serene-core-server 0.1.1

package/dist/src/models/users/external-user-integration-model.d.ts

@@ -0,0 +1,36 @@
+import { PrismaClient } from '@/prisma/client';
+export declare class ExternalUserIntegrationModel {
+    clName: string;
+    create(prisma: PrismaClient, userProfileId: string, externalIntegrationUserId: string, externalIntegration: string): Promise<{
+        id: string;
+        userProfileId: string;
+        externalIntegrationUserId: string;
+        externalIntegration: string;
+    }>;
+    deleteById(prisma: PrismaClient, id: string): Promise<{
+        id: string;
+        userProfileId: string;
+        externalIntegrationUserId: string;
+        externalIntegration: string;
+    } | undefined>;
+    filter(prisma: PrismaClient, userProfileId: string | undefined, externalIntegrationUserId: string | undefined, externalIntegration: string | undefined): Promise<{
+        id: string;
+        userProfileId: string;
+        externalIntegrationUserId: string;
+        externalIntegration: string;
+    }[]>;
+    getById(prisma: PrismaClient, id: string): Promise<any>;
+    getByUniqueKey(prisma: PrismaClient, externalIntegrationUserId: string, externalIntegration: string): Promise<any>;
+    update(prisma: PrismaClient, id: string, userProfileId: string | undefined, externalIntegrationUserId: string | undefined, externalIntegration: string | undefined): Promise<{
+        id: string;
+        userProfileId: string;
+        externalIntegrationUserId: string;
+        externalIntegration: string;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, userProfileId: string | undefined, externalIntegrationUserId: string | undefined, externalIntegration: string | undefined): Promise<{
+        id: string;
+        userProfileId: string;
+        externalIntegrationUserId: string;
+        externalIntegration: string;
+    }>;
+}

package/dist/src/models/users/external-user-integration-model.js

@@ -0,0 +1,167 @@
+export class ExternalUserIntegrationModel {
+    // Consts
+    clName = 'ExternalUserIntegrationModel';
+    // Code
+    async create(prisma, userProfileId, externalIntegrationUserId, externalIntegration) {
+        // Debug
+        const fnName = `${this.clName}.create()`;
+        // Create record
+        try {
+            return await prisma.externalUserIntegration.create({
+                data: {
+                    userProfileId: userProfileId,
+                    externalIntegrationUserId: externalIntegrationUserId,
+                    externalIntegration: externalIntegration
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async deleteById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.deleteById()`;
+        // Delete
+        try {
+            return await prisma.externalUserIntegration.delete({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+    }
+    async filter(prisma, userProfileId, externalIntegrationUserId, externalIntegration) {
+        // Debug
+        const fnName = `${this.clName}.filter()`;
+        // Query
+        try {
+            return await prisma.externalUserIntegration.findMany({
+                where: {
+                    userProfileId: userProfileId,
+                    externalIntegrationUserId: externalIntegrationUserId,
+                    externalIntegration: externalIntegration
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async getById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.getById()`;
+        // Query
+        var externalUserIntegration = null;
+        try {
+            externalUserIntegration = await prisma.externalUserIntegration.findUnique({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Return
+        return externalUserIntegration;
+    }
+    async getByUniqueKey(prisma, externalIntegrationUserId, externalIntegration) {
+        // Debug
+        const fnName = `${this.clName}.getByUniqueKey()`;
+        // Validate
+        if (externalIntegrationUserId == null) {
+            console.error(`${fnName}: externalIntegrationUserId is null`);
+            throw 'Prisma error';
+        }
+        if (externalIntegration == null) {
+            console.error(`${fnName}: externalIntegration is null`);
+            throw 'Prisma error';
+        }
+        // Query
+        var externalUserIntegration = null;
+        try {
+            externalUserIntegration = await prisma.externalUserIntegration.findFirst({
+                where: {
+                    externalIntegrationUserId: externalIntegrationUserId,
+                    externalIntegration: externalIntegration
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Return
+        return externalUserIntegration;
+    }
+    async update(prisma, id, userProfileId, externalIntegrationUserId, externalIntegration) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Update record
+        try {
+            return await prisma.externalUserIntegration.update({
+                data: {
+                    userProfileId: userProfileId,
+                    externalIntegrationUserId: externalIntegrationUserId,
+                    externalIntegration: externalIntegration
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, userProfileId, externalIntegrationUserId, externalIntegration) {
+        // Debug
+        const fnName = `${this.clName}.upsert()`;
+        // If id isn't specified, but the unique keys are, try to get the record
+        if (id == null &&
+            externalIntegrationUserId != null &&
+            externalIntegration != null) {
+            const externalUserIntegration = await this.getByUniqueKey(prisma, externalIntegrationUserId, externalIntegration);
+            if (externalUserIntegration != null) {
+                id = externalUserIntegration.id;
+            }
+        }
+        // Upsert
+        if (id == null) {
+            // Validate for create (mainly for type validation of the create call)
+            if (userProfileId == null) {
+                console.error(`${fnName}: id is null and userProfileId is null`);
+                throw 'Prisma error';
+            }
+            if (externalIntegrationUserId == null) {
+                console.error(`${fnName}: id is null and externalIntegrationUserId is null`);
+                throw 'Prisma error';
+            }
+            if (externalIntegration == null) {
+                console.error(`${fnName}: id is null and externalIntegration is null`);
+                throw 'Prisma error';
+            }
+            // Create
+            return await this.create(prisma, userProfileId, externalIntegrationUserId, externalIntegration);
+        }
+        else {
+            // Update
+            return await this.update(prisma, id, userProfileId, externalIntegrationUserId, externalIntegration);
+        }
+    }
+}

package/dist/src/models/users/user-error-model.d.ts

@@ -0,0 +1,54 @@
+import { PrismaClient } from '@/prisma/client';
+export declare class UserErrorModel {
+    clName: string;
+    create(prisma: PrismaClient, userErrorSummaryId: string, userProfileId: string, endUserProfileId: string | null, instanceId: string | null, origin: string, message: string, techMessage: string | null): Promise<{
+        message: string;
+        id: string;
+        origin: string;
+        userProfileId: string;
+        created: Date;
+        updated: Date;
+        instanceId: string | null;
+        userErrorSummaryId: string;
+        endUserProfileId: string | null;
+        techMessage: string | null;
+    }>;
+    deleteByUserErrorSummaryId(prisma: PrismaClient, userErrorSummaryId: string): Promise<import("@/prisma/index").Prisma.BatchPayload>;
+    deleteByUserProfileId(prisma: PrismaClient, userProfileId: string): Promise<import("@/prisma/index").Prisma.BatchPayload>;
+    filter(prisma: PrismaClient, userErrorSummaryId: string | undefined, userProfileId: string | undefined, endUserProfileId: string | null | undefined, instanceId: string | null | undefined, origin: string | undefined): Promise<{
+        message: string;
+        id: string;
+        origin: string;
+        userProfileId: string;
+        created: Date;
+        updated: Date;
+        instanceId: string | null;
+        userErrorSummaryId: string;
+        endUserProfileId: string | null;
+        techMessage: string | null;
+    }[]>;
+    update(prisma: PrismaClient, id: string, userErrorSummaryId: string | undefined, userProfileId: string | undefined, endUserProfileId: string | null | undefined, instanceId: string | null | undefined, origin: string | undefined, message: string | undefined, techMessage: string | null | undefined): Promise<{
+        message: string;
+        id: string;
+        origin: string;
+        userProfileId: string;
+        created: Date;
+        updated: Date;
+        instanceId: string | null;
+        userErrorSummaryId: string;
+        endUserProfileId: string | null;
+        techMessage: string | null;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, userErrorSummaryId: string | undefined, userProfileId: string | undefined, endUserProfileId: string | null | undefined, instanceId: string | null | undefined, origin: string | undefined, message: string | undefined, techMessage: string | null | undefined): Promise<{
+        message: string;
+        id: string;
+        origin: string;
+        userProfileId: string;
+        created: Date;
+        updated: Date;
+        instanceId: string | null;
+        userErrorSummaryId: string;
+        endUserProfileId: string | null;
+        techMessage: string | null;
+    }>;
+}

package/dist/src/models/users/user-error-model.js

@@ -0,0 +1,146 @@
+export class UserErrorModel {
+    // Consts
+    clName = 'UserErrorModel';
+    // Code
+    async create(prisma, userErrorSummaryId, userProfileId, endUserProfileId, instanceId, origin, message, techMessage) {
+        // Debug
+        const fnName = `${this.clName}.filter()`;
+        // Create
+        try {
+            return await prisma.userError.create({
+                data: {
+                    userErrorSummaryId: userErrorSummaryId,
+                    userProfileId: userProfileId,
+                    endUserProfileId: endUserProfileId,
+                    instanceId: instanceId,
+                    origin: origin,
+                    message: message,
+                    techMessage: techMessage
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async deleteByUserErrorSummaryId(prisma, userErrorSummaryId) {
+        // Debug
+        const fnName = `${this.clName}.deleteByUserErrorSummaryId()`;
+        // Query
+        try {
+            return await prisma.userError.deleteMany({
+                where: {
+                    userErrorSummaryId: userErrorSummaryId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw `Prisma error`;
+        }
+    }
+    async deleteByUserProfileId(prisma, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.deleteByUserProfileId()`;
+        // Query
+        try {
+            return await prisma.userError.deleteMany({
+                where: {
+                    userProfileId: userProfileId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw `Prisma error`;
+        }
+    }
+    async filter(prisma, userErrorSummaryId, userProfileId, endUserProfileId, instanceId, origin) {
+        // Debug
+        const fnName = `${this.clName}.filter()`;
+        // Query
+        try {
+            return await prisma.userError.findMany({
+                where: {
+                    userErrorSummaryId: userErrorSummaryId,
+                    userProfileId: userProfileId,
+                    endUserProfileId: endUserProfileId,
+                    instanceId: instanceId,
+                    origin: origin
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw `Prisma error`;
+        }
+    }
+    async update(prisma, id, userErrorSummaryId, userProfileId, endUserProfileId, instanceId, origin, message, techMessage) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Create
+        try {
+            return await prisma.userError.update({
+                data: {
+                    userErrorSummaryId: userErrorSummaryId,
+                    userProfileId: userProfileId,
+                    endUserProfileId: endUserProfileId,
+                    instanceId: instanceId,
+                    origin: origin,
+                    message: message,
+                    techMessage: techMessage
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, userErrorSummaryId, userProfileId, endUserProfileId, instanceId, origin, message, techMessage) {
+        // Debug
+        const fnName = `${this.clName}.upsert()`;
+        // Upsert
+        if (id == null) {
+            // Validate for create (mainly for type validation of the create call)
+            if (userErrorSummaryId == null) {
+                console.error(`${fnName}: id is null and userErrorSummaryId is null`);
+                throw 'Prisma error';
+            }
+            if (userProfileId == null) {
+                console.error(`${fnName}: id is null and userProfileId is null`);
+                throw 'Prisma error';
+            }
+            if (endUserProfileId === undefined) {
+                console.error(`${fnName}: id is null and endUserProfileId is undefined`);
+                throw 'Prisma error';
+            }
+            if (instanceId === undefined) {
+                console.error(`${fnName}: id is null and instanceId is undefined`);
+                throw 'Prisma error';
+            }
+            if (origin == null) {
+                console.error(`${fnName}: id is null and origin is null`);
+                throw 'Prisma error';
+            }
+            if (message == null) {
+                console.error(`${fnName}: id is null and message is null`);
+                throw 'Prisma error';
+            }
+            if (techMessage === undefined) {
+                console.error(`${fnName}: id is null and techMessage is undefined`);
+                throw 'Prisma error';
+            }
+            // Create
+            return await this.create(prisma, userErrorSummaryId, userProfileId, endUserProfileId, instanceId, origin, message, techMessage);
+        }
+        else {
+            // Update
+            return await this.update(prisma, id, userErrorSummaryId, userProfileId, endUserProfileId, instanceId, origin, message, techMessage);
+        }
+    }
+}

package/dist/src/models/users/user-error-summary-model.d.ts

@@ -0,0 +1,45 @@
+import { PrismaClient } from '@/prisma/client';
+export declare class UserErrorSummaryModel {
+    clName: string;
+    create(prisma: PrismaClient, userProfileId: string, instanceId: string | null, origin: string | null, message: string, count: number): Promise<{
+        message: string;
+        id: string;
+        origin: string | null;
+        count: number;
+        userProfileId: string;
+        instanceId: string | null;
+    }>;
+    deleteByUserProfileId(prisma: PrismaClient, userProfileId: string): Promise<import("@/prisma/index").Prisma.BatchPayload>;
+    filter(prisma: PrismaClient, userProfileId: string | undefined, instanceId: string | null | undefined, origin: string | null | undefined): Promise<{
+        message: string;
+        id: string;
+        origin: string | null;
+        count: number;
+        userProfileId: string;
+        instanceId: string | null;
+    }[]>;
+    getByUniqueKey(prisma: PrismaClient, userProfileId: string, instanceId: string | null, origin: string | null | undefined, message: string): Promise<{
+        message: string;
+        id: string;
+        origin: string | null;
+        count: number;
+        userProfileId: string;
+        instanceId: string | null;
+    } | null>;
+    update(prisma: PrismaClient, id: string, userProfileId: string | undefined, instanceId: string | null | undefined, origin: string | null | undefined, message: string | undefined, count: number | undefined): Promise<{
+        message: string;
+        id: string;
+        origin: string | null;
+        count: number;
+        userProfileId: string;
+        instanceId: string | null;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, userProfileId: string | undefined, instanceId: string | null | undefined, origin: string | null | undefined, message: string | undefined, count: number | undefined): Promise<{
+        message: string;
+        id: string;
+        origin: string | null;
+        count: number;
+        userProfileId: string;
+        instanceId: string | null;
+    }>;
+}

package/dist/src/models/users/user-error-summary-model.js

@@ -0,0 +1,145 @@
+export class UserErrorSummaryModel {
+    // Consts
+    clName = 'UserErrorSummaryModel';
+    // Code
+    async create(prisma, userProfileId, instanceId, origin, message, count) {
+        // Debug
+        const fnName = `${this.clName}.filter()`;
+        // Create
+        try {
+            return await prisma.userErrorSummary.create({
+                data: {
+                    userProfileId: userProfileId,
+                    instanceId: instanceId,
+                    origin: origin,
+                    message: message,
+                    count: count
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async deleteByUserProfileId(prisma, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.deleteByUserProfileId()`;
+        // Query
+        try {
+            return await prisma.userErrorSummary.deleteMany({
+                where: {
+                    userProfileId: userProfileId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw `Prisma error`;
+        }
+    }
+    async filter(prisma, userProfileId, instanceId, origin) {
+        // Debug
+        const fnName = `${this.clName}.filter()`;
+        // Query
+        try {
+            return await prisma.userErrorSummary.findMany({
+                where: {
+                    userProfileId: userProfileId,
+                    instanceId: instanceId,
+                    origin: origin
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw `Prisma error`;
+        }
+    }
+    async getByUniqueKey(prisma, userProfileId, instanceId, origin, message) {
+        // Debug
+        const fnName = `${this.clName}.getByUniqueKey()`;
+        // Query
+        try {
+            return await prisma.userErrorSummary.findFirst({
+                where: {
+                    userProfileId: userProfileId,
+                    instanceId: instanceId,
+                    origin: origin,
+                    message: message
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw `Prisma error`;
+        }
+    }
+    async update(prisma, id, userProfileId, instanceId, origin, message, count) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Create
+        try {
+            return await prisma.userErrorSummary.update({
+                data: {
+                    userProfileId: userProfileId,
+                    instanceId: instanceId,
+                    origin: origin,
+                    message: message,
+                    count: count
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, userProfileId, instanceId, origin, message, count) {
+        // Debug
+        const fnName = `${this.clName}.upsert()`;
+        // Try to get by the unique key
+        if (id == null &&
+            userProfileId != null &&
+            instanceId !== undefined &&
+            message != null) {
+            const userErrorSummary = await this.getByUniqueKey(prisma, userProfileId, instanceId, origin, message);
+            if (userErrorSummary != null) {
+                id = userErrorSummary.id;
+            }
+        }
+        // Upsert
+        if (id == null) {
+            // Validate for create (mainly for type validation of the create call)
+            if (userProfileId == null) {
+                console.error(`${fnName}: id is null and userProfileId is null`);
+                throw 'Prisma error';
+            }
+            if (instanceId === undefined) {
+                console.error(`${fnName}: id is null and instanceId is undefined`);
+                throw 'Prisma error';
+            }
+            if (origin === undefined) {
+                console.error(`${fnName}: id is null and origin is undefined`);
+                throw 'Prisma error';
+            }
+            if (message == null) {
+                console.error(`${fnName}: id is null and message is null`);
+                throw 'Prisma error';
+            }
+            if (count == null) {
+                console.error(`${fnName}: id is null and count is null`);
+                throw 'Prisma error';
+            }
+            // Create
+            return await this.create(prisma, userProfileId, instanceId, origin, message, count);
+        }
+        else {
+            // Update
+            return await this.update(prisma, id, userProfileId, instanceId, origin, message, count);
+        }
+    }
+}

package/dist/src/models/users/user-group-member-model.d.ts

@@ -0,0 +1,41 @@
+import { PrismaClient } from '@/prisma/client';
+export declare class UserGroupMemberModel {
+    clName: string;
+    create(prisma: PrismaClient, userGroupId: string, userProfileId: string, isGroupAdmin: boolean): Promise<{
+        id: string;
+        userProfileId: string;
+        created: Date;
+        userGroupId: string;
+        isGroupAdmin: boolean;
+    }>;
+    delete(prisma: PrismaClient, id: string): Promise<{
+        id: string;
+        userProfileId: string;
+        created: Date;
+        userGroupId: string;
+        isGroupAdmin: boolean;
+    }>;
+    filter(prisma: PrismaClient, userGroupId: string | undefined, isGroupAdmin: boolean | undefined): Promise<{
+        id: string;
+        userProfileId: string;
+        created: Date;
+        userGroupId: string;
+        isGroupAdmin: boolean;
+    }[]>;
+    getById(prisma: PrismaClient, id: string): Promise<any>;
+    getByUniqueKey(prisma: PrismaClient, userGroupId: string, userProfileId: string): Promise<any>;
+    update(prisma: PrismaClient, id: string, userGroupId: string | undefined, userProfileId: string | undefined, isGroupAdmin: boolean | undefined): Promise<{
+        id: string;
+        userProfileId: string;
+        created: Date;
+        userGroupId: string;
+        isGroupAdmin: boolean;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, userGroupId: string | undefined, userProfileId: string | undefined, isGroupAdmin: boolean | undefined): Promise<{
+        id: string;
+        userProfileId: string;
+        created: Date;
+        userGroupId: string;
+        isGroupAdmin: boolean;
+    }>;
+}