serene-core-server 0.1.1

package/dist/src/services/users/profile-service.js

@@ -0,0 +1,385 @@
+import { CustomError } from '../../types/errors';
+import { UserModel } from '../../models/users/user-model';
+import { UserPreferenceModel } from '../../models/users/user-preference-model';
+import { UserProfileModel } from '../../models/users/user-profile-model';
+import { countries } from '../locale/countries';
+import { UserPreferenceService } from '../user-preference/service';
+export class ProfileService {
+    // Consts
+    clName = 'ProfileService';
+    // billingAddress = 'billing address'
+    personalDetails = 'personal details';
+    firstName = 'first name';
+    fullName = 'full name';
+    lastName = 'last name'; // For legacy compatibility with old Chargebee code in Serene Store
+    countryCode = 'country code';
+    /* billingNameAsMyName = 'billing name as my name'
+    billingCountryAsMyCountry = 'billing country as my country'
+    billingCountryCode = 'billing country code'
+    billingFirstName = 'billing first name'
+    billingLastName = 'billing last name'
+    billingAddressLine1 = 'billing address line 1'
+    billingAddressLine2 = 'billing address line 2'
+    billingCity = 'billing city'
+    billingState = 'billing state'
+    billingZip = 'billing zip' */
+    // Models
+    userModel = new UserModel();
+    userProfileModel = new UserProfileModel();
+    userPreferenceModel = new UserPreferenceModel();
+    // Code
+    userPreferenceService = new UserPreferenceService();
+    // Code
+    async getAll(prisma, userProfileId) {
+        // Get userPreference records
+        const userPreferences = await this.userPreferenceService.getUserPreferences(prisma, userProfileId, this.personalDetails, [this.firstName,
+            this.fullName,
+            this.countryCode]);
+        /* const userPreferences = await
+          this.userPreferenceService.getUserPreferences(
+            prisma,
+            userProfileId,
+            this.billingAddress,
+            [ this.firstName,
+              this.lastName,
+              this.countryCode,
+              this.billingNameAsMyName,
+              this.billingCountryAsMyCountry,
+              this.billingCountryCode,
+              this.billingFirstName,
+              this.billingLastName,
+              this.billingAddressLine1,
+              this.billingAddressLine2,
+              this.billingCity,
+              this.billingState,
+              this.billingZip ]) */
+        var userPreferenceMap = [];
+        for (const userPreference of userPreferences) {
+            userPreferenceMap[userPreference.key] = userPreference;
+        }
+        return userPreferenceMap;
+    }
+    getCountryCodeByName(country) {
+        for (const countryIter of countries) {
+            if (countryIter.name === country) {
+                return countryIter.code;
+            }
+        }
+        return null;
+    }
+    async update(prisma, userProfileId, firstName, fullName, countryCode) {
+        // Get userPreference records
+        const userPreferenceService = new UserPreferenceService();
+        // Upsert all records
+        await this.userPreferenceModel.upsert(prisma, undefined, // id
+        userProfileId, this.personalDetails, this.firstName, firstName, null);
+        await this.userPreferenceModel.upsert(prisma, undefined, // id
+        userProfileId, this.personalDetails, this.fullName, fullName, null);
+        await this.userPreferenceModel.upsert(prisma, undefined, // id
+        userProfileId, this.personalDetails, this.countryCode, countryCode, null);
+        /* await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingNameAsMyName,
+                billingNameAsMyName.toString(),
+                null)
+    
+        await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingCountryAsMyCountry,
+                billingCountryAsMyCountry.toString(),
+                null)
+    
+        await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingCountryCode,
+                billingCountryCode,
+                null)
+    
+        await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingFirstName,
+                billingFirstName,
+                null)
+    
+        await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingLastName,
+                billingLastName,
+                null)
+    
+        await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingAddressLine1,
+                billingAddressLine1,
+                null)
+    
+        await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingAddressLine2,
+                billingAddressLine2,
+                null)
+    
+        await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingCity,
+                billingCity,
+                null)
+    
+        await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingState,
+                billingState,
+                null)
+    
+        await this.userPreferenceModel.upsert(
+                prisma,
+                undefined,  // id
+                userProfileId,
+                this.billingAddress,
+                this.billingZip,
+                billingZip,
+                null) */
+    }
+    async updateViaRestApi({ req, res }, prisma) {
+        // Debug
+        const fnName = `${this.clName}.updateViaRestApi()`;
+        // Get body
+        const body = req.body;
+        // Validate
+        if (!body.userProfileId) {
+            return res.status(200).json({
+                status: false,
+                msg: 'UserProfileId was not found'
+            });
+        }
+        if (!body.firstName) {
+            return res.status(200).json({
+                status: false,
+                msg: 'First name not specified'
+            });
+        }
+        if (!body.fullName) {
+            return res.status(200).json({
+                status: false,
+                msg: 'Full name not specified'
+            });
+        }
+        if (!body.country) {
+            return res.status(200).json({
+                status: false,
+                msg: 'Country not specified'
+            });
+        }
+        /* if (!body.billingNameAsMyName) {
+          return res.status(200).json(
+            {
+              status: false,
+              msg: 'Billing name as my name not specified'
+            })
+        }
+    
+        if (!body.billingCountryAsMyCountry) {
+          return res.status(200).json(
+            {
+              status: false,
+              msg: 'Billing country as my country not specified'
+            })
+        }
+    
+        if (body.billingNameAsMyName === 'false' &&
+          !body.billingFirstName) {
+          return res.status(200).json(
+            {
+              status: false,
+              msg: 'Billing first name not specified'
+            })
+        }
+    
+        if (body.billingNameAsMyName === 'false' &&
+          !body.billingLastName) {
+          return res.status(200).json(
+            {
+              status: false,
+              msg: 'Billing last name not specified'
+            })
+        }
+    
+        if (body.billingCountryAsMyCountry === 'false' &&
+          !body.billingCountry) {
+          return res.status(200).json(
+            {
+              status: false,
+              msg: 'Billing country not specified'
+            })
+        }
+    
+        if (!body.billingAddressLine1) {
+          return res.status(200).json(
+            {
+              status: false,
+              msg: 'Billing address line 1 not specified'
+            })
+        }
+    
+        if (!body.billingCity) {
+          return res.status(200).json(
+            {
+              status: false,
+              msg: 'Billing city not specified'
+            })
+        }
+    
+        if (!body.billingZip) {
+          return res.status(200).json(
+            {
+              status: false,
+              msg: 'Billing zip not specified'
+            })
+        }
+    
+        console.log(`.  body.zip: ${body.zip}`) */
+        // Get UserProfile record
+        const userProfile = await this.userProfileModel.getById(prisma, body.userProfileId);
+        // Get country codes for countries
+        const countryCode = this.getCountryCodeByName(body.country);
+        // const billingCountryCode = this.getCountryCodeByName(body.billingCountry)
+        // Update the user profile
+        await this.update(prisma, body.userProfileId, body.firstName, body.fullName, countryCode);
+        // Validate
+        if (userProfile == null) {
+            throw new CustomError(`${fnName}: userProfile == null`);
+        }
+        if (userProfile.userId == null) {
+            throw new CustomError(`${fnName}: userProfile.userId == null`);
+        }
+        // Update the User
+        await this.userModel.update(prisma, userProfile.userId, undefined, // email
+        body.fullName);
+        // Respond
+        return res.status(200).json({
+            status: true,
+            msg: 'OK'
+        });
+    }
+    async validateProfileCompleted(prisma, forAction, userProfileId) {
+        const userPreferences = await this.getAll(prisma, userProfileId);
+        return this.validateRequiredFields(forAction, userPreferences);
+    }
+    validateRequiredFields(forAction, userPreferences) {
+        // If for a scription, no fields are required (only the email sign-up)
+        if (forAction === 'subscription') {
+            return {
+                status: true
+            };
+        }
+        // Validate required fields
+        if (!userPreferences[this.firstName]) {
+            return {
+                status: false,
+                message: 'First name is missing for the user'
+            };
+        }
+        if (!userPreferences[this.fullName]) {
+            return {
+                status: false,
+                message: 'Full name is missing for the user'
+            };
+        }
+        if (!userPreferences[this.countryCode]) {
+            return {
+                status: false,
+                message: 'Country is missing for the user'
+            };
+        }
+        /* if (!userPreferences[this.billingNameAsMyName]) {
+          return {
+            status: false,
+            message: 'Billing name as my name checked (or not) is missing for the user'
+          }
+        }
+    
+        if (!userPreferences[this.billingCountryAsMyCountry]) {
+          return {
+            status: false,
+            message: 'Billing country as my country checked (or not) is missing for the user'
+          }
+        }
+    
+        if (userPreferences[this.billingNameAsMyName] === 'false') {
+          if (!userPreferences[this.billingFirstName]) {
+            return {
+              status: false,
+              message: 'Billing first name is missing for the user'
+            }
+          }
+    
+          if (!userPreferences[this.billingLastName]) {
+            return {
+              status: false,
+              message: 'Billing last name is missing for the user'
+            }
+          }
+        }
+    
+        if (userPreferences[this.billingCountryAsMyCountry] === 'false') {
+          if (!userPreferences[this.billingCountryCode]) {
+            return {
+              status: false,
+              message: 'Billing country is missing for the user'
+            }
+          }
+        }
+    
+        if (!userPreferences[this.billingAddressLine1]) {
+          return {
+            status: false,
+            message: 'Billing address line 1 is missing for the user'
+          }
+        }
+    
+        if (!userPreferences[this.billingCity]) {
+          return {
+            status: false,
+            message: 'Billing city is missing for the user'
+          }
+        }
+    
+        if (!userPreferences[this.billingZip]) {
+          return {
+            status: false,
+            message: 'Billing zip is missing for the user'
+          }
+        } */
+        // Validated OK
+        return {
+            status: true
+        };
+    }
+}

package/dist/src/services/users/service.d.ts

@@ -0,0 +1,64 @@
+import { PrismaClient } from '@/prisma/client';
+import { UserProfileModel } from '../../models/users/user-profile-model';
+import { UserModel } from '../../models/users/user-model';
+import { UserPreferenceService } from '../user-preference/service';
+export declare class UsersService {
+    clName: string;
+    userModel: UserModel;
+    userProfileModel: UserProfileModel;
+    userPreferenceService: UserPreferenceService;
+    createBlankUser(prisma: PrismaClient): Promise<{
+        id: string;
+        userId: string | null;
+        created: Date;
+        updated: Date;
+        isAdmin: boolean;
+        ownerType: string | null;
+        roles: string[];
+        deletePending: Date | null;
+    }>;
+    createDefaultUserPreferences(prisma: PrismaClient, userProfileId: string, defaultUserPreferences: string | undefined): Promise<void>;
+    createUserByEmail(prisma: PrismaClient, email: string): Promise<string>;
+    getById(prisma: PrismaClient, userProfileId: string): Promise<{
+        id: string;
+        userId: string | null;
+        created: Date;
+        updated: Date;
+        isAdmin: boolean;
+        ownerType: string | null;
+        roles: string[];
+        deletePending: Date | null;
+    } | null | undefined>;
+    getUserByUserProfileId(prisma: PrismaClient, userProfileId: string): Promise<{
+        name: string | null;
+        id: string;
+        image: string | null;
+        email: string | null;
+        emailVerified: Date | null;
+    } | null | undefined>;
+    getOrCreateSignedOutUser(prisma: PrismaClient, signedOutId: string, defaultUserPreferences: string): Promise<{
+        id: string;
+    }>;
+    getOrCreateUserByEmail(prisma: PrismaClient, email: string, defaultUserPreferences: string | undefined): Promise<{
+        id: string;
+        userId: string | null;
+        created: Date;
+        updated: Date;
+        isAdmin: boolean;
+        ownerType: string | null;
+        roles: string[];
+        deletePending: Date | null;
+    }>;
+    getUserProfileByEmail(prisma: PrismaClient, email: string): Promise<{
+        id: string;
+        userId: string | null;
+        created: Date;
+        updated: Date;
+        isAdmin: boolean;
+        ownerType: string | null;
+        roles: string[];
+        deletePending: Date | null;
+    } | null | undefined>;
+    verifyHumanUserProfile(prisma: PrismaClient, userProfileId: string): Promise<void>;
+    verifySignedInUserProfileId(prisma: PrismaClient, userProfileId: string): Promise<boolean>;
+}

package/dist/src/services/users/service.js

@@ -0,0 +1,152 @@
+import { CustomError } from '../../types/errors';
+import { UserProfileModel } from '../../models/users/user-profile-model';
+import { UserModel } from '../../models/users/user-model';
+import { UserPreferenceService } from '../user-preference/service';
+export class UsersService {
+    // Consts
+    clName = 'UsersService';
+    // Models
+    userModel = new UserModel();
+    userProfileModel = new UserProfileModel();
+    // Services
+    userPreferenceService = new UserPreferenceService();
+    // Code
+    async createBlankUser(prisma) {
+        // console.log('UsersService.createBlankUser(): start')
+        return await this.userProfileModel.create(prisma, null, // userId
+        false, // isAdmin
+        null); // deletePending
+    }
+    async createDefaultUserPreferences(prisma, userProfileId, defaultUserPreferences) {
+        // console.log('createDefaultUserPreferences()')
+        if (defaultUserPreferences == null ||
+            defaultUserPreferences === '') {
+            return;
+        }
+        const jsonArray = JSON.parse(defaultUserPreferences);
+        for (const json of jsonArray) {
+            await this.userPreferenceService.createIfNotExists(prisma, userProfileId, json.category, json.key, json.value, null);
+        }
+    }
+    async createUserByEmail(prisma, email) {
+        const user = await this.userModel.create(prisma, email, undefined); // name
+        const userProfile = await this.userProfileModel.create(prisma, user.id, false, // isAdmin
+        null); // deletePending
+        return userProfile.id;
+    }
+    async getById(prisma, userProfileId) {
+        return await this.userProfileModel.getById(prisma, userProfileId);
+    }
+    async getUserByUserProfileId(prisma, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.getUserByUserProfileId()`;
+        // Get userProfile
+        const userProfile = await this.getById(prisma, userProfileId);
+        // Validate
+        if (userProfile == null) {
+            throw new CustomError(`${fnName}: userProfile == null`);
+        }
+        // Get user record
+        if (userProfile.userId == null) {
+            return null;
+        }
+        else {
+            return await this.userModel.getById(prisma, userProfile.userId);
+        }
+    }
+    async getOrCreateSignedOutUser(prisma, signedOutId, defaultUserPreferences) {
+        // Debug
+        const fnName = `${this.clName}.getOrCreateSignedOutUser()`;
+        // User id exists, use it
+        var userProfile = null;
+        var signedOutUserProfile = {
+            id: signedOutId
+        };
+        if (signedOutId != null) {
+            // console.log(`${fnName}: getting user..`)
+            userProfile = await this.getById(prisma, signedOutId);
+            if (userProfile) {
+                if (userProfile.id) {
+                    signedOutUserProfile = userProfile;
+                }
+            }
+        }
+        if (userProfile == null) {
+            // Create user record
+            // console.log(`${fnName}: creating user..`)
+            const userProfile = await this.createBlankUser(prisma);
+            // console.log(`${fnName}: userProfileId: ${userProfile.id}`)
+            signedOutUserProfile = userProfile;
+            signedOutId = userProfile.id;
+        }
+        // Create default user preferences
+        await this.createDefaultUserPreferences(prisma, signedOutId, defaultUserPreferences);
+        // Return signedOutId
+        return signedOutUserProfile;
+    }
+    async getOrCreateUserByEmail(prisma, email, defaultUserPreferences) {
+        // Debug
+        const fnName = `${this.clName}.getOrCreateUserByEmail()`;
+        // console.log(`UsersService.getOrCreateUserByEmail(): email: ${email}`)
+        // Get/create user record
+        var signedInUser = await this.userModel.getByEmail(prisma, email);
+        if (signedInUser == null) {
+            signedInUser = await this.userModel.create(prisma, email, undefined); // name
+        }
+        // Get/create userProfile record
+        // console.log(`UsersService.getOrCreateUserByEmail(): get userProfile ` +
+        //             `records where signedInUser.id = ${signedInUser.id}`)
+        var signedInUserProfile = await this.userProfileModel.getByUserId(prisma, signedInUser.id);
+        // console.log(`signedInUserProfile: ` + JSON.stringify(signedInUserProfile))
+        if (signedInUserProfile == null) {
+            // Create userProfile record
+            signedInUserProfile = await this.userProfileModel.create(prisma, signedInUser.id, // userId
+            false, // isAdmin
+            null); // deletePending
+        }
+        // Create default user preferences
+        await this.createDefaultUserPreferences(prisma, signedInUserProfile.id, defaultUserPreferences);
+        return signedInUserProfile;
+    }
+    async getUserProfileByEmail(prisma, email) {
+        // console.log(`UsersService.getUserProfileByEmail(): emailLower: ${emailLower}`)
+        const user = await this.userModel.getByEmail(prisma, email);
+        if (user == null) {
+            return null;
+        }
+        else {
+            return await this.userProfileModel.getByUserId(prisma, user.id);
+        }
+    }
+    async verifyHumanUserProfile(prisma, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.verifyHumanUserProfile()`;
+        // Get UserProfile record
+        const userProfile = await this.getById(prisma, userProfileId);
+        // Validate
+        if (userProfile == null) {
+            throw new CustomError(`${fnName}: userProfile == null`);
+        }
+        // Verify human roleOwnerType, or set if none
+        if (userProfile.ownerType == null) {
+            await this.userProfileModel.setOwnerType(prisma, userProfile);
+        }
+    }
+    async verifySignedInUserProfileId(prisma, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.verifySignedInUserProfileId()`;
+        // Get UserProfile
+        const userProfile = await this.userProfileModel.getById(prisma, userProfileId);
+        // Validate
+        if (userProfile == null) {
+            throw new CustomError(`${fnName}: userProfile == null`);
+        }
+        // Return
+        if (userProfile.userId == null) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+}

package/dist/src/services/users/user-error-service.d.ts

@@ -0,0 +1,4 @@
+import { PrismaClient } from '@/prisma/client';
+export declare class UserErrorService {
+    upsert(prisma: PrismaClient, userProfileId: string, endUserProfileId: string | null, instanceId: string | null, summaryMessage: string | undefined, origin: string, message: string, techMessage: string | null): Promise<void>;
+}

package/dist/src/services/users/user-error-service.js

@@ -0,0 +1,27 @@
+import { UserErrorModel } from '../../models/users/user-error-model';
+import { UserErrorSummaryModel } from '../../models/users/user-error-summary-model';
+// Models
+const userErrorModel = new UserErrorModel();
+const userErrorSummaryModel = new UserErrorSummaryModel();
+// Class
+export class UserErrorService {
+    async upsert(prisma, userProfileId, endUserProfileId, instanceId, summaryMessage, origin, message, techMessage) {
+        // If the summaryMessage isn't specified, set it to the message
+        if (summaryMessage == null) {
+            summaryMessage = message;
+        }
+        // Get the existing UserErrorSummary if it exists
+        var userErrorSummary = await userErrorSummaryModel.getByUniqueKey(prisma, userProfileId, instanceId, origin, summaryMessage);
+        // Create/update UserErrorSummary
+        if (userErrorSummary == null) {
+            // Create
+            userErrorSummary = await userErrorSummaryModel.create(prisma, userProfileId, instanceId, origin, summaryMessage, 1); // count
+        }
+        else {
+            // Inc count
+            userErrorSummary = await userErrorSummaryModel.update(prisma, userErrorSummary.id, undefined, undefined, undefined, undefined, userErrorSummary.count + 1);
+        }
+        // Create UserError
+        const userError = await userErrorModel.create(prisma, userErrorSummary.id, userProfileId, endUserProfileId, instanceId, origin, message, techMessage);
+    }
+}

package/dist/src/services/users/users-group-service.d.ts

@@ -0,0 +1,16 @@
+import { PrismaClient } from '@/prisma/client';
+import { UserGroupMemberModel } from '../../models/users/user-group-member-model';
+import { UserGroupModel } from '../../models/users/user-group-model';
+export declare class UsersGroupService {
+    clName: string;
+    externalUsersGroupName: string;
+    userGroupMemberModel: UserGroupMemberModel;
+    userGroupModel: UserGroupModel;
+    verifyGroupMemberByOwner(prisma: PrismaClient, memberUserProfileId: string, ownerUserProfileId: string, groupName: string): Promise<{
+        status: boolean;
+        message: string;
+    } | {
+        status: boolean;
+        message?: undefined;
+    }>;
+}