2 files changed, 111 insertions, 8 deletions

diff --git a/src/server/authentication/models/current_user_utils.ts b/src/server/authentication/models/current_user_utils.ts
new file mode 100644
index 000000000..0ac85b446
--- /dev/null
+++ b/src/server/authentication/models/current_user_utils.ts
@@ -0,0 +1,102 @@
+import { DashUserModel } from "./user_model";
+import * as rp from 'request-promise';
+import { RouteStore } from "../../RouteStore";
+import { ServerUtils } from "../../ServerUtil";
+import { Server } from "../../../client/Server";
+import { Document } from "../../../fields/Document";
+import { KeyStore } from "../../../fields/KeyStore";
+import { ListField } from "../../../fields/ListField";
+import { Documents } from "../../../client/documents/Documents";
+import { Schema, Attribute, AttributeGroup, Catalog } from "../../../client/northstar/model/idea/idea";
+import { observable, computed, action } from "mobx";
+import { ArrayUtil } from "../../../client/northstar/utils/ArrayUtil";
+
+export class CurrentUserUtils {
+    private static curr_email: string;
+    private static curr_id: string;
+    private static user_document: Document;
+    //TODO tfs: these should be temporary...
+    private static mainDocId: string | undefined;
+    @observable private static catalog?: Catalog;
+
+    public static get email(): string {
+        return this.curr_email;
+    }
+
+    public static get id(): string {
+        return this.curr_id;
+    }
+
+    public static get UserDocument(): Document {
+        return this.user_document;
+    }
+
+    public static get MainDocId(): string | undefined {
+        return this.mainDocId;
+    }
+
+    public static set MainDocId(id: string | undefined) {
+        this.mainDocId = id;
+    }
+
+    @computed public static get NorthstarDBCatalog(): Catalog | undefined {
+        return this.catalog;
+    }
+    public static set NorthstarDBCatalog(ctlog: Catalog | undefined) {
+        this.catalog = ctlog;
+    }
+    public static GetNorthstarSchema(name: string): Schema | undefined {
+        return !this.catalog || !this.catalog.schemas ? undefined :
+            ArrayUtil.FirstOrDefault<Schema>(this.catalog.schemas, (s: Schema) => s.displayName === name);
+    }
+    public static GetAllNorthstarColumnAttributes(schema: Schema) {
+        if (!schema || !schema.rootAttributeGroup) {
+            return [];
+        }
+        const recurs = (attrs: Attribute[], g: AttributeGroup) => {
+            if (g.attributes) {
+                attrs.push.apply(attrs, g.attributes);
+                if (g.attributeGroups) {
+                    g.attributeGroups.forEach(ng => recurs(attrs, ng));
+                }
+            }
+        };
+        const allAttributes: Attribute[] = new Array<Attribute>();
+        recurs(allAttributes, schema.rootAttributeGroup);
+        return allAttributes;
+    }
+
+    private static createUserDocument(id: string): Document {
+        let doc = new Document(id);
+
+        doc.Set(KeyStore.Workspaces, new ListField<Document>());
+        doc.Set(KeyStore.OptionalRightCollection, Documents.SchemaDocument([], { title: "Pending documents" }))
+        return doc;
+    }
+
+    public static loadCurrentUser(): Promise<any> {
+        let userPromise = rp.get(ServerUtils.prepend(RouteStore.getCurrUser)).then((response) => {
+            if (response) {
+                let obj = JSON.parse(response);
+                CurrentUserUtils.curr_id = obj.id as string;
+                CurrentUserUtils.curr_email = obj.email as string;
+            } else {
+                throw new Error("There should be a user! Why does Dash think there isn't one?")
+            }
+        });
+        let userDocPromise = rp.get(ServerUtils.prepend(RouteStore.getUserDocumentId)).then(id => {
+            if (id) {
+                return Server.GetField(id).then(field => {
+                    if (field instanceof Document) {
+                        this.user_document = field;
+                    } else {
+                        this.user_document = this.createUserDocument(id);
+                    }
+                })
+            } else {
+                throw new Error("There should be a user id! Why does Dash think there isn't one?")
+            }
+        });
+        return Promise.all([userPromise, userDocPromise]);
+    }
+}
\ No newline at end of file
diff --git a/src/server/authentication/models/User.ts b/src/server/authentication/models/user_model.ts
index 9752c4260..81580aad5 100644
--- a/src/server/authentication/models/User.ts
+++ b/src/server/authentication/models/user_model.ts
@@ -1,6 +1,5 @@
 //@ts-ignore
 import * as bcrypt from "bcrypt-nodejs";
-import * as crypto from "crypto";
 //@ts-ignore
 import * as mongoose from "mongoose";
 var url = 'mongodb://localhost:27017/Dash'
@@ -16,12 +15,13 @@ mongoose.connection.on('error', function (error) {
 mongoose.connection.on('disconnected', function () {
     console.log('connection closed');
 });
-export type UserModel = mongoose.Document & {
+export type DashUserModel = mongoose.Document & {
     email: string,
     password: string,
-    passwordResetToken: string,
-    passwordResetExpires: Date,
-    tokens: AuthToken[],
+    passwordResetToken: string | undefined,
+    passwordResetExpires: Date | undefined,
+
+    userDocumentId: string;
 
     profile: {
         name: string,
@@ -47,10 +47,11 @@ const userSchema = new mongoose.Schema({
     passwordResetToken: String,
     passwordResetExpires: Date,
 
+    userDocumentId: String,
+
     facebook: String,
     twitter: String,
     google: String,
-    tokens: Array,
 
     profile: {
         name: String,
@@ -65,7 +66,7 @@ const userSchema = new mongoose.Schema({
  * Password hash middleware.
  */
 userSchema.pre("save", function save(next) {
-    const user = this as UserModel;
+    const user = this as DashUserModel;
     if (!user.isModified("password")) { return next(); }
     bcrypt.genSalt(10, (err, salt) => {
         if (err) { return next(err); }
@@ -77,7 +78,7 @@ userSchema.pre("save", function save(next) {
     });
 });
 
-const comparePassword: comparePasswordFunction = function (this: UserModel, candidatePassword, cb) {
+const comparePassword: comparePasswordFunction = function (this: DashUserModel, candidatePassword, cb) {
     bcrypt.compare(candidatePassword, this.password, (err: mongoose.Error, isMatch: boolean) => {
         cb(err, isMatch);
     });