Add support for user registration

Author: skadefro

OpenFlow/src/Config.ts

@@ -10,6 +10,7 @@ export class Config {
     public static db:DatabaseConnection = null;
     public static auto_create_users:boolean = Config.parseBoolean(Config.getEnv("auto_create_users", "false"));
     public static auto_create_domains:string[] = Config.parseArray(Config.getEnv("auto_create_domains", ""));
+    public static allow_user_registration:boolean = Config.parseBoolean(Config.getEnv("allow_user_registration", "false"));
 
     public static api_bypass_perm_check:boolean = Config.parseBoolean(Config.getEnv("api_bypass_perm_check", "false"));
     public static websocket_package_size:number = parseInt(Config.getEnv("websocket_package_size", "1024"), 10);

OpenFlow/src/Messages/Message.ts

@@ -20,6 +20,7 @@ import { MapReduceMessage } from "./MapReduceMessage";
 import { CloseQueueMessage } from "./CloseQueueMessage";
 import { RegisterQueueMessage } from "./RegisterQueueMessage";
 import { QueueMessage } from "./QueueMessage";
+import { RegisterUserMessage } from "./RegisterUserMessage";
 
 export class Message {
     public id: string;
@@ -95,6 +96,9 @@ export class Message {
                 case "signin":
                     this.Signin(cli);
                     break;
+                case "registeruser":
+                    this.RegisterUser(cli);
+                    break;
                 case "mapreduce":
                     this.MapReduce(cli);
                     break;
@@ -407,6 +411,22 @@ export class Message {
         }
         this.Send(cli);
     }
+    private async RegisterUser(cli: WebSocketClient): Promise<void> {
+        this.Reply();
+        var msg: RegisterUserMessage;
+        var user:User;
+        try {
+            msg = RegisterUserMessage.assign(this.data);
+            user = await User.FindByUsername(msg.username);
+            if(user!==null && user !== undefined) { throw new Error("Illegal username"); }
+            user = await User.ensureUser(msg.name, msg.username, msg.password, null);
+            msg.user = new TokenUser(user);
+        } catch (error) {
+            this.data = "";
+            msg.error = error.toString();
+        }
+        this.Send(cli);
+    }
 }
 
 export class JSONfn {

OpenFlow/src/Messages/RegisterUserMessage.ts

@@ -0,0 +1,18 @@
+import { Base } from "../base";
+import { TokenUser } from "../TokenUser";
+
+export class RegisterUserMessage implements IReplyMessage {
+    public error: string;
+    public jwt:any;
+
+    public user:TokenUser;
+    public name:string;
+    public username:string;
+    public password:string;
+    static assign(o:any):RegisterUserMessage {
+        if (typeof o === "string" || o instanceof String) {
+            return Object.assign(new RegisterUserMessage(), JSON.parse(o.toString()));
+        }
+        return Object.assign(new RegisterUserMessage(), o);
+    }
+}

OpenFlow/src/User.ts

@@ -112,5 +112,18 @@ export class User extends Base {
             });
         }
     }
+
+    public static async ensureUser(name:string, username:string, password:string, id:string):Promise<User> {
+        var user:User = await User.FindByUsernameOrId(username, id);
+        if(user!==null && (user._id === id || id === null)) { return user; }
+        if(user!==null && id !== null ) { await Config.db.DeleteOne(user._id, "users", TokenUser.rootToken()); }
+        user  = new User(); user._id = id; user.name = name; user.username = username;
+        if(password===null || password===undefined || password === "") { password = Math.random().toString(36).substr(2, 9); }
+        await user.SetPassword(password);
+        user = await Config.db.InsertOne(user, "users", TokenUser.rootToken());
+        user = User.assign(user);
+        return user;
+    }
+    
 }
 

OpenFlow/src/public/Controllers.ts

@@ -442,6 +442,13 @@ module openflow {
                 this.loadData();
             });
         }
+        async DeleteOne(model: any):Promise<any> {
+            this.loading = true;
+            await this.api.Delete(this.collection, model);
+            this.models = this.models.filter(function (m: any):boolean { return m._id!==model._id;});
+            this.loading = false;
+            if (!this.$scope.$$phase) { this.$scope.$apply(); }
+        }
         async DeleteMany():Promise<void> {
             this.loading = true;
             var Promises:Promise<DeleteOneMessage>[] = [];