limitations on registrations and a single team mode

Author: rafiki270

Sources/ApiCore/ApiCoreBase.swift

@@ -74,6 +74,14 @@ public class ApiCoreBase {
                     } else {
                         // Create default configuration
                         _configuration = Configuration(
+                            general: Configuration.General(
+                                singleTeam: false
+                            ),
+                            auth: Configuration.Auth(
+                                allowRegistrations: true,
+                                allowInvitations: true,
+                                allowedDomainsForRegistration: []
+                            ),
                             server: Configuration.Server(
                                 name: "API Core!",
                                 url: nil,

Sources/ApiCore/Config/Configuration.swift

@@ -18,6 +18,51 @@ public final class Configuration: Configurable {
         case invalidConfigurationData
     }
 
+    /// General
+    public final class General: Codable {
+        
+        /// Single team server (all team functionality will be disabled, all new users will be automatically assigned to the main team if enabled)
+        /// (disabled by default)
+        public internal(set) var singleTeam: Bool
+        
+        enum CodingKeys: String, CodingKey {
+            case singleTeam = "single_team"
+        }
+        
+        /// Initializer
+        init(singleTeam: Bool) {
+            self.singleTeam = singleTeam
+        }
+        
+    }
+    
+    /// Authentication
+    public final class Auth: Codable {
+        
+        /// Allow new registrations (enabled by default)
+        public internal(set) var allowRegistrations: Bool
+        
+        /// Allow new registrations (enabled by default)
+        public internal(set) var allowInvitations: Bool
+        
+        /// Domains allowed to go through a self-registration process
+        public internal(set) var allowedDomainsForRegistration: [String]
+        
+        enum CodingKeys: String, CodingKey {
+            case allowRegistrations = "allow_registrations"
+            case allowInvitations = "allow_invitations"
+            case allowedDomainsForRegistration = "registration_domains"
+        }
+        
+        /// Initializer
+        init(allowRegistrations: Bool, allowInvitations: Bool, allowedDomainsForRegistration: [String]) {
+            self.allowRegistrations = allowRegistrations
+            self.allowInvitations = allowInvitations
+            self.allowedDomainsForRegistration = allowedDomainsForRegistration
+        }
+        
+    }
+    
     /// Sertver info
     public final class Server: Codable {
 
@@ -183,6 +228,12 @@ public final class Configuration: Configurable {
 
     }
 
+    /// General settings
+    public internal(set) var general: General
+    
+    /// Authentication settings
+    public internal(set) var auth: Auth
+    
     /// Server info
     public internal(set) var server: Server
 
@@ -199,6 +250,8 @@ public final class Configuration: Configurable {
     public internal(set) var storage: Storage
 
     enum CodingKeys: String, CodingKey {
+        case general
+        case auth
         case server
         case jwtSecret = "jwt_secret"
         case database
@@ -207,7 +260,9 @@ public final class Configuration: Configurable {
     }
 
     /// Initialization
-    public init(server: Server, jwtSecret: String, database: Database, mail: Mail, storage: Storage) {
+    public init(general: General, auth: Auth, server: Server, jwtSecret: String, database: Database, mail: Mail, storage: Storage) {
+        self.general = general
+        self.auth = auth
         self.server = server
         self.jwtSecret = jwtSecret
         self.database = database
@@ -224,7 +279,14 @@ extension Configuration {
     public func loadEnv() {
         // Root
         load("apicore.jwt_secret", to: &jwtSecret)
-
+        
+        // General
+        load("apicore.general.single_team", to: &general.singleTeam)
+        
+        // Auth
+        load("apicore.auth.allow_registrations", to: &auth.allowRegistrations)
+        load("apicore.auth.allow_invitations", to: &auth.allowInvitations)
+        
         // Mail
         load("apicore.mail.email", to: &mail.email)
 

Sources/ApiCore/Controllers/AuthController.swift

@@ -175,7 +175,7 @@ public class AuthController: Controller {
                         passwordError = (error as? FrontendError) ?? AuthError.invalidPassword(reason: .generic)
                     }
 
-                    // If no error save
+                    // If there is no error, save
                     if passwordError == nil {
                         user.password = try password.password.passwordHash(req)
                         user.verified = true

Sources/ApiCore/Controllers/InstallController.swift

@@ -39,15 +39,15 @@ public class InstallController: Controller {
 
     /// Setup routes
     public static func boot(router: Router) throws {
-        router.get("install") { (req)->Future<Response> in
+        router.get("install") { req->Future<Response> in
             return try install(on: req)
         }
 
-        router.get("uninstall") { (req)->Future<Response> in
+        router.get("uninstall") { req->Future<Response> in
             return try uninstall(on: req)
         }
 
-        router.get("reinstall") { (req)->Future<Response> in
+        router.get("reinstall") { req->Future<Response> in
             return try uninstall(on: req).flatMap(to: Response.self) { _ in
                 return try install(on: req).map(to: Response.self) { _ in
                     return try req.response.maintenanceFinished(message: "Re-installation finished, login as [email protected]/admin")

Sources/ApiCore/Controllers/LogsController.swift

@@ -21,7 +21,7 @@ public class LogsController: Controller {
     /// Setup routes
     public static func boot(router: Router) throws {
         // Print out logged errors
-        router.get("errors") { (req) -> Future<[ErrorLog]> in
+        router.get("errors") { req -> Future<[ErrorLog]> in
             return ErrorLog.query(on: req).sort(\ErrorLog.added, .descending).all()
         }
 

Sources/ApiCore/Controllers/TeamsController.swift

@@ -19,6 +19,9 @@ class TeamsController: Controller {
     /// Error
     enum Error: FrontendError {
 
+        /// User has not been found
+        case singleTeamConfiguration
+        
         /// User has not been found
         case userNotFound
 
@@ -41,6 +44,8 @@ class TeamsController: Controller {
         /// Erro code
         var identifier: String {
             switch self {
+            case .singleTeamConfiguration:
+                return "team_error.single_team_configuration"
             case .userNotFound:
                 return "team_error.user_not_found"
             case .cantAddYourself:
@@ -59,6 +64,8 @@ class TeamsController: Controller {
         /// Error reason
         var reason: String {
             switch self {
+            case .singleTeamConfiguration:
+                return "Server is running in a single team configuration"
             case .userNotFound:
                 return "User not found"
             case .cantAddYourself:
@@ -93,19 +100,22 @@ class TeamsController: Controller {
 
     /// Setup routes
     static func boot(router: Router) throws {
-        router.get("teams") { (req) -> Future<[Team]> in
+        router.get("teams") { req -> Future<[Team]> in
             let me = try req.me.user()
             return try me.teams.query(on: req).paginate(on: req).all().map({ teams in
                 return teams
             })
         }
 
-        router.get("teams", DbIdentifier.parameter) { (req) -> Future<Team> in
+        router.get("teams", DbIdentifier.parameter) { req -> Future<Team> in
             let id = try req.parameters.next(DbIdentifier.self)
             return try req.me.verifiedTeam(id: id)
         }
 
-        router.post("teams") { (req) -> Future<Response> in
+        router.post("teams") { req -> Future<Response> in
+            guard ApiCoreBase.configuration.general.singleTeam == false else {
+                throw Error.singleTeamConfiguration
+            }
             return try req.content.decode(Team.New.self).flatMap(to: Response.self) { newTeam in
                 return try Team.exists(identifier: newTeam.identifier, on: req).flatMap(to: Response.self) { identifierExists in
                     if identifierExists {
@@ -124,7 +134,10 @@ class TeamsController: Controller {
             }
         }   
 
-        router.post("teams", "check") { (req) -> Future<Response> in
+        router.post("teams", "check") { req -> Future<Response> in
+            guard ApiCoreBase.configuration.general.singleTeam == false else {
+                throw Error.singleTeamConfiguration
+            }
             return try req.content.decode(Team.Identifier.self).flatMap(to: Response.self) { identifierObject in
                 return try Team.exists(identifier: identifierObject.identifier, on: req).map(to: Response.self) { identifierExists in
                     if identifierExists {
@@ -135,7 +148,10 @@ class TeamsController: Controller {
             }
         }
 
-        router.put("teams", DbIdentifier.parameter) { (req) -> Future<Team> in
+        router.put("teams", DbIdentifier.parameter) { req -> Future<Team> in
+            guard ApiCoreBase.configuration.general.singleTeam == false else {
+                throw Error.singleTeamConfiguration
+            }
             let id = try req.parameters.next(DbIdentifier.self)
             return try req.me.verifiedTeam(id: id).flatMap(to: Team.self, { team in
                 return try req.content.decode(Team.New.self).flatMap(to: Team.self) { newTeam in
@@ -166,26 +182,46 @@ class TeamsController: Controller {
             }
         }
 
-        router.get("teams", DbIdentifier.parameter, "users") { (req) -> Future<[User]> in
+        router.get("teams", DbIdentifier.parameter, "users") { req -> Future<[User]> in
             let id = try req.parameters.next(DbIdentifier.self)
             return try req.me.verifiedTeam(id: id).flatMap(to: [User].self) { (team) -> Future<[User]> in
                 return try team.users.query(on: req).paginate(on: req).all()
             }
         }
 
-        router.post("teams", DbIdentifier.parameter, "link") { (req) -> Future<Response> in
+        router.post("teams", DbIdentifier.parameter, "link") { req -> Future<Response> in
+            guard ApiCoreBase.configuration.general.singleTeam == false else {
+                throw Error.singleTeamConfiguration
+            }
             return try processLinking(request: req, action: .link)
         }
 
-        router.post("teams", DbIdentifier.parameter, "unlink") { (req) -> Future<Response> in
+        router.post("teams", DbIdentifier.parameter, "unlink") { req -> Future<Response> in
+            guard ApiCoreBase.configuration.general.singleTeam == false else {
+                throw Error.singleTeamConfiguration
+            }
             return try processLinking(request: req, action: .unlink)
         }
 
-        router.delete("teams", DbIdentifier.parameter) { (req) -> Future<Response> in
+        router.delete("teams", DbIdentifier.parameter) { req -> Future<Response> in
+            guard ApiCoreBase.configuration.general.singleTeam == false else {
+                throw Error.singleTeamConfiguration
+            }
             // TODO: Reload JWT token if successful with new info
             // QUESTION: Should we make sure user has at least one team?
             let teamId = try req.parameters.next(DbIdentifier.self)
             return try req.me.verifiedTeam(id: teamId).flatMap(to: Response.self) { (team) -> Future<Response> in
+                // Common delete function
+                func delete(team: Team, request req: Request) throws -> Future<Response> {
+                    if team.admin {
+                        throw Error.unableToDeleteAdminTeam
+                    }
+                    // TODO: Cascade through all team data (that is not shared with other teams, possibly delete users too?) !!!!!!
+                    return team.delete(on: req).map(to: Response.self, { (_) -> Response in
+                        return try req.response.deleted()
+                    })
+                }
+                
                 if let canDelete = ApiCoreBase.deleteTeamWarning {
                     return canDelete(team).flatMap(to: Response.self, { (error) -> Future<Response> in
                         guard let error = error else {
@@ -206,17 +242,6 @@ class TeamsController: Controller {
 
 extension TeamsController {
 
-    /// Delete team
-    private static func delete(team: Team, request req: Request) throws -> Future<Response> {
-        if team.admin {
-            throw Error.unableToDeleteAdminTeam
-        }
-        // TODO: Cascade through all team data (that is not shared with other teams, possibly delete users too?) !!!!!!
-        return team.delete(on: req).map(to: Response.self, { (_) -> Response in
-            return try req.response.deleted()
-        })
-    }
-    
     /// Process linking from a request
     private static func processLinking(request req: Request, action: TeamsController.LinkAction) throws -> Future<Response> {
         let teamId = try req.parameters.next(DbIdentifier.self)