profile-update

server/config.ts

@@ -6,8 +6,16 @@ export const PERMISSIONS = {
   CAN_SEE_ALL_USERS: 'CAN_SEE_ALL_USERS',
   CAN_ACCESS_DASHBOARD_PAGE: 'CAN_ACCESS_DASHBOARD_PAGE',
   CAN_UPDATE_SETTINGS: 'CAN_UPDATE_SETTINGS',
+  CAN_ACCESS_SETTINGS: 'CAN_ACCESS_SETTINGS',
+  CAN_ACCESS_EMAIL_TEMPLATES: 'CAN_ACCESS_EMAIL_TEMPLATES',
 };
 
+export enum ROLE_RANK {
+  ADMIN = 1,
+  USER,
+  BLOCKED,
+}
+
 export const CONFIG = {
   SiteName: 'JIBC',
 };

server/methods/roles.method.ts

 import { Meteor } from 'meteor/meteor';
 import { first } from 'rxjs/operators';
 import { rolesCollection } from '../collections/role.collection';
-import { PERMISSIONS } from '../config';
+import { PERMISSIONS, ROLE_RANK } from '../config';
 import { RoleModel } from '../models/role.model';
 import { UtilsService } from '../services/utils.service';
 
@@ -17,4 +17,8 @@ Meteor.methods({
       throw new Meteor.Error('Unable to add.', JSON.stringify(e));
     }
   },
+
+  getRoleSlug(id): ROLE_RANK {
+    return rolesCollection.findOne(id).Slug;
+  },
 });

server/methods/settings.method.ts

@@ -19,4 +19,19 @@ Meteor.methods({
       throw new Meteor.Error(403, 'Not Enough Permissions');
     }
   },
+
+  updateEmailTemplates(setting: any): void {
+    if (UtilsService.hasPermission(PERMISSIONS.CAN_UPDATE_SETTINGS)) {
+      settingsCollection.update(setting.id, {
+        $set: {
+          Value: {
+            SUBJECT: setting.subject,
+            CONTENT: setting.content,
+          },
+        },
+      });
+    } else {
+      throw new Meteor.Error(403, 'Not Enough Permissions');
+    }
+  },
 });

server/methods/users.method.ts

@@ -28,13 +28,24 @@ Meteor.methods({
         },
       };
       const userId = Accounts.createUser(userObj);
-      EmailService.sendVerificationEmail(user, userId);
+      const usr = Accounts.findUserByUsername(user.username);
+      EmailService.sendVerificationEmail(usr, userId);
 
       return userId;
     }
     throw new Meteor.Error(422, 'Email address already in use.');
   },
 
+  verifyEmailAddress(user: any): any {
+    if (Accounts.findUserByEmail(user.email)) {
+      const usr = Accounts.findUserByEmail(user.email);
+      EmailService.sendVerificationEmail(usr, user._id, user.email);
+
+      return true;
+    }
+    throw new Meteor.Error(422, 'Email address already in use.');
+  },
+
   updateUser(user: any): any {
     if (!UtilsService.hasPermission(PERMISSIONS.CAN_UPDATE_OWN_USER)) {
       throw new Meteor.Error(403, 'Forbidden.');
@@ -50,6 +61,34 @@ Meteor.methods({
     }
   },
 
+  addEmailAddress(user: any): any {
+    if (!UtilsService.hasPermission(PERMISSIONS.CAN_UPDATE_OWN_USER)) {
+      throw new Meteor.Error(403, 'Forbidden.');
+    }
+
+    if (Accounts.findUserByEmail(user.email)) {
+      throw new Meteor.Error(422, 'Email address already in use.');
+    }
+
+    if (user._id && user.email) {
+      Accounts.addEmail(user._id, user.email);
+      return true;
+    }
+    throw new Meteor.Error(500, 'Email Address is missing.');
+  },
+
+  removeEmailAddress(user: any): any {
+    if (!UtilsService.hasPermission(PERMISSIONS.CAN_UPDATE_OWN_USER)) {
+      throw new Meteor.Error(403, 'Forbidden.');
+    }
+
+    if (user._id && user.email) {
+      Accounts.removeEmail(user._id, user.email);
+      return true;
+    }
+    throw new Meteor.Error(500, 'Email Address is missing.');
+  },
+
   checkUserByEmail(email: string): any {
     return Accounts.findUserByEmail(email);
   },

server/migrations.ts

 import { settingsCollection } from './collections/setting.collections';
-import { PERMISSIONS } from './config';
+import { PERMISSIONS, ROLE_RANK } from './config';
 import { rolesCollection } from './collections/role.collection';
 import { Meteor } from 'meteor/meteor';
 
@@ -15,16 +15,19 @@ Migrations.add({
         title: 'Admin',
         permissions: allPermissions,
         description: '',
+        Slug: ROLE_RANK.ADMIN,
       });
       rolesCollection.insert({
         title: 'User',
         permissions: [PERMISSIONS.CAN_LOGIN, PERMISSIONS.CAN_UPDATE_OWN_USER],
         description: '',
+        Slug: ROLE_RANK.USER,
       });
       rolesCollection.insert({
         title: 'Blocked',
         permissions: [],
         description: '',
+        Slug: ROLE_RANK.BLOCKED,
       });
     } else {
       rolesCollection.update({ title: 'Admin' }, { $set: { permissions: allPermissions } });
@@ -35,18 +38,27 @@ Migrations.add({
 // @ts-ignore
 Migrations.add({
   version: 2,
-  name: 'Adding Admin User',
+  name: 'Adding Admin & User',
   up() {
     if (!Meteor.users.find({}).fetch().length) {
       Accounts.createUser({
         username: 'admin',
-        password: 'admin',
+        password: 'Admin123',
         email: 'ali.arshad@vqode.com',
         profile: {
           name: 'Admin User',
           role: rolesCollection.findOne({ title: 'Admin' })._id,
         },
       });
+      Accounts.createUser({
+        username: 'lead',
+        password: 'Qweasdzxc1',
+        email: 'lead@mailinator.com',
+        profile: {
+          name: 'Lead',
+          role: rolesCollection.findOne({ title: 'User' })._id,
+        },
+      });
     }
   },
 });

server/models/role.model.ts

+import { ROLE_RANK } from '../config';
+
 export interface RoleModel {
   _id?: string;
   title: string;
   permissions: string[];
+  Slug: ROLE_RANK;
   description: string;
 }

server/publications/settings.publication.ts

 import { settingsCollection } from '../collections/setting.collections';
+import { UtilsService } from '../services/utils.service';
+import { PERMISSIONS } from '../config';
+import { Meteor } from 'meteor/meteor';
 
-Meteor.publish('settings', () => settingsCollection.find({}));
+Meteor.publish('settings', () => {
+  if (UtilsService.hasPermission(PERMISSIONS.CAN_ACCESS_SETTINGS)) {
+    return settingsCollection.find({});
+  }
+  throw new Meteor.Error(403, 'Not Enough Permissions');
+});
+
+Meteor.publish('email-templates', () => {
+  if (UtilsService.hasPermission(PERMISSIONS.CAN_ACCESS_EMAIL_TEMPLATES)) {
+    return settingsCollection.find({ IsEmail: true });
+  }
+  throw new Meteor.Error(403, 'Not Enough Permissions');
+});

server/services/email.service.ts

 import { CONFIG } from '../config';
 import { settingsCollection } from '../collections/setting.collections';
+import { rolesCollection } from "../collections/role.collection";
 
 export class EmailService {
-  static sendVerificationEmail(user: any, userId: string): void {
+  static sendVerificationEmail(user: any, userId: string, email = false): void {
     Accounts.emailTemplates.siteName = CONFIG.SiteName;
+    const defaultRole = rolesCollection.findOne(user.profile.role);
     // Will uncomment it later with domain email
     // Accounts.emailTemplates.from = CONFIG.DomainEmail;
 
@@ -16,13 +18,15 @@ export class EmailService {
         const token = url.substr(url.lastIndexOf('/') + 1);
         const link = `${process.env.appUrl}#/auth/verify-email/${token}`;
         const content: any = settingsCollection.findOne({ Key: 'REGISTER' });
-        return content.Value.CONTENT.replace(/\$name/g, user.name)
-          .replace(/\$role/g, user.role)
+        return content.Value.CONTENT.replace(/\$name/g, user.profile.name)
+          .replace(/\$role/g, defaultRole.title)
           .replace(/\$link/g, link);
       },
     };
+    const mail = email ? email : user.emails[0].address;
+    console.log(mail, userId);
 
-    Accounts.sendVerificationEmail(userId, user.email);
+    Accounts.sendVerificationEmail(userId, mail);
   }
 
   static sendForgotPasswordEmail(user: Meteor.User, email: string): void {