Upload folder using huggingface_hub (part 10)

libraries/nestjs-libraries/src/chat/tools/integration.validation.tool.ts

@@ -0,0 +1,114 @@
+import { AgentToolInterface } from '@gitroom/nestjs-libraries/chat/agent.tool.interface';
+import { createTool } from '@mastra/core/tools';
+import { z } from 'zod';
+import { Injectable } from '@nestjs/common';
+import {
+  IntegrationManager,
+  socialIntegrationList,
+} from '@gitroom/nestjs-libraries/integrations/integration.manager';
+import { getValidationSchemas } from '@gitroom/nestjs-libraries/chat/validation.schemas.helper';
+import { checkAuth } from '@gitroom/nestjs-libraries/chat/auth.context';
+
+@Injectable()
+export class IntegrationValidationTool implements AgentToolInterface {
+  constructor(private _integrationManager: IntegrationManager) {}
+  name = 'integrationSchema';
+
+  run() {
+    return createTool({
+      id: 'integrationSchema',
+      description: `Everytime we want to schedule a social media post, we need to understand the schema of the integration.
+         This tool helps us get the schema of the integration.
+         Sometimes we might get a schema back the requires some id, for that, you can get information from 'tools'
+         And use the triggerTool function.
+        `,
+      mcp: {
+        annotations: {
+          title: 'Get Integration Schema',
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false,
+        },
+      },
+      inputSchema: z.object({
+        isPremium: z
+          .boolean()
+          .describe('is this the user premium? if not, set to false'),
+        platform: z
+          .string()
+          .describe(
+            `platform identifier (${socialIntegrationList
+              .map((p) => p.identifier)
+              .join(', ')})`
+          ),
+      }),
+      outputSchema: z.object({
+        output: z.object({
+          rules: z.string(),
+          maxLength: z
+            .number()
+            .describe('The maximum length of a post / comment'),
+          settings: z
+            .any()
+            .describe('List of settings need to be passed to schedule a post'),
+          tools: z
+            .array(
+              z.object({
+                description: z.string().describe('Description of the tool'),
+                methodName: z
+                  .string()
+                  .describe('Method to call to get the information'),
+                dataSchema: z
+                  .array(
+                    z.object({
+                      key: z
+                        .string()
+                        .describe('Name of the settings key to pass'),
+                      description: z
+                        .string()
+                        .describe('Description of the setting key'),
+                      type: z.string(),
+                    })
+                  )
+                  .describe(
+                    'This will be passed to schedulePostTool [output:settings]'
+                  ),
+              })
+            )
+            .describe(
+              "Sometimes settings require some id, tags and stuff, if you don't have, trigger the `triggerTool` function from the tools list [output:callable-tools]"
+            ),
+        }),
+      }),
+      execute: async (inputData, context) => {
+        checkAuth(inputData, context);
+        const integration = socialIntegrationList.find(
+          (p) => p.identifier === inputData.platform
+        )!;
+
+        if (!integration) {
+          return {
+            output: { rules: '', maxLength: 0, settings: {}, tools: [] },
+          };
+        }
+
+        const maxLength = integration.maxLength(inputData.isPremium);
+        const schemas = !integration.dto
+          ? false
+          : getValidationSchemas()[integration.dto.name];
+        const tools = this._integrationManager.getAllTools();
+        const rules = this._integrationManager.getAllRulesDescription();
+
+        return {
+          output: {
+            rules: rules[integration.identifier],
+            maxLength,
+            settings: !schemas ? 'No additional settings required' : schemas,
+            tools: tools[integration.identifier],
+          },
+        };
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/chat/tools/tool.list.ts

@@ -0,0 +1,23 @@
+import { IntegrationValidationTool } from '@gitroom/nestjs-libraries/chat/tools/integration.validation.tool';
+import { IntegrationTriggerTool } from '@gitroom/nestjs-libraries/chat/tools/integration.trigger.tool';
+import { IntegrationSchedulePostTool } from './integration.schedule.post';
+import { GenerateVideoOptionsTool } from '@gitroom/nestjs-libraries/chat/tools/generate.video.options.tool';
+import { VideoFunctionTool } from '@gitroom/nestjs-libraries/chat/tools/video.function.tool';
+import { GenerateVideoTool } from '@gitroom/nestjs-libraries/chat/tools/generate.video.tool';
+import { GenerateImageTool } from '@gitroom/nestjs-libraries/chat/tools/generate.image.tool';
+import { IntegrationListTool } from '@gitroom/nestjs-libraries/chat/tools/integration.list.tool';
+import { GroupListTool } from '@gitroom/nestjs-libraries/chat/tools/group.list.tool';
+import { UploadFromUrlTool } from '@gitroom/nestjs-libraries/chat/tools/upload.from.url.tool';
+
+export const toolList = [
+  IntegrationListTool,
+  GroupListTool,
+  IntegrationValidationTool,
+  IntegrationTriggerTool,
+  IntegrationSchedulePostTool,
+  GenerateVideoOptionsTool,
+  VideoFunctionTool,
+  GenerateVideoTool,
+  GenerateImageTool,
+  UploadFromUrlTool,
+];

libraries/nestjs-libraries/src/chat/tools/upload.from.url.tool.ts

@@ -0,0 +1,145 @@
+import { AgentToolInterface } from '@gitroom/nestjs-libraries/chat/agent.tool.interface';
+import { createTool } from '@mastra/core/tools';
+import { z } from 'zod';
+import { Injectable } from '@nestjs/common';
+import { MediaService } from '@gitroom/nestjs-libraries/database/prisma/media/media.service';
+import { UploadFactory } from '@gitroom/nestjs-libraries/upload/upload.factory';
+import { getMaxSize } from '@gitroom/nestjs-libraries/upload/custom.upload.validation';
+import { checkAuth } from '@gitroom/nestjs-libraries/chat/auth.context';
+import { ssrfSafeDispatcher } from '@gitroom/nestjs-libraries/dtos/webhooks/ssrf.safe.dispatcher';
+import { Readable } from 'stream';
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { fromBuffer } = require('file-type');
+
+// Same allow-list as the public API /upload-from-url route.
+const ALLOWED_MIME = new Set<string>([
+  'image/jpeg',
+  'image/png',
+  'image/gif',
+  'image/webp',
+  'image/avif',
+  'image/bmp',
+  'image/tiff',
+  'video/mp4',
+]);
+
+@Injectable()
+export class UploadFromUrlTool implements AgentToolInterface {
+  private storage = UploadFactory.createStorage();
+
+  constructor(private _mediaService: MediaService) {}
+  name = 'uploadFromUrlTool';
+
+  run() {
+    return createTool({
+      id: 'uploadFromUrlTool',
+      description: `Upload a remote image or video into the media library from a public URL.
+Use this before scheduling a post when the user provides an external media URL (not already hosted on our domain),
+so the attachment passes the upload-domain validation. Returns the hosted media { id, path } to use as an attachment, or { error } on failure.`,
+      mcp: {
+        annotations: {
+          title: 'Upload Media From URL',
+          readOnlyHint: false,
+          destructiveHint: false,
+          idempotentHint: false,
+          openWorldHint: true,
+        },
+      },
+      inputSchema: z.object({
+        url: z
+          .string()
+          .url()
+          .describe('The public URL of the image or video to upload'),
+      }),
+      // Mastra validates a tool's return against this schema, so it must also
+      // allow the graceful { error } shape. Fields are optional (rather than
+      // wrapping everything in an `output` union) to keep the change minimal:
+      // the existing { id, path } success return and the new { error } return
+      // both validate without rewriting every return statement.
+      outputSchema: z.object({
+        id: z.string().optional(),
+        path: z.string().optional(),
+        error: z.string().optional(),
+      }),
+      execute: async (inputData, context) => {
+        checkAuth(inputData, context);
+        try {
+          const org = JSON.parse(
+            (context?.requestContext as any)?.get('organization') as string
+          );
+
+          const response = await fetch(inputData.url, {
+            // @ts-ignore — undici option, not in lib.dom fetch types
+            dispatcher: ssrfSafeDispatcher,
+          });
+
+          if (!response.ok) {
+            return { error: 'Failed to fetch URL' };
+          }
+
+          // Guard against OOM: bail out before buffering the whole body into
+          // memory. Content-Length may be absent or wrong, so we re-check the
+          // real size after download too. The type isn't known yet (sniffed
+          // below), so the pre-check uses the largest allowed cap (video).
+          const maxDownloadSize = getMaxSize('video/mp4');
+          const declaredSize = Number(response.headers.get('content-length'));
+          if (declaredSize && declaredSize > maxDownloadSize) {
+            return {
+              error: `File is too large: ${declaredSize} bytes (max ${maxDownloadSize} bytes).`,
+            };
+          }
+
+          const buffer = Buffer.from(await response.arrayBuffer());
+          const detected = await fromBuffer(buffer);
+          if (!detected || !ALLOWED_MIME.has(detected.mime)) {
+            return { error: 'Unsupported file type.' };
+          }
+
+          const maxSize = getMaxSize(detected.mime);
+          if (buffer.length > maxSize) {
+            return {
+              error: `File is too large: ${buffer.length} bytes (max ${maxSize} bytes).`,
+            };
+          }
+
+          const getFile = await this.storage.uploadFile({
+            buffer,
+            mimetype: detected.mime,
+            size: buffer.length,
+            path: '',
+            fieldname: '',
+            destination: '',
+            stream: new Readable(),
+            filename: '',
+            originalname: `upload.${detected.ext}`,
+            encoding: '',
+          });
+
+          return await this._mediaService.saveFile(
+            org.id,
+            getFile.originalname,
+            getFile.path
+          );
+        } catch (err) {
+          // undici's fetch rejects with a generic TypeError('fetch failed')
+          // and hides the real reason (DNS, TLS, SSRF block, ...) in
+          // err.cause, so surface it for the agent. Error.cause isn't in the
+          // es2020 lib typings this repo compiles against, hence the cast.
+          const cause =
+            err instanceof Error
+              ? (err as Error & { cause?: unknown }).cause
+              : undefined;
+          const causeText =
+            cause instanceof Error && cause.message
+              ? ` (${cause.message})`
+              : '';
+          return {
+            error: `Failed to upload media from URL: ${
+              err instanceof Error ? err.message : 'Unexpected error'
+            }${causeText}`,
+          };
+        }
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/chat/tools/video.function.tool.ts

@@ -0,0 +1,56 @@
+import { AgentToolInterface } from '@gitroom/nestjs-libraries/chat/agent.tool.interface';
+import { createTool } from '@mastra/core/tools';
+import { Injectable } from '@nestjs/common';
+import { VideoManager } from '@gitroom/nestjs-libraries/videos/video.manager';
+import z from 'zod';
+import { ModuleRef } from '@nestjs/core';
+import { checkAuth } from '@gitroom/nestjs-libraries/chat/auth.context';
+
+@Injectable()
+export class VideoFunctionTool implements AgentToolInterface {
+  constructor(
+    private _videoManagerService: VideoManager,
+    private _moduleRef: ModuleRef
+  ) {}
+  name = 'videoFunctionTool';
+
+  run() {
+    return createTool({
+      id: 'videoFunctionTool',
+      description: `Sometimes when we want to generate videos we might need to get some additional information like voice_id, etc`,
+      mcp: {
+        annotations: {
+          title: 'Video Function Helper',
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false,
+        },
+      },
+      inputSchema: z.object({
+        identifier: z.string(),
+        functionName: z.string(),
+      }),
+      outputSchema: z.object({}).passthrough(),
+      execute: async (inputData, context) => {
+        checkAuth(inputData, context);
+        const videos = this._videoManagerService.getAllVideos();
+        const findVideo = videos.find(
+          (p) =>
+            p.identifier === inputData.identifier &&
+            p.tools.some((p) => p.functionName === inputData.functionName)
+        );
+
+        if (!findVideo) {
+          throw new Error('Function not found');
+        }
+
+        const func = await this._moduleRef
+          // @ts-ignore
+          .get(findVideo.target, { strict: false })
+          [inputData.functionName]();
+        return func;
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/chat/validation.schemas.helper.ts

@@ -0,0 +1,30 @@
+import {
+  validationMetadatasToSchemas,
+  targetConstructorToSchema,
+} from 'class-validator-jsonschema';
+import { ValidationTypes } from 'class-validator';
+// @ts-ignore
+import { defaultMetadataStorage } from 'class-transformer/cjs/storage';
+
+export function getValidationSchemas() {
+  return validationMetadatasToSchemas({
+    classTransformerMetadataStorage: defaultMetadataStorage,
+    additionalConverters: {
+      [ValidationTypes.NESTED_VALIDATION]: (meta, options) => {
+        if (typeof meta.target === 'function') {
+          const typeMeta = options.classTransformerMetadataStorage
+            ? options.classTransformerMetadataStorage.findTypeMetadata(
+                meta.target,
+                meta.propertyName
+              )
+            : null;
+          if (typeMeta) {
+            const childType = typeMeta.typeFunction();
+            return targetConstructorToSchema(childType, options);
+          }
+        }
+        return {};
+      },
+    },
+  });
+}

libraries/nestjs-libraries/src/database/prisma/admin-stats/admin-stats.repository.ts

@@ -0,0 +1,157 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+
+export interface StatsParams {
+  from: Date;
+  to: Date;
+  unknownOnly?: boolean;
+}
+
+// Unknown errors are stored as the serialized error payload, e.g.
+// {..."message":"Unknown Error"...}. Matches `message LIKE '%"message":"Unknown Error"%'`.
+const UNKNOWN_ERROR_TOKEN = '"message":"Unknown Error"';
+
+interface PerSocial {
+  provider: string;
+  count: number;
+}
+
+export interface StatsResponse {
+  from: string;
+  to: string;
+  errors: { total: number; perSocial: PerSocial[] };
+  posts: { total: number; perSocial: PerSocial[] };
+  connected: { total: number; perSocial: PerSocial[] };
+}
+
+const sortDesc = (list: PerSocial[]) =>
+  list.sort((a, b) => b.count - a.count || a.provider.localeCompare(b.provider));
+
+@Injectable()
+export class AdminStatsRepository {
+  constructor(
+    private _post: PrismaRepository<'post'>,
+    private _integration: PrismaRepository<'integration'>,
+    private _errors: PrismaRepository<'errors'>
+  ) {}
+
+  private async errorStats(params: StatsParams) {
+    const where: Prisma.ErrorsWhereInput = {
+      createdAt: { gte: params.from, lte: params.to },
+      ...(params.unknownOnly
+        ? { message: { contains: UNKNOWN_ERROR_TOKEN } }
+        : {}),
+    };
+
+    const [total, grouped] = await Promise.all([
+      this._errors.model.errors.count({ where }),
+      this._errors.model.errors.groupBy({
+        by: ['platform'],
+        where,
+        _count: { _all: true },
+      }),
+    ]);
+
+    return {
+      total,
+      perSocial: sortDesc(
+        grouped.map((g) => ({
+          provider: g.platform,
+          count: g._count._all,
+        }))
+      ),
+    };
+  }
+
+  private async postStats(params: StatsParams) {
+    // Only count top-level posts (thread children share a parentPostId) so the
+    // numbers match a "post published to a channel" rather than every fragment.
+    const where: Prisma.PostWhereInput = {
+      state: 'PUBLISHED',
+      parentPostId: null,
+      deletedAt: null,
+      publishDate: { gte: params.from, lte: params.to },
+    };
+
+    const [total, grouped] = await Promise.all([
+      this._post.model.post.count({ where }),
+      this._post.model.post.groupBy({
+        by: ['integrationId'],
+        where,
+        _count: { _all: true },
+      }),
+    ]);
+
+    // groupBy can't reach into the integration relation, so resolve the
+    // providerIdentifier for the integrations we saw and fold the counts.
+    const integrationIds = grouped.map((g) => g.integrationId);
+    const integrations = integrationIds.length
+      ? await this._integration.model.integration.findMany({
+          where: { id: { in: integrationIds } },
+          select: { id: true, providerIdentifier: true },
+        })
+      : [];
+    const providerById = new Map(
+      integrations.map((i) => [i.id, i.providerIdentifier])
+    );
+
+    const byProvider = new Map<string, number>();
+    for (const g of grouped) {
+      const provider = providerById.get(g.integrationId) || 'unknown';
+      byProvider.set(provider, (byProvider.get(provider) || 0) + g._count._all);
+    }
+
+    return {
+      total,
+      perSocial: sortDesc(
+        [...byProvider.entries()].map(([provider, count]) => ({
+          provider,
+          count,
+        }))
+      ),
+    };
+  }
+
+  private async connectedStats(params: StatsParams) {
+    const where: Prisma.IntegrationWhereInput = {
+      deletedAt: null,
+      createdAt: { gte: params.from, lte: params.to },
+    };
+
+    const [total, grouped] = await Promise.all([
+      this._integration.model.integration.count({ where }),
+      this._integration.model.integration.groupBy({
+        by: ['providerIdentifier'],
+        where,
+        _count: { _all: true },
+      }),
+    ]);
+
+    return {
+      total,
+      perSocial: sortDesc(
+        grouped.map((g) => ({
+          provider: g.providerIdentifier,
+          count: g._count._all,
+        }))
+      ),
+    };
+  }
+
+  async getStats(params: StatsParams): Promise<StatsResponse> {
+    const [errors, posts, connected] = await Promise.all([
+      this.errorStats(params),
+      this.postStats(params),
+      this.connectedStats(params),
+    ]);
+
+    return {
+      from: params.from.toISOString(),
+      to: params.to.toISOString(),
+      errors,
+      posts,
+      connected,
+    };
+  }
+}

libraries/nestjs-libraries/src/database/prisma/admin-stats/admin-stats.service.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@nestjs/common';
+import {
+  AdminStatsRepository,
+  StatsParams,
+} from '@gitroom/nestjs-libraries/database/prisma/admin-stats/admin-stats.repository';
+
+@Injectable()
+export class AdminStatsService {
+  constructor(private _adminStatsRepository: AdminStatsRepository) {}
+
+  getStats(params: StatsParams) {
+    return this._adminStatsRepository.getStats(params);
+  }
+}

libraries/nestjs-libraries/src/database/prisma/agencies/agencies.repository.ts

@@ -0,0 +1,183 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { User } from '@prisma/client';
+import { CreateAgencyDto } from '@gitroom/nestjs-libraries/dtos/agencies/create.agency.dto';
+
+@Injectable()
+export class AgenciesRepository {
+  constructor(
+    private _socialMediaAgencies: PrismaRepository<'socialMediaAgency'>,
+    private _socialMediaAgenciesNiche: PrismaRepository<'socialMediaAgencyNiche'>
+  ) {}
+
+  getAllAgencies() {
+    return this._socialMediaAgencies.model.socialMediaAgency.findMany({
+      where: {
+        deletedAt: null,
+        approved: true,
+      },
+      include: {
+        logo: true,
+        niches: true,
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+  }
+
+  getCount() {
+    return this._socialMediaAgencies.model.socialMediaAgency.count({
+      where: {
+        deletedAt: null,
+        approved: true,
+      },
+    });
+  }
+
+  getAllAgenciesSlug() {
+    return this._socialMediaAgencies.model.socialMediaAgency.findMany({
+      where: {
+        deletedAt: null,
+        approved: true,
+      },
+      select: {
+        slug: true,
+      },
+    });
+  }
+
+  approveOrDecline(action: string, id: string) {
+    return this._socialMediaAgencies.model.socialMediaAgency.update({
+      where: {
+        id,
+      },
+      data: {
+        approved: action === 'approve',
+      },
+    });
+  }
+
+  getAgencyById(id: string) {
+    return this._socialMediaAgencies.model.socialMediaAgency.findFirst({
+      where: {
+        id,
+        deletedAt: null,
+        approved: true,
+      },
+      include: {
+        logo: true,
+        niches: true,
+        user: true,
+      },
+    });
+  }
+
+  getAgencyInformation(agency: string) {
+    return this._socialMediaAgencies.model.socialMediaAgency.findFirst({
+      where: {
+        slug: agency,
+        deletedAt: null,
+        approved: true,
+      },
+      include: {
+        logo: true,
+        niches: true,
+      },
+    });
+  }
+
+  getAgencyByUser(user: User) {
+    return this._socialMediaAgencies.model.socialMediaAgency.findFirst({
+      where: {
+        userId: user.id,
+        deletedAt: null,
+      },
+      include: {
+        logo: true,
+        niches: true,
+      },
+    });
+  }
+
+  async createAgency(user: User, body: CreateAgencyDto) {
+    const insertAgency =
+      await this._socialMediaAgencies.model.socialMediaAgency.upsert({
+        where: {
+          userId: user.id,
+        },
+        update: {
+          userId: user.id,
+          name: body.name,
+          website: body.website,
+          facebook: body.facebook,
+          instagram: body.instagram,
+          twitter: body.twitter,
+          linkedIn: body.linkedIn,
+          youtube: body.youtube,
+          tiktok: body.tiktok,
+          logoId: body.logo.id,
+          shortDescription: body.shortDescription,
+          description: body.description,
+          approved: false,
+        },
+        create: {
+          userId: user.id,
+          name: body.name,
+          website: body.website,
+          facebook: body.facebook,
+          instagram: body.instagram,
+          twitter: body.twitter,
+          linkedIn: body.linkedIn,
+          youtube: body.youtube,
+          tiktok: body.tiktok,
+          logoId: body.logo.id,
+          shortDescription: body.shortDescription,
+          description: body.description,
+          slug: body.name.toLowerCase().replace(/ /g, '-'),
+          approved: false,
+        },
+        select: {
+          id: true,
+        },
+      });
+
+    await this._socialMediaAgenciesNiche.model.socialMediaAgencyNiche.deleteMany(
+      {
+        where: {
+          agencyId: insertAgency.id,
+          niche: {
+            notIn: body.niches,
+          },
+        },
+      }
+    );
+
+    const currentNiche =
+      await this._socialMediaAgenciesNiche.model.socialMediaAgencyNiche.findMany(
+        {
+          where: {
+            agencyId: insertAgency.id,
+          },
+          select: {
+            niche: true,
+          },
+        }
+      );
+
+    const addNewNiche = body.niches.filter(
+      (n) => !currentNiche.some((c) => c.niche === n)
+    );
+
+    await this._socialMediaAgenciesNiche.model.socialMediaAgencyNiche.createMany(
+      {
+        data: addNewNiche.map((n) => ({
+          agencyId: insertAgency.id,
+          niche: n,
+        })),
+      }
+    );
+
+    return insertAgency;
+  }
+}

libraries/nestjs-libraries/src/database/prisma/agencies/agencies.service.ts

@@ -0,0 +1,217 @@
+import { Injectable } from '@nestjs/common';
+import { AgenciesRepository } from '@gitroom/nestjs-libraries/database/prisma/agencies/agencies.repository';
+import { User } from '@prisma/client';
+import { CreateAgencyDto } from '@gitroom/nestjs-libraries/dtos/agencies/create.agency.dto';
+import { NotificationService } from '@gitroom/nestjs-libraries/database/prisma/notifications/notification.service';
+
+@Injectable()
+export class AgenciesService {
+  constructor(
+    private _agenciesRepository: AgenciesRepository,
+    private _notificationService: NotificationService
+  ) {}
+  getAgencyByUser(user: User) {
+    return this._agenciesRepository.getAgencyByUser(user);
+  }
+
+  getCount() {
+    return this._agenciesRepository.getCount();
+  }
+
+  getAllAgencies() {
+    return this._agenciesRepository.getAllAgencies();
+  }
+
+  getAllAgenciesSlug() {
+    return this._agenciesRepository.getAllAgenciesSlug();
+  }
+
+  getAgencyInformation(agency: string) {
+    return this._agenciesRepository.getAgencyInformation(agency);
+  }
+
+  async approveOrDecline(email: string, action: string, id: string) {
+    await this._agenciesRepository.approveOrDecline(action, id);
+    const agency = await this._agenciesRepository.getAgencyById(id);
+
+    if (action === 'approve') {
+      await this._notificationService.sendEmail(
+        agency?.user?.email!,
+        'Your Agency has been approved and added to Postiz 🚀',
+        `
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Your Agency has been approved and added to Postiz 🚀</title>
+</head>
+
+<body style="font-family: Arial, sans-serif; margin: 0; padding: 0;">
+  Hi there, <br /><br />
+  Your agency ${agency?.name} has been added to Postiz!<br />
+  You can <a href="https://postiz.com/agencies/${agency?.slug}">check it here</a><br />
+  It will appear on the main agency of Postiz in the next 24 hours.<br /><br />
+</body>
+</html>`
+      );
+
+      return;
+    }
+
+    await this._notificationService.sendEmail(
+      agency?.user?.email!,
+      'Your Agency has been declined 😔',
+      `
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Your Agency has been declined</title>
+</head>
+
+<body style="font-family: Arial, sans-serif; margin: 0; padding: 0;">
+  Hi there, <br /><br />
+  Your agency ${agency?.name} has been declined to Postiz!<br />
+  If you think we have made a mistake, please reply to this email and let us know
+</body>
+</html>`
+    );
+
+    return;
+  }
+
+  async createAgency(user: User, body: CreateAgencyDto) {
+    const agency = await this._agenciesRepository.createAgency(user, body);
+    await this._notificationService.sendEmail(
+      'nevo@postiz.com',
+      'New agency created',
+      `
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Email Template</title>
+</head>
+
+<body style="font-family: Arial, sans-serif; margin: 0; padding: 0; background-color: #f4f4f4;">
+    <table align="center" cellpadding="0" cellspacing="0" style="max-width: 600px; width: 100%; background-color: #ffffff; margin-top: 20px; border: 1px solid #ddd;">
+        <tr>
+            <td style="padding: 0 20px 20px 20px; text-align: center;">
+                <!-- Website -->
+                <a href="${
+                  body.website
+                }" style="text-decoration: none; color: #007bff;">${
+        body.website
+      }</a>
+            </td>
+        </tr>
+        <tr>
+            <td style="padding: 20px; text-align: center;">
+                <!-- Social Media Links -->
+                <p style="margin: 10px 0; font-size: 16px;">
+                    Social Medias:
+                    <a href="${
+                      body.facebook
+                    }" style="margin: 0 10px; text-decoration: none; color: #007bff;">${
+        body.facebook
+      }</a><br />
+                    <a href="${
+                      body.instagram
+                    }" style="margin: 0 10px; text-decoration: none; color: #007bff;">${
+        body.instagram
+      }</a><br />
+                    <a href="${
+                      body.twitter
+                    }" style="margin: 0 10px; text-decoration: none; color: #007bff;">${
+        body.twitter
+      }</a><br />
+                    <a href="${
+                      body.linkedIn
+                    }" style="margin: 0 10px; text-decoration: none; color: #007bff;">${
+        body.linkedIn
+      }</a><br />
+                    <a href="${
+                      body.youtube
+                    }" style="margin: 0 10px; text-decoration: none; color: #007bff;">${
+        body.youtube
+      }</a><br />
+                    <a href="${
+                      body.tiktok
+                    }" style="margin: 0 10px; text-decoration: none; color: #007bff;">${
+        body.tiktok
+      }</a>
+                </p>
+            </td>
+        </tr>
+        <tr>
+            <td style="padding: 20px;">
+                <!-- Short Description -->
+                <h2 style="text-align: center; color: #333;">Logo</h2>
+                <p style="text-align: center; color: #555; font-size: 16px;">
+                  <img src="${body.logo.path}" width="60" height="60" />
+                </p>
+            </td>
+        </tr>
+        <tr>
+            <td style="padding: 20px;">
+                <!-- Short Description -->
+                <h2 style="text-align: center; color: #333;">Name</h2>
+                <p style="text-align: center; color: #555; font-size: 16px;">${
+                  body.name
+                }</p>
+            </td>
+        </tr>
+        <tr>
+            <td style="padding: 20px;">
+                <!-- Short Description -->
+                <h2 style="text-align: center; color: #333;">Short Description</h2>
+                <p style="text-align: center; color: #555; font-size: 16px;">${
+                  body.shortDescription
+                }</p>
+            </td>
+        </tr>
+        <tr>
+            <td style="padding: 20px;">
+                <!-- Description -->
+                <h2 style="text-align: center; color: #333;">Description</h2>
+                <p style="text-align: center; color: #555; font-size: 16px;">${
+                  body.description
+                }</p>
+            </td>
+        </tr>
+        <tr>
+            <td style="padding: 20px;">
+                <!-- Niches -->
+                <h2 style="text-align: center; color: #333;">Niches</h2>
+                <p style="text-align: center; color: #555; font-size: 16px;">${body.niches.join(
+                  ','
+                )}</p>
+            </td>
+        </tr>
+        <tr>
+            <td style="padding: 20px; text-align: center; background-color: #000;">
+                <a href="https://postiz.com/agencies/action/approve/${
+                  agency.id
+                }" style="margin: 0 10px; text-decoration: none; color: #007bff;">To approve click here</a><br /><br /><br />
+                <a href="https://postiz.com/agencies/action/decline/${
+                  agency.id
+                }" style="margin: 0 10px; text-decoration: none; color: #007bff;">To decline click here</a><br /><br /><br />
+            </td>
+        </tr>
+        <tr>
+            <td style="padding: 20px; text-align: center; background-color: #f4f4f4;">
+                <p style="color: #777; font-size: 14px;">&copy; 2024 Your Gitroom Limited All rights reserved.</p>
+            </td>
+        </tr>
+    </table>
+</body>
+
+</html>
+    `
+    );
+    return agency;
+  }
+}

libraries/nestjs-libraries/src/database/prisma/announcements/announcements.repository.ts

@@ -0,0 +1,35 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { AnnouncementDto } from '@gitroom/nestjs-libraries/dtos/announcements/announcements.dto';
+import { AnnouncementColor } from '@prisma/client';
+
+@Injectable()
+export class AnnouncementsRepository {
+  constructor(private _announcements: PrismaRepository<'announcement'>) {}
+
+  getAnnouncements() {
+    return this._announcements.model.announcement.findMany({
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+  }
+
+  createAnnouncement(body: AnnouncementDto) {
+    return this._announcements.model.announcement.create({
+      data: {
+        title: body.title,
+        description: body.description,
+        color: (body.color as AnnouncementColor) || AnnouncementColor.INFO,
+      },
+    });
+  }
+
+  deleteAnnouncement(id: string) {
+    return this._announcements.model.announcement.delete({
+      where: {
+        id,
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/announcements/announcements.service.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { AnnouncementsRepository } from '@gitroom/nestjs-libraries/database/prisma/announcements/announcements.repository';
+import { AnnouncementDto } from '@gitroom/nestjs-libraries/dtos/announcements/announcements.dto';
+
+@Injectable()
+export class AnnouncementsService {
+  constructor(private _announcementsRepository: AnnouncementsRepository) {}
+
+  getAnnouncements() {
+    return this._announcementsRepository.getAnnouncements();
+  }
+
+  createAnnouncement(body: AnnouncementDto) {
+    return this._announcementsRepository.createAnnouncement(body);
+  }
+
+  deleteAnnouncement(id: string) {
+    return this._announcementsRepository.deleteAnnouncement(id);
+  }
+}

libraries/nestjs-libraries/src/database/prisma/autopost/autopost.repository.ts

@@ -0,0 +1,107 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { v4 as uuidv4 } from 'uuid';
+import { AutopostDto } from '@gitroom/nestjs-libraries/dtos/autopost/autopost.dto';
+
+@Injectable()
+export class AutopostRepository {
+  constructor(private _autoPost: PrismaRepository<'autoPost'>) {}
+
+  getTotal(orgId: string) {
+    return this._autoPost.model.autoPost.count({
+      where: {
+        organizationId: orgId,
+        deletedAt: null,
+      },
+    });
+  }
+
+  getAutoposts(orgId: string) {
+    return this._autoPost.model.autoPost.findMany({
+      where: {
+        organizationId: orgId,
+        deletedAt: null,
+      },
+    });
+  }
+
+  deleteAutopost(orgId: string, id: string) {
+    return this._autoPost.model.autoPost.update({
+      where: {
+        id,
+        organizationId: orgId,
+      },
+      data: {
+        deletedAt: new Date(),
+      },
+    });
+  }
+
+  getAutopost(id: string) {
+    return this._autoPost.model.autoPost.findUnique({
+      where: {
+        id,
+        deletedAt: null,
+      },
+    });
+  }
+
+  updateUrl(id: string, url: string) {
+    return this._autoPost.model.autoPost.update({
+      where: {
+        id,
+      },
+      data: {
+        lastUrl: url,
+      },
+    });
+  }
+
+  changeActive(orgId: string, id: string, active: boolean) {
+    return this._autoPost.model.autoPost.update({
+      where: {
+        id,
+        organizationId: orgId,
+      },
+      data: {
+        active,
+      },
+    });
+  }
+
+  async createAutopost(orgId: string, body: AutopostDto, id?: string) {
+    const { id: newId, active } = await this._autoPost.model.autoPost.upsert({
+      where: {
+        id: id || uuidv4(),
+        organizationId: orgId,
+      },
+      create: {
+        organizationId: orgId,
+        url: body.url,
+        title: body.title,
+        integrations: JSON.stringify(body.integrations),
+        active: body.active,
+        content: body.content,
+        generateContent: body.generateContent,
+        addPicture: body.addPicture,
+        syncLast: body.syncLast,
+        onSlot: body.onSlot,
+        lastUrl: body.lastUrl,
+      },
+      update: {
+        url: body.url,
+        title: body.title,
+        integrations: JSON.stringify(body.integrations),
+        active: body.active,
+        content: body.content,
+        generateContent: body.generateContent,
+        addPicture: body.addPicture,
+        syncLast: body.syncLast,
+        onSlot: body.onSlot,
+        lastUrl: body.lastUrl,
+      },
+    });
+
+    return { id: newId, active };
+  }
+}

libraries/nestjs-libraries/src/database/prisma/autopost/autopost.service.ts

@@ -0,0 +1,371 @@
+import { Injectable } from '@nestjs/common';
+import { AutopostRepository } from '@gitroom/nestjs-libraries/database/prisma/autopost/autopost.repository';
+import { AutopostDto } from '@gitroom/nestjs-libraries/dtos/autopost/autopost.dto';
+import dayjs from 'dayjs';
+import { END, START, StateGraph } from '@langchain/langgraph';
+import { AutoPost, Integration } from '@prisma/client';
+import { BaseMessage } from '@langchain/core/messages';
+import striptags from 'striptags';
+import { ChatOpenAI, DallEAPIWrapper } from '@langchain/openai';
+import { JSDOM } from 'jsdom';
+import { z } from 'zod';
+import { ChatPromptTemplate } from '@langchain/core/prompts';
+import { PostsService } from '@gitroom/nestjs-libraries/database/prisma/posts/posts.service';
+import Parser from 'rss-parser';
+import { IntegrationService } from '@gitroom/nestjs-libraries/database/prisma/integrations/integration.service';
+import { makeId } from '@gitroom/nestjs-libraries/services/make.is';
+import { TemporalService } from 'nestjs-temporal-core';
+import { TypedSearchAttributes } from '@temporalio/common';
+import {
+  organizationId,
+} from '@gitroom/nestjs-libraries/temporal/temporal.search.attribute';
+const parser = new Parser();
+
+interface WorkflowChannelsState {
+  messages: BaseMessage[];
+  integrations: Integration[];
+  body: AutoPost;
+  description: string;
+  image: string;
+  id: string;
+  load: {
+    date: string;
+    url: string;
+    description: string;
+  };
+}
+
+const model = new ChatOpenAI({
+  apiKey: process.env.OPENAI_API_KEY || 'sk-proj-',
+  model: 'gpt-4.1',
+  temperature: 0.7,
+});
+
+const dalle = new DallEAPIWrapper({
+  apiKey: process.env.OPENAI_API_KEY || 'sk-proj-',
+  model: 'chatgpt-image-latest',
+});
+
+const generateContent = z.object({
+  socialMediaPostContent: z
+    .string()
+    .describe('Content for social media posts max 120 chars'),
+});
+
+const dallePrompt = z.object({
+  generatedTextToBeSentToDallE: z
+    .string()
+    .describe('Generated prompt from description to be sent to DallE'),
+});
+
+@Injectable()
+export class AutopostService {
+  constructor(
+    private _autopostsRepository: AutopostRepository,
+    private _temporalService: TemporalService,
+    private _integrationService: IntegrationService,
+    private _postsService: PostsService
+  ) {}
+
+  async stopAll(org: string) {
+    const getAll = (await this.getAutoposts(org)).filter((f) => f.active);
+    for (const autopost of getAll) {
+      await this.changeActive(org, autopost.id, false);
+    }
+  }
+
+  getAutoposts(orgId: string) {
+    return this._autopostsRepository.getAutoposts(orgId);
+  }
+
+  async createAutopost(orgId: string, body: AutopostDto, id?: string) {
+    const data = await this._autopostsRepository.createAutopost(
+      orgId,
+      body,
+      id
+    );
+
+    await this.processCron(body.active, orgId, data.id);
+
+    return data;
+  }
+
+  async changeActive(orgId: string, id: string, active: boolean) {
+    const data = await this._autopostsRepository.changeActive(
+      orgId,
+      id,
+      active
+    );
+    await this.processCron(active, orgId, id);
+    return data;
+  }
+
+  async processCron(active: boolean, orgId: string, id: string) {
+    if (active) {
+      try {
+        return this._temporalService.client
+          .getRawClient()
+          ?.workflow.start('autoPostWorkflow', {
+            workflowId: `autopost-${id}`,
+            taskQueue: 'main',
+            args: [{ id, immediately: true }],
+            typedSearchAttributes: new TypedSearchAttributes([
+              {
+                key: organizationId,
+                value: orgId,
+              },
+            ]),
+          });
+      } catch (err) {}
+    }
+
+    try {
+      return await this._temporalService.terminateWorkflow(`autopost-${id}`);
+    } catch (err) {
+      return false;
+    }
+  }
+
+  async deleteAutopost(orgId: string, id: string) {
+    const data = await this._autopostsRepository.deleteAutopost(orgId, id);
+    await this.processCron(false, orgId, id);
+    return data;
+  }
+
+  async loadXML(url: string) {
+    try {
+      const { items } = await parser.parseURL(url);
+      const findLast = items.reduce(
+        (all: any, current: any) => {
+          if (dayjs(current.pubDate).isAfter(all.pubDate)) {
+            return current;
+          }
+          return all;
+        },
+        { pubDate: dayjs().subtract(100, 'years') }
+      );
+
+      return {
+        success: true,
+        date: findLast.pubDate,
+        url: findLast.link,
+        description: striptags(
+          findLast?.['content:encoded'] ||
+            findLast?.content ||
+            findLast?.description ||
+            ''
+        )
+          .replace(/\n/g, ' ')
+          .trim(),
+      };
+    } catch (err) {
+      /** sent **/
+    }
+
+    return { success: false };
+  }
+
+  static state = () =>
+    new StateGraph<WorkflowChannelsState>({
+      channels: {
+        messages: {
+          reducer: (currentState, updateValue) =>
+            currentState.concat(updateValue),
+          default: () => [],
+        },
+        body: null,
+        description: null,
+        load: null,
+        image: null,
+        integrations: null,
+        id: null,
+      },
+    });
+
+  async loadUrl(url: string) {
+    try {
+      const loadDom = new JSDOM(await (await fetch(url)).text());
+      loadDom.window.document
+        .querySelectorAll('script')
+        .forEach((s) => s.remove());
+      loadDom.window.document
+        .querySelectorAll('style')
+        .forEach((s) => s.remove());
+      // remove all html, script and styles
+      return striptags(loadDom.window.document.body.innerHTML);
+    } catch (err) {
+      return '';
+    }
+  }
+
+  async generateDescription(state: WorkflowChannelsState) {
+    if (!state.body.generateContent) {
+      return {
+        ...state,
+        description: state.body.content,
+      };
+    }
+
+    const description =
+      state.load.description || (await this.loadUrl(state.load.url));
+    if (!description) {
+      return {
+        ...state,
+        description: '',
+      };
+    }
+
+    const structuredOutput = model.withStructuredOutput(generateContent);
+    const { socialMediaPostContent } = await ChatPromptTemplate.fromTemplate(
+      `
+        You are an assistant that gets raw 'description' of a content and generate a social media post content.
+        Rules:
+        - Maximum 100 chars
+        - Try to make it a short as possible to fit any social media
+        - Add line breaks between sentences (\\n) 
+        - Don't add hashtags
+        - Add emojis when needed
+        
+        'description':
+        {content}
+      `
+    )
+      .pipe(structuredOutput)
+      .invoke({
+        content: description,
+      });
+
+    return {
+      ...state,
+      description: socialMediaPostContent,
+    };
+  }
+
+  async generatePicture(state: WorkflowChannelsState) {
+    const structuredOutput = model.withStructuredOutput(dallePrompt);
+    const { generatedTextToBeSentToDallE } =
+      await ChatPromptTemplate.fromTemplate(
+        `
+        You are an assistant that gets description and generate a prompt that will be sent to DallE to generate pictures.
+        
+        content:
+        {content}
+      `
+      )
+        .pipe(structuredOutput)
+        .invoke({
+          content: state.load.description || state.description,
+        });
+
+    const image = await dalle.invoke(generatedTextToBeSentToDallE);
+
+    return { ...state, image };
+  }
+
+  async schedulePost(state: WorkflowChannelsState) {
+    const nextTime = await this._postsService.findFreeDateTime(
+      state.integrations[0].organizationId
+    );
+
+    await this._postsService.createPost(state.integrations[0].organizationId, {
+      date: nextTime + 'Z',
+      order: makeId(10),
+      shortLink: false,
+      type: 'draft',
+      tags: [],
+      posts: state.integrations.map((i) => ({
+        settings: {
+          __type: i.providerIdentifier as any,
+          title: '',
+          tags: [],
+          subreddit: [],
+        },
+        group: makeId(10),
+        integration: { id: i.id },
+        value: [
+          {
+            id: makeId(10),
+            delay: 0,
+            content:
+              state.description.replace(/\n/g, '\n\n') +
+              '\n\n' +
+              state.load.url,
+            image: !state.image
+              ? []
+              : [
+                  {
+                    id: makeId(10),
+                    name: makeId(10),
+                    path: state.image,
+                    organizationId: state.integrations[0].organizationId,
+                  },
+                ],
+          },
+        ],
+      })),
+    }, 'AUTOPOST');
+  }
+
+  async updateUrl(state: WorkflowChannelsState) {
+    await this._autopostsRepository.updateUrl(state.id, state.load.url);
+  }
+
+  async startAutopost(id: string) {
+    const getPost = await this._autopostsRepository.getAutopost(id);
+    if (!getPost || !getPost.active) {
+      return;
+    }
+
+    const load = await this.loadXML(getPost.url);
+    if (!load.success || load.url === getPost.lastUrl) {
+      return;
+    }
+
+    const integrations = await this._integrationService.getIntegrationsList(
+      getPost.organizationId
+    );
+
+    const parseIntegrations = JSON.parse(getPost.integrations || '[]') || [];
+    const neededIntegrations = integrations.filter((i) =>
+      parseIntegrations.some((ii: any) => ii.id === i.id)
+    );
+
+    const integrationsToSend =
+      parseIntegrations.length === 0 ? integrations : neededIntegrations;
+    if (integrationsToSend.length === 0) {
+      return;
+    }
+
+    const state = AutopostService.state();
+    const workflow = state
+      .addNode('generate-description', this.generateDescription.bind(this))
+      .addNode('generate-picture', this.generatePicture.bind(this))
+      .addNode('schedule-post', this.schedulePost.bind(this))
+      .addNode('update-url', this.updateUrl.bind(this))
+      .addEdge(START, 'generate-description')
+      .addConditionalEdges(
+        'generate-description',
+        (state: WorkflowChannelsState) => {
+          if (!state.description) {
+            return 'schedule-post';
+          }
+          if (state.body.addPicture) {
+            return 'generate-picture';
+          }
+          return 'schedule-post';
+        }
+      )
+      .addEdge('generate-picture', 'schedule-post')
+      .addEdge('schedule-post', 'update-url')
+      .addEdge('update-url', END);
+
+    const app = workflow.compile();
+    await app.invoke({
+      messages: [],
+      id,
+      body: getPost,
+      load,
+      integrations: integrationsToSend,
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/database.module.ts

@@ -0,0 +1,105 @@
+import { Global, Module } from '@nestjs/common';
+import { PrismaRepository, PrismaService, PrismaTransaction } from './prisma.service';
+import { OrganizationRepository } from '@gitroom/nestjs-libraries/database/prisma/organizations/organization.repository';
+import { OrganizationService } from '@gitroom/nestjs-libraries/database/prisma/organizations/organization.service';
+import { UsersService } from '@gitroom/nestjs-libraries/database/prisma/users/users.service';
+import { UsersRepository } from '@gitroom/nestjs-libraries/database/prisma/users/users.repository';
+import { SubscriptionService } from '@gitroom/nestjs-libraries/database/prisma/subscriptions/subscription.service';
+import { SubscriptionRepository } from '@gitroom/nestjs-libraries/database/prisma/subscriptions/subscription.repository';
+import { NotificationService } from '@gitroom/nestjs-libraries/database/prisma/notifications/notification.service';
+import { IntegrationService } from '@gitroom/nestjs-libraries/database/prisma/integrations/integration.service';
+import { IntegrationRepository } from '@gitroom/nestjs-libraries/database/prisma/integrations/integration.repository';
+import { PostsService } from '@gitroom/nestjs-libraries/database/prisma/posts/posts.service';
+import { PostsRepository } from '@gitroom/nestjs-libraries/database/prisma/posts/posts.repository';
+import { IntegrationManager } from '@gitroom/nestjs-libraries/integrations/integration.manager';
+import { MediaService } from '@gitroom/nestjs-libraries/database/prisma/media/media.service';
+import { MediaRepository } from '@gitroom/nestjs-libraries/database/prisma/media/media.repository';
+import { NotificationsRepository } from '@gitroom/nestjs-libraries/database/prisma/notifications/notifications.repository';
+import { EmailService } from '@gitroom/nestjs-libraries/services/email.service';
+import { StripeService } from '@gitroom/nestjs-libraries/services/stripe.service';
+import { ExtractContentService } from '@gitroom/nestjs-libraries/openai/extract.content.service';
+import { OpenaiService } from '@gitroom/nestjs-libraries/openai/openai.service';
+import { AgenciesService } from '@gitroom/nestjs-libraries/database/prisma/agencies/agencies.service';
+import { AgenciesRepository } from '@gitroom/nestjs-libraries/database/prisma/agencies/agencies.repository';
+import { TrackService } from '@gitroom/nestjs-libraries/track/track.service';
+import { ShortLinkService } from '@gitroom/nestjs-libraries/short-linking/short.link.service';
+import { WebhooksRepository } from '@gitroom/nestjs-libraries/database/prisma/webhooks/webhooks.repository';
+import { WebhooksService } from '@gitroom/nestjs-libraries/database/prisma/webhooks/webhooks.service';
+import { SignatureRepository } from '@gitroom/nestjs-libraries/database/prisma/signatures/signature.repository';
+import { SignatureService } from '@gitroom/nestjs-libraries/database/prisma/signatures/signature.service';
+import { AutopostRepository } from '@gitroom/nestjs-libraries/database/prisma/autopost/autopost.repository';
+import { AutopostService } from '@gitroom/nestjs-libraries/database/prisma/autopost/autopost.service';
+import { SetsService } from '@gitroom/nestjs-libraries/database/prisma/sets/sets.service';
+import { SetsRepository } from '@gitroom/nestjs-libraries/database/prisma/sets/sets.repository';
+import { ThirdPartyRepository } from '@gitroom/nestjs-libraries/database/prisma/third-party/third-party.repository';
+import { ThirdPartyService } from '@gitroom/nestjs-libraries/database/prisma/third-party/third-party.service';
+import { VideoManager } from '@gitroom/nestjs-libraries/videos/video.manager';
+import { FalService } from '@gitroom/nestjs-libraries/openai/fal.service';
+import { RefreshIntegrationService } from '@gitroom/nestjs-libraries/integrations/refresh.integration.service';
+import { OAuthRepository } from '@gitroom/nestjs-libraries/database/prisma/oauth/oauth.repository';
+import { OAuthService } from '@gitroom/nestjs-libraries/database/prisma/oauth/oauth.service';
+import { AnnouncementsRepository } from '@gitroom/nestjs-libraries/database/prisma/announcements/announcements.repository';
+import { AnnouncementsService } from '@gitroom/nestjs-libraries/database/prisma/announcements/announcements.service';
+import { ErrorsRepository } from '@gitroom/nestjs-libraries/database/prisma/errors/errors.repository';
+import { ErrorsService } from '@gitroom/nestjs-libraries/database/prisma/errors/errors.service';
+import { AdminStatsRepository } from '@gitroom/nestjs-libraries/database/prisma/admin-stats/admin-stats.repository';
+import { AdminStatsService } from '@gitroom/nestjs-libraries/database/prisma/admin-stats/admin-stats.service';
+
+@Global()
+@Module({
+  imports: [],
+  controllers: [],
+  providers: [
+    PrismaService,
+    PrismaRepository,
+    PrismaTransaction,
+    UsersService,
+    UsersRepository,
+    OrganizationService,
+    OrganizationRepository,
+    SubscriptionService,
+    SubscriptionRepository,
+    NotificationService,
+    NotificationsRepository,
+    WebhooksRepository,
+    WebhooksService,
+    IntegrationService,
+    IntegrationRepository,
+    PostsService,
+    PostsRepository,
+    StripeService,
+    SignatureRepository,
+    AutopostRepository,
+    AutopostService,
+    SignatureService,
+    MediaService,
+    MediaRepository,
+    AgenciesService,
+    AgenciesRepository,
+    IntegrationManager,
+    RefreshIntegrationService,
+    ExtractContentService,
+    OpenaiService,
+    FalService,
+    EmailService,
+    TrackService,
+    ShortLinkService,
+    SetsService,
+    SetsRepository,
+    ThirdPartyRepository,
+    ThirdPartyService,
+    OAuthRepository,
+    OAuthService,
+    VideoManager,
+    AnnouncementsRepository,
+    AnnouncementsService,
+    ErrorsRepository,
+    ErrorsService,
+    AdminStatsRepository,
+    AdminStatsService,
+  ],
+  get exports() {
+    return this.providers;
+  },
+})
+export class DatabaseModule {}

libraries/nestjs-libraries/src/database/prisma/errors/errors.repository.ts

@@ -0,0 +1,143 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+
+const UNKNOWN_TOKEN = 'An unknown error occurred';
+
+interface ListErrorsParams {
+  page?: number;
+  limit?: number;
+  platform?: string;
+  email?: string;
+  unknownFirst?: boolean;
+}
+
+@Injectable()
+export class ErrorsRepository {
+  constructor(private _errors: PrismaRepository<'errors'>) {}
+
+  private buildWhere(params: ListErrorsParams) {
+    const where: any = {};
+    if (params.platform) {
+      where.platform = params.platform;
+    }
+    if (params.email) {
+      where.organization = {
+        users: {
+          some: {
+            user: {
+              email: { contains: params.email, mode: 'insensitive' },
+            },
+          },
+        },
+      };
+    }
+    return where;
+  }
+
+  private get include() {
+    return {
+      organization: {
+        select: {
+          id: true,
+          name: true,
+          users: {
+            select: {
+              user: { select: { id: true, email: true, name: true } },
+            },
+          },
+        },
+      },
+      post: { select: { id: true, content: true } },
+    } as const;
+  }
+
+  async listPlatforms() {
+    const rows = await this._errors.model.errors.findMany({
+      distinct: ['platform'],
+      select: { platform: true },
+      orderBy: { platform: 'asc' },
+    });
+    return rows.map((r) => r.platform);
+  }
+
+  async listErrors(params: ListErrorsParams) {
+    const page = Math.max(0, params.page || 0);
+    const limit = Math.min(Math.max(1, params.limit || 20), 100);
+    const skip = page * limit;
+    const where = this.buildWhere(params);
+    const include = this.include;
+
+    if (!params.unknownFirst) {
+      const [items, total] = await Promise.all([
+        this._errors.model.errors.findMany({
+          where,
+          orderBy: { createdAt: 'desc' },
+          skip,
+          take: limit,
+          include,
+        }),
+        this._errors.model.errors.count({ where }),
+      ]);
+      return {
+        items,
+        total,
+        page,
+        limit,
+        hasMore: skip + items.length < total,
+      };
+    }
+
+    const unknownWhere = { ...where, message: { contains: UNKNOWN_TOKEN } };
+    const knownWhere = {
+      ...where,
+      NOT: { message: { contains: UNKNOWN_TOKEN } },
+    };
+
+    const [unknownTotal, knownTotal] = await Promise.all([
+      this._errors.model.errors.count({ where: unknownWhere }),
+      this._errors.model.errors.count({ where: knownWhere }),
+    ]);
+
+    let unknownItems: any[] = [];
+    let knownItems: any[] = [];
+
+    if (skip < unknownTotal) {
+      const takeUnknown = Math.min(unknownTotal - skip, limit);
+      unknownItems = await this._errors.model.errors.findMany({
+        where: unknownWhere,
+        orderBy: { createdAt: 'desc' },
+        skip,
+        take: takeUnknown,
+        include,
+      });
+      const remaining = limit - unknownItems.length;
+      if (remaining > 0) {
+        knownItems = await this._errors.model.errors.findMany({
+          where: knownWhere,
+          orderBy: { createdAt: 'desc' },
+          skip: 0,
+          take: remaining,
+          include,
+        });
+      }
+    } else {
+      knownItems = await this._errors.model.errors.findMany({
+        where: knownWhere,
+        orderBy: { createdAt: 'desc' },
+        skip: skip - unknownTotal,
+        take: limit,
+        include,
+      });
+    }
+
+    const items = [...unknownItems, ...knownItems];
+    const total = unknownTotal + knownTotal;
+    return {
+      items,
+      total,
+      page,
+      limit,
+      hasMore: skip + items.length < total,
+    };
+  }
+}

libraries/nestjs-libraries/src/database/prisma/errors/errors.service.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { ErrorsRepository } from '@gitroom/nestjs-libraries/database/prisma/errors/errors.repository';
+
+@Injectable()
+export class ErrorsService {
+  constructor(private _errorsRepository: ErrorsRepository) {}
+
+  listErrors(params: {
+    page?: number;
+    limit?: number;
+    platform?: string;
+    email?: string;
+    unknownFirst?: boolean;
+  }) {
+    return this._errorsRepository.listErrors(params);
+  }
+
+  listPlatforms() {
+    return this._errorsRepository.listPlatforms();
+  }
+}

libraries/nestjs-libraries/src/database/prisma/integrations/integration.repository.ts

@@ -0,0 +1,674 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import dayjs from 'dayjs';
+import { Integration } from '@prisma/client';
+import { makeId } from '@gitroom/nestjs-libraries/services/make.is';
+import { IntegrationTimeDto } from '@gitroom/nestjs-libraries/dtos/integrations/integration.time.dto';
+import { UploadFactory } from '@gitroom/nestjs-libraries/upload/upload.factory';
+import { PlugDto } from '@gitroom/nestjs-libraries/dtos/plugs/plug.dto';
+
+@Injectable()
+export class IntegrationRepository {
+  private storage = UploadFactory.createStorage();
+  constructor(
+    private _integration: PrismaRepository<'integration'>,
+    private _posts: PrismaRepository<'post'>,
+    private _plugs: PrismaRepository<'plugs'>,
+    private _exisingPlugData: PrismaRepository<'exisingPlugData'>,
+    private _customers: PrismaRepository<'customer'>,
+    private _mentions: PrismaRepository<'mentions'>
+  ) {}
+
+  getMentions(platform: string, q: string) {
+    return this._mentions.model.mentions.findMany({
+      where: {
+        platform,
+        OR: [
+          {
+            name: {
+              contains: q,
+              mode: 'insensitive',
+            },
+          },
+          {
+            username: {
+              contains: q,
+              mode: 'insensitive',
+            },
+          },
+        ],
+      },
+      orderBy: {
+        name: 'asc',
+      },
+      take: 100,
+      select: {
+        name: true,
+        username: true,
+        image: true,
+      },
+    });
+  }
+
+  insertMentions(
+    platform: string,
+    mentions: { name: string; username: string; image: string }[]
+  ) {
+    if (mentions.length === 0) {
+      return [] as any[];
+    }
+    return this._mentions.model.mentions.createMany({
+      data: mentions.map((mention) => ({
+        platform,
+        name: mention.name,
+        username: mention.username,
+        image: mention.image,
+      })),
+      skipDuplicates: true,
+    });
+  }
+
+  async checkPreviousConnections(org: string, id: string) {
+    const findIt = await this._integration.model.integration.findMany({
+      where: {
+        rootInternalId: id,
+      },
+      select: {
+        organizationId: true,
+        id: true,
+      },
+    });
+
+    if (findIt.some((f) => f.organizationId === org)) {
+      return false;
+    }
+
+    return findIt.length > 0;
+  }
+
+  updateProviderSettings(org: string, id: string, settings: string) {
+    return this._integration.model.integration.update({
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: {
+        additionalSettings: settings,
+      },
+    });
+  }
+
+  async setTimes(org: string, id: string, times: IntegrationTimeDto) {
+    return this._integration.model.integration.update({
+      select: {
+        id: true,
+      },
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: {
+        postingTimes: JSON.stringify(times.time),
+      },
+    });
+  }
+
+  getPlug(plugId: string) {
+    return this._plugs.model.plugs.findFirst({
+      where: {
+        id: plugId,
+      },
+      include: {
+        integration: true,
+      },
+    });
+  }
+
+  async getPlugs(orgId: string, integrationId: string) {
+    return this._plugs.model.plugs.findMany({
+      where: {
+        integrationId,
+        organizationId: orgId,
+        activated: true,
+      },
+      include: {
+        integration: {
+          select: {
+            id: true,
+            providerIdentifier: true,
+          },
+        },
+      },
+    });
+  }
+
+  async updateIntegration(id: string, params: Partial<Integration>) {
+    if (
+      params.picture &&
+      (params.picture.indexOf(process.env.CLOUDFLARE_BUCKET_URL!) === -1 ||
+        params.picture.indexOf(process.env.FRONTEND_URL!) === -1)
+    ) {
+      params.picture = await this.storage.uploadSimple(params.picture);
+    }
+
+    const existing = await this._integration.model.integration.findUnique({
+      where: {
+        organizationId_internalId: {
+          organizationId: params.organizationId!,
+          internalId: params.internalId,
+        },
+      },
+    });
+
+    if (existing) {
+      await this._posts.model.post.updateMany({
+        where: {
+          integrationId: id,
+        },
+        data: {
+          deletedAt: new Date(),
+        },
+      });
+
+      await this._integration.model.integration.update({
+        where: {
+          id,
+        },
+        data: {
+          internalId: `deleted_${params.internalId}_${makeId(10)}`,
+          deletedAt: new Date(),
+        },
+      });
+    }
+
+    return this._integration.model.integration.update({
+      where: {
+        ...(existing ? { id: existing.id } : { id }),
+      },
+      data: {
+        ...params,
+        disabled: false,
+        deletedAt: null,
+      },
+    });
+  }
+
+  disconnectChannel(org: string, id: string) {
+    return this._integration.model.integration.update({
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: {
+        refreshNeeded: true,
+      },
+    });
+  }
+
+  async createOrUpdateIntegration(
+    additionalSettings:
+      | {
+          title: string;
+          description: string;
+          type: 'checkbox' | 'text' | 'textarea';
+          value: any;
+          regex?: string;
+        }[]
+      | undefined,
+    oneTimeToken: boolean,
+    org: string,
+    name: string,
+    picture: string | undefined,
+    type: 'article' | 'social',
+    internalId: string,
+    provider: string,
+    token: string,
+    refreshToken = '',
+    expiresIn = 999999999,
+    username?: string,
+    isBetweenSteps = false,
+    refresh?: string,
+    timezone?: number,
+    customInstanceDetails?: string
+  ) {
+    const postTimes = timezone
+      ? {
+          postingTimes: JSON.stringify([
+            { time: 560 - timezone },
+            { time: 850 - timezone },
+            { time: 1140 - timezone },
+          ]),
+        }
+      : {};
+    const upsert = await this._integration.model.integration.upsert({
+      where: {
+        organizationId_internalId: {
+          internalId,
+          organizationId: org,
+        },
+      },
+      create: {
+        type: type as any,
+        name,
+        providerIdentifier: provider,
+        token,
+        profile: username,
+        ...(picture ? { picture } : {}),
+        inBetweenSteps: isBetweenSteps,
+        refreshToken,
+        ...(expiresIn
+          ? { tokenExpiration: new Date(Date.now() + expiresIn * 1000) }
+          : {}),
+        internalId,
+        ...postTimes,
+        organizationId: org,
+        refreshNeeded: false,
+        rootInternalId: internalId,
+        ...(customInstanceDetails ? { customInstanceDetails } : {}),
+        additionalSettings: additionalSettings
+          ? JSON.stringify(additionalSettings)
+          : '[]',
+      },
+      update: {
+        ...(additionalSettings
+          ? { additionalSettings: JSON.stringify(additionalSettings) }
+          : {}),
+        ...(customInstanceDetails ? { customInstanceDetails } : {}),
+        type: type as any,
+        ...(!refresh
+          ? {
+              inBetweenSteps: isBetweenSteps,
+            }
+          : {}),
+        ...(picture ? { picture } : {}),
+        profile: username,
+        providerIdentifier: provider,
+        token,
+        refreshToken,
+        ...(expiresIn
+          ? { tokenExpiration: new Date(Date.now() + expiresIn * 1000) }
+          : {}),
+        internalId,
+        organizationId: org,
+        deletedAt: null,
+        refreshNeeded: false,
+      },
+    });
+
+    if (oneTimeToken) {
+      const rootId =
+        (
+          await this._integration.model.integration.findFirst({
+            where: {
+              organizationId: org,
+              internalId: internalId,
+            },
+          })
+        )?.rootInternalId || internalId;
+
+      await this._integration.model.integration.updateMany({
+        where: {
+          id: {
+            not: upsert.id,
+          },
+          rootInternalId: rootId,
+        },
+        data: {
+          token,
+          refreshToken,
+          refreshNeeded: false,
+          ...(expiresIn
+            ? { tokenExpiration: new Date(Date.now() + expiresIn * 1000) }
+            : {}),
+        },
+      });
+    }
+
+    return upsert;
+  }
+
+  needsToBeRefreshed() {
+    return this._integration.model.integration.findMany({
+      where: {
+        tokenExpiration: {
+          lte: dayjs().add(1, 'day').toDate(),
+        },
+        inBetweenSteps: false,
+        deletedAt: null,
+        refreshNeeded: false,
+      },
+    });
+  }
+
+  async setBetweenRefreshSteps(id: string) {
+    return this._integration.model.integration.update({
+      where: {
+        id,
+      },
+      data: {
+        inBetweenSteps: true,
+      },
+    });
+  }
+  refreshNeeded(org: string, id: string) {
+    return this._integration.model.integration.update({
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: {
+        refreshNeeded: true,
+      },
+    });
+  }
+
+  updateNameAndUrl(id: string, name: string, url: string) {
+    return this._integration.model.integration.update({
+      where: {
+        id,
+      },
+      data: {
+        ...(name ? { name } : {}),
+        ...(url ? { picture: url } : {}),
+      },
+    });
+  }
+
+  getIntegrationById(org: string, id: string) {
+    return this._integration.model.integration.findFirst({
+      where: {
+        organizationId: org,
+        id,
+      },
+    });
+  }
+
+  async getIntegrationForOrder(
+    id: string,
+    order: string,
+    user: string,
+    org: string
+  ) {
+    const integration = await this._posts.model.post.findFirst({
+      where: {
+        integrationId: id,
+        submittedForOrder: {
+          id: order,
+          messageGroup: {
+            OR: [
+              { sellerId: user },
+              { buyerId: user },
+              { buyerOrganizationId: org },
+            ],
+          },
+        },
+      },
+      select: {
+        integration: {
+          select: {
+            id: true,
+            name: true,
+            picture: true,
+            inBetweenSteps: true,
+            providerIdentifier: true,
+          },
+        },
+      },
+    });
+
+    return integration?.integration;
+  }
+
+  async updateOnCustomerName(org: string, id: string, name: string) {
+    const customer = !name
+      ? undefined
+      : (await this._customers.model.customer.findFirst({
+          where: {
+            orgId: org,
+            name,
+          },
+        })) ||
+        (await this._customers.model.customer.create({
+          data: {
+            name,
+            orgId: org,
+          },
+        }));
+
+    return this._integration.model.integration.update({
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: {
+        customer: !customer
+          ? { disconnect: true }
+          : {
+              connect: {
+                id: customer.id,
+              },
+            },
+      },
+    });
+  }
+
+  updateIntegrationGroup(org: string, id: string, group: string) {
+    return this._integration.model.integration.update({
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: !group
+        ? {
+            customer: {
+              disconnect: true,
+            },
+          }
+        : {
+            customer: {
+              connect: {
+                id: group,
+              },
+            },
+          },
+    });
+  }
+
+  customers(orgId: string) {
+    return this._customers.model.customer.findMany({
+      where: {
+        orgId,
+        deletedAt: null,
+      },
+    });
+  }
+
+  getIntegrationsList(org: string) {
+    return this._integration.model.integration.findMany({
+      where: {
+        organizationId: org,
+        deletedAt: null,
+      },
+      include: {
+        customer: true,
+      },
+    });
+  }
+
+  async disableChannel(org: string, id: string) {
+    await this._integration.model.integration.update({
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: {
+        disabled: true,
+      },
+    });
+  }
+
+  async enableChannel(org: string, id: string) {
+    await this._integration.model.integration.update({
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: {
+        disabled: false,
+      },
+    });
+  }
+
+  getPostsForChannel(org: string, id: string) {
+    return this._posts.model.post.groupBy({
+      by: ['group'],
+      where: {
+        organizationId: org,
+        integrationId: id,
+        deletedAt: null,
+      },
+    });
+  }
+
+  deleteChannel(org: string, id: string) {
+    return this._integration.model.integration.update({
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: {
+        deletedAt: new Date(),
+      },
+    });
+  }
+
+  async checkForDeletedOnceAndUpdate(org: string, page: string) {
+    return this._integration.model.integration.updateMany({
+      where: {
+        organizationId: org,
+        internalId: page,
+        deletedAt: {
+          not: null,
+        },
+      },
+      data: {
+        internalId: makeId(10),
+      },
+    });
+  }
+
+  async disableIntegrations(org: string, totalChannels: number) {
+    const getChannels = await this._integration.model.integration.findMany({
+      where: {
+        organizationId: org,
+        disabled: false,
+        deletedAt: null,
+      },
+      take: totalChannels,
+      select: {
+        id: true,
+      },
+    });
+
+    for (const channel of getChannels) {
+      await this._integration.model.integration.update({
+        where: {
+          id: channel.id,
+        },
+        data: {
+          disabled: true,
+        },
+      });
+    }
+  }
+
+  getPlugsByIntegrationId(org: string, id: string) {
+    return this._plugs.model.plugs.findMany({
+      where: {
+        organizationId: org,
+        integrationId: id,
+      },
+    });
+  }
+
+  createOrUpdatePlug(org: string, integrationId: string, body: PlugDto) {
+    return this._plugs.model.plugs.upsert({
+      where: {
+        organizationId: org,
+        plugFunction_integrationId: {
+          integrationId,
+          plugFunction: body.func,
+        },
+      },
+      create: {
+        integrationId,
+        organizationId: org,
+        plugFunction: body.func,
+        data: JSON.stringify(body.fields),
+        activated: true,
+      },
+      update: {
+        data: JSON.stringify(body.fields),
+      },
+      select: {
+        activated: true,
+      },
+    });
+  }
+
+  changePlugActivation(orgId: string, plugId: string, status: boolean) {
+    return this._plugs.model.plugs.update({
+      where: {
+        organizationId: orgId,
+        id: plugId,
+      },
+      data: {
+        activated: !!status,
+      },
+    });
+  }
+
+  async loadExisingData(
+    methodName: string,
+    integrationId: string,
+    id: string[]
+  ) {
+    return this._exisingPlugData.model.exisingPlugData.findMany({
+      where: {
+        integrationId,
+        methodName,
+        value: {
+          in: id,
+        },
+      },
+    });
+  }
+
+  async saveExisingData(
+    methodName: string,
+    integrationId: string,
+    value: string[]
+  ) {
+    return this._exisingPlugData.model.exisingPlugData.createMany({
+      data: value.map((p) => ({
+        integrationId,
+        methodName,
+        value: p,
+      })),
+    });
+  }
+
+  async getPostingTimes(orgId: string, integrationsId?: string) {
+    return this._integration.model.integration.findMany({
+      where: {
+        ...(integrationsId ? { id: integrationsId } : {}),
+        organizationId: orgId,
+        disabled: false,
+        deletedAt: null,
+      },
+      select: {
+        postingTimes: true,
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/integrations/integration.service.ts

@@ -0,0 +1,569 @@
+import {
+  forwardRef,
+  HttpException,
+  HttpStatus,
+  Inject,
+  Injectable,
+} from '@nestjs/common';
+import { IntegrationRepository } from '@gitroom/nestjs-libraries/database/prisma/integrations/integration.repository';
+import { IntegrationManager } from '@gitroom/nestjs-libraries/integrations/integration.manager';
+import {
+  AnalyticsData,
+  SocialProvider,
+} from '@gitroom/nestjs-libraries/integrations/social/social.integrations.interface';
+import { Integration, Organization } from '@prisma/client';
+import { NotificationService } from '@gitroom/nestjs-libraries/database/prisma/notifications/notification.service';
+import dayjs from 'dayjs';
+import { timer } from '@gitroom/helpers/utils/timer';
+import { ioRedis } from '@gitroom/nestjs-libraries/redis/redis.service';
+import { RefreshToken } from '@gitroom/nestjs-libraries/integrations/social.abstract';
+import { IntegrationTimeDto } from '@gitroom/nestjs-libraries/dtos/integrations/integration.time.dto';
+import { UploadFactory } from '@gitroom/nestjs-libraries/upload/upload.factory';
+import { PlugDto } from '@gitroom/nestjs-libraries/dtos/plugs/plug.dto';
+import { difference, uniq } from 'lodash';
+import utc from 'dayjs/plugin/utc';
+import { AutopostRepository } from '@gitroom/nestjs-libraries/database/prisma/autopost/autopost.repository';
+import { RefreshIntegrationService } from '@gitroom/nestjs-libraries/integrations/refresh.integration.service';
+import { TemporalService } from 'nestjs-temporal-core';
+
+dayjs.extend(utc);
+
+@Injectable()
+export class IntegrationService {
+  private storage = UploadFactory.createStorage();
+  constructor(
+    private _integrationRepository: IntegrationRepository,
+    private _autopostsRepository: AutopostRepository,
+    private _integrationManager: IntegrationManager,
+    private _notificationService: NotificationService,
+    @Inject(forwardRef(() => RefreshIntegrationService))
+    private _refreshIntegrationService: RefreshIntegrationService,
+    private _temporalService: TemporalService
+  ) {}
+
+  async changeActiveCron(orgId: string) {
+    const data = await this._autopostsRepository.getAutoposts(orgId);
+
+    for (const item of data.filter((f) => f.active)) {
+      try {
+        await this._temporalService.terminateWorkflow(`autopost-${item.id}`);
+      } catch (err) {}
+    }
+
+    return true;
+  }
+
+  getMentions(platform: string, q: string) {
+    return this._integrationRepository.getMentions(platform, q);
+  }
+
+  insertMentions(
+    platform: string,
+    mentions: { name: string; username: string; image: string }[]
+  ) {
+    return this._integrationRepository.insertMentions(platform, mentions);
+  }
+
+  async setTimes(
+    orgId: string,
+    integrationId: string,
+    times: IntegrationTimeDto
+  ) {
+    return this._integrationRepository.setTimes(orgId, integrationId, times);
+  }
+
+  updateProviderSettings(org: string, id: string, additionalSettings: string) {
+    return this._integrationRepository.updateProviderSettings(
+      org,
+      id,
+      additionalSettings
+    );
+  }
+
+  checkPreviousConnections(org: string, id: string) {
+    return this._integrationRepository.checkPreviousConnections(org, id);
+  }
+
+  async createOrUpdateIntegration(
+    additionalSettings:
+      | {
+          title: string;
+          description: string;
+          type: 'checkbox' | 'text' | 'textarea';
+          value: any;
+          regex?: string;
+        }[]
+      | undefined,
+    oneTimeToken: boolean,
+    org: string,
+    name: string,
+    picture: string | undefined,
+    type: 'article' | 'social',
+    internalId: string,
+    provider: string,
+    token: string,
+    refreshToken = '',
+    expiresIn?: number,
+    username?: string,
+    isBetweenSteps = false,
+    refresh?: string,
+    timezone?: number,
+    customInstanceDetails?: string
+  ) {
+    const uploadedPicture = picture
+      ? picture?.indexOf('imagedelivery.net') > -1
+        ? picture
+        : await this.storage.uploadSimple(picture)
+      : undefined;
+
+    return this._integrationRepository.createOrUpdateIntegration(
+      additionalSettings,
+      oneTimeToken,
+      org,
+      name,
+      uploadedPicture,
+      type,
+      internalId,
+      provider,
+      token,
+      refreshToken,
+      expiresIn,
+      username,
+      isBetweenSteps,
+      refresh,
+      timezone,
+      customInstanceDetails
+    );
+  }
+
+  updateIntegrationGroup(org: string, id: string, group: string) {
+    return this._integrationRepository.updateIntegrationGroup(org, id, group);
+  }
+
+  updateOnCustomerName(org: string, id: string, name: string) {
+    return this._integrationRepository.updateOnCustomerName(org, id, name);
+  }
+
+  getIntegrationsList(org: string) {
+    return this._integrationRepository.getIntegrationsList(org);
+  }
+
+  getIntegrationForOrder(id: string, order: string, user: string, org: string) {
+    return this._integrationRepository.getIntegrationForOrder(
+      id,
+      order,
+      user,
+      org
+    );
+  }
+
+  updateNameAndUrl(id: string, name: string, url: string) {
+    return this._integrationRepository.updateNameAndUrl(id, name, url);
+  }
+
+  getIntegrationById(org: string, id: string) {
+    return this._integrationRepository.getIntegrationById(org, id);
+  }
+
+  async refreshToken(provider: SocialProvider, refresh: string) {
+    try {
+      const { refreshToken, accessToken, expiresIn } =
+        await provider.refreshToken(refresh);
+
+      if (!refreshToken || !accessToken || !expiresIn) {
+        return false;
+      }
+
+      return { refreshToken, accessToken, expiresIn };
+    } catch (e) {
+      return false;
+    }
+  }
+
+  async disconnectChannel(orgId: string, integration: Integration) {
+    await this._integrationRepository.disconnectChannel(orgId, integration.id);
+    await this.informAboutRefreshError(orgId, integration);
+  }
+
+  async informAboutRefreshError(
+    orgId: string,
+    integration: Integration,
+    err = ''
+  ) {
+    await this._notificationService.inAppNotification(
+      orgId,
+      `Could not refresh your ${integration.providerIdentifier} channel ${err}`,
+      `Could not refresh your ${integration.providerIdentifier} channel ${err}. Please go back to the system and connect it again ${process.env.FRONTEND_URL}/launches`,
+      true,
+      false,
+      'info'
+    );
+  }
+
+  async refreshNeeded(org: string, id: string) {
+    return this._integrationRepository.refreshNeeded(org, id);
+  }
+
+  async setBetweenRefreshSteps(id: string) {
+    return this._integrationRepository.setBetweenRefreshSteps(id);
+  }
+
+  async refreshTokens() {
+    const integrations = await this._integrationRepository.needsToBeRefreshed();
+    for (const integration of integrations) {
+      const provider = this._integrationManager.getSocialIntegration(
+        integration.providerIdentifier
+      );
+
+      const data = await this.refreshToken(provider, integration.refreshToken!);
+
+      if (!data) {
+        await this.informAboutRefreshError(
+          integration.organizationId,
+          integration
+        );
+        await this._integrationRepository.refreshNeeded(
+          integration.organizationId,
+          integration.id
+        );
+        return;
+      }
+
+      const { refreshToken, accessToken, expiresIn } = data;
+
+      await this.createOrUpdateIntegration(
+        undefined,
+        !!provider.oneTimeToken,
+        integration.organizationId,
+        integration.name,
+        undefined,
+        'social',
+        integration.internalId,
+        integration.providerIdentifier,
+        accessToken,
+        refreshToken,
+        expiresIn
+      );
+    }
+  }
+
+  async disableChannel(org: string, id: string) {
+    return this._integrationRepository.disableChannel(org, id);
+  }
+
+  async enableChannel(org: string, totalChannels: number, id: string) {
+    const integrations = (
+      await this._integrationRepository.getIntegrationsList(org)
+    ).filter((f) => !f.disabled);
+    if (
+      !!process.env.STRIPE_PUBLISHABLE_KEY &&
+      integrations.length >= totalChannels
+    ) {
+      throw new Error('You have reached the maximum number of channels');
+    }
+
+    return this._integrationRepository.enableChannel(org, id);
+  }
+
+  async getPostsForChannel(org: string, id: string) {
+    return this._integrationRepository.getPostsForChannel(org, id);
+  }
+
+  async deleteChannel(org: string, id: string) {
+    return this._integrationRepository.deleteChannel(org, id);
+  }
+
+  async disableIntegrations(org: string, totalChannels: number) {
+    return this._integrationRepository.disableIntegrations(org, totalChannels);
+  }
+
+  async checkForDeletedOnceAndUpdate(org: string, page: string) {
+    return this._integrationRepository.checkForDeletedOnceAndUpdate(org, page);
+  }
+
+  async saveProviderPage(org: string, id: string, data: any) {
+    const getIntegration = await this._integrationRepository.getIntegrationById(
+      org,
+      id
+    );
+    if (!getIntegration) {
+      throw new HttpException('Integration not found', HttpStatus.NOT_FOUND);
+    }
+    if (!getIntegration.inBetweenSteps) {
+      throw new HttpException('Invalid request', HttpStatus.BAD_REQUEST);
+    }
+
+    const provider = this._integrationManager.getSocialIntegration(
+      getIntegration.providerIdentifier
+    );
+
+    if (!provider.fetchPageInformation) {
+      throw new HttpException(
+        'Provider does not support page selection',
+        HttpStatus.BAD_REQUEST
+      );
+    }
+
+    const getIntegrationInformation = await provider.fetchPageInformation(
+      getIntegration.token,
+      data
+    );
+
+    await this.checkForDeletedOnceAndUpdate(
+      org,
+      String(getIntegrationInformation.id)
+    );
+    await this._integrationRepository.updateIntegration(id, {
+      picture: getIntegrationInformation.picture,
+      internalId: String(getIntegrationInformation.id),
+      organizationId: org,
+      name: getIntegrationInformation.name,
+      inBetweenSteps: false,
+      token: getIntegrationInformation.access_token,
+      profile: getIntegrationInformation.username,
+    });
+
+    return { success: true };
+  }
+
+  async checkAnalytics(
+    org: Organization,
+    integration: string,
+    date: string,
+    forceRefresh = false
+  ): Promise<AnalyticsData[]> {
+    const getIntegration = await this.getIntegrationById(org.id, integration);
+
+    if (!getIntegration) {
+      throw new Error('Invalid integration');
+    }
+
+    if (getIntegration.type !== 'social') {
+      return [];
+    }
+
+    const integrationProvider = this._integrationManager.getSocialIntegration(
+      getIntegration.providerIdentifier
+    );
+
+    if (
+      dayjs(getIntegration?.tokenExpiration).isBefore(dayjs()) ||
+      forceRefresh
+    ) {
+      const data = await this._refreshIntegrationService.refresh(
+        getIntegration
+      );
+      if (!data) {
+        return [];
+      }
+
+      const { accessToken } = data;
+
+      if (accessToken) {
+        getIntegration.token = accessToken;
+
+        if (integrationProvider.refreshWait) {
+          await timer(10000);
+        }
+      } else {
+        await this.disconnectChannel(org.id, getIntegration);
+        return [];
+      }
+    }
+
+    const getIntegrationData = await ioRedis.get(
+      `integration:${org.id}:${integration}:${date}`
+    );
+    if (getIntegrationData) {
+      return JSON.parse(getIntegrationData);
+    }
+
+    if (integrationProvider.analytics) {
+      try {
+        const loadAnalytics = await integrationProvider.analytics(
+          getIntegration.internalId,
+          getIntegration.token,
+          +date
+        );
+        await ioRedis.set(
+          `integration:${org.id}:${integration}:${date}`,
+          JSON.stringify(loadAnalytics),
+          'EX',
+          !process.env.NODE_ENV || process.env.NODE_ENV === 'development'
+            ? 1
+            : 3600
+        );
+        return loadAnalytics;
+      } catch (e) {
+        if (e instanceof RefreshToken) {
+          return this.checkAnalytics(org, integration, date, true);
+        }
+      }
+    }
+
+    return [];
+  }
+
+  customers(orgId: string) {
+    return this._integrationRepository.customers(orgId);
+  }
+
+  getPlugsByIntegrationId(org: string, integrationId: string) {
+    return this._integrationRepository.getPlugsByIntegrationId(
+      org,
+      integrationId
+    );
+  }
+
+  async processInternalPlug(
+    data: {
+      post: string;
+      originalIntegration: string;
+      integration: string;
+      plugName: string;
+      orgId: string;
+      delay: number;
+      information: any;
+    },
+    forceRefresh = false
+  ): Promise<any> {
+    const originalIntegration =
+      await this._integrationRepository.getIntegrationById(
+        data.orgId,
+        data.originalIntegration
+      );
+
+    const getIntegration = await this._integrationRepository.getIntegrationById(
+      data.orgId,
+      data.integration
+    );
+
+    if (!getIntegration || !originalIntegration) {
+      return;
+    }
+
+    const getAllInternalPlugs = this._integrationManager
+      .getInternalPlugs(getIntegration.providerIdentifier)
+      .internalPlugs.find((p: any) => p.identifier === data.plugName);
+
+    if (!getAllInternalPlugs) {
+      return;
+    }
+
+    const getSocialIntegration = this._integrationManager.getSocialIntegration(
+      getIntegration.providerIdentifier
+    );
+
+    // @ts-ignore
+    await getSocialIntegration?.[getAllInternalPlugs.methodName]?.(
+      getIntegration,
+      originalIntegration,
+      data.post,
+      data.information
+    );
+
+    return;
+  }
+
+  async processPlugs(data: {
+    plugId: string;
+    postId: string;
+    delay: number;
+    totalRuns: number;
+    currentRun: number;
+  }) {
+    const getPlugById = await this._integrationRepository.getPlug(data.plugId);
+    if (!getPlugById) {
+      return true;
+    }
+
+    const integration = this._integrationManager.getSocialIntegration(
+      getPlugById.integration.providerIdentifier
+    );
+
+    // @ts-ignore
+    const process = await integration[getPlugById.plugFunction](
+      getPlugById.integration,
+      data.postId,
+      JSON.parse(getPlugById.data).reduce((all: any, current: any) => {
+        all[current.name] = current.value;
+        return all;
+      }, {})
+    );
+
+    if (process) {
+      return true;
+    }
+
+    if (data.totalRuns === data.currentRun) {
+      return true;
+    }
+
+    return false;
+  }
+
+  async createOrUpdatePlug(
+    orgId: string,
+    integrationId: string,
+    body: PlugDto
+  ) {
+    const { activated } = await this._integrationRepository.createOrUpdatePlug(
+      orgId,
+      integrationId,
+      body
+    );
+
+    return {
+      activated,
+    };
+  }
+
+  async changePlugActivation(orgId: string, plugId: string, status: boolean) {
+    const { id, integrationId, plugFunction } =
+      await this._integrationRepository.changePlugActivation(
+        orgId,
+        plugId,
+        status
+      );
+
+    return { id };
+  }
+
+  async getPlugs(orgId: string, integrationId: string) {
+    return this._integrationRepository.getPlugs(orgId, integrationId);
+  }
+
+  async loadExisingData(
+    methodName: string,
+    integrationId: string,
+    id: string[]
+  ) {
+    const exisingData = await this._integrationRepository.loadExisingData(
+      methodName,
+      integrationId,
+      id
+    );
+    const loadOnlyIds = exisingData.map((p) => p.value);
+    return difference(id, loadOnlyIds);
+  }
+
+  async findFreeDateTime(
+    orgId: string,
+    integrationsId?: string
+  ): Promise<number[]> {
+    const findTimes = await this._integrationRepository.getPostingTimes(
+      orgId,
+      integrationsId
+    );
+    return uniq(
+      findTimes.reduce((all: any, current: any) => {
+        return [
+          ...all,
+          ...JSON.parse(current.postingTimes).map(
+            (p: { time: number }) => p.time
+          ),
+        ];
+      }, [] as number[])
+    );
+  }
+}

libraries/nestjs-libraries/src/database/prisma/media/media.repository.ts

@@ -0,0 +1,123 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { SaveMediaInformationDto } from '@gitroom/nestjs-libraries/dtos/media/save.media.information.dto';
+
+@Injectable()
+export class MediaRepository {
+  constructor(private _media: PrismaRepository<'media'>) {}
+
+  saveFile(org: string, fileName: string, filePath: string, originalName?: string) {
+    return this._media.model.media.create({
+      data: {
+        organization: {
+          connect: {
+            id: org,
+          },
+        },
+        name: fileName,
+        path: filePath,
+        originalName: originalName || null,
+      },
+      select: {
+        id: true,
+        name: true,
+        originalName: true,
+        path: true,
+        thumbnail: true,
+        alt: true,
+      },
+    });
+  }
+
+  getMediaById(id: string) {
+    return this._media.model.media.findUnique({
+      where: {
+        id,
+      },
+    });
+  }
+
+  deleteMedia(org: string, id: string) {
+    return this._media.model.media.update({
+      where: {
+        id,
+        organizationId: org,
+      },
+      data: {
+        deletedAt: new Date(),
+      },
+    });
+  }
+
+  saveMediaInformation(org: string, data: SaveMediaInformationDto) {
+    return this._media.model.media.update({
+      where: {
+        id: data.id,
+        organizationId: org,
+      },
+      data: {
+        alt: data.alt,
+        thumbnail: data.thumbnail,
+        thumbnailTimestamp: data.thumbnailTimestamp,
+      },
+      select: {
+        id: true,
+        name: true,
+        originalName: true,
+        alt: true,
+        thumbnail: true,
+        path: true,
+        thumbnailTimestamp: true,
+      },
+    });
+  }
+
+  async getMedia(org: string, page: number, search?: string) {
+    const pageNum = (page || 1) - 1;
+    const trimmedSearch = search?.trim();
+    const searchFilter = trimmedSearch
+      ? {
+          originalName: {
+            contains: trimmedSearch,
+            mode: 'insensitive' as const,
+          },
+        }
+      : {};
+    const query = {
+      where: {
+        organization: {
+          id: org,
+        },
+        deletedAt: null,
+        ...searchFilter,
+      },
+    };
+    const pages = Math.ceil((await this._media.model.media.count(query)) / 18);
+    const results = await this._media.model.media.findMany({
+      where: {
+        organizationId: org,
+        deletedAt: null,
+        ...searchFilter,
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+      select: {
+        id: true,
+        name: true,
+        originalName: true,
+        path: true,
+        thumbnail: true,
+        alt: true,
+        thumbnailTimestamp: true,
+      },
+      skip: pageNum * 18,
+      take: 18,
+    });
+
+    return {
+      pages,
+      results,
+    };
+  }
+}

libraries/nestjs-libraries/src/database/prisma/media/media.service.ts

@@ -0,0 +1,157 @@
+import { HttpException, Injectable } from '@nestjs/common';
+import { MediaRepository } from '@gitroom/nestjs-libraries/database/prisma/media/media.repository';
+import { OpenaiService } from '@gitroom/nestjs-libraries/openai/openai.service';
+import { generationError } from '@gitroom/nestjs-libraries/openai/generation.error';
+import { SubscriptionService } from '@gitroom/nestjs-libraries/database/prisma/subscriptions/subscription.service';
+import { Organization } from '@prisma/client';
+import { SaveMediaInformationDto } from '@gitroom/nestjs-libraries/dtos/media/save.media.information.dto';
+import { VideoManager } from '@gitroom/nestjs-libraries/videos/video.manager';
+import { VideoDto } from '@gitroom/nestjs-libraries/dtos/videos/video.dto';
+import { UploadFactory } from '@gitroom/nestjs-libraries/upload/upload.factory';
+import {
+  AuthorizationActions,
+  Sections,
+  SubscriptionException,
+} from '@gitroom/backend/services/auth/permissions/permission.exception.class';
+
+@Injectable()
+export class MediaService {
+  private storage = UploadFactory.createStorage();
+
+  constructor(
+    private _mediaRepository: MediaRepository,
+    private _openAi: OpenaiService,
+    private _subscriptionService: SubscriptionService,
+    private _videoManager: VideoManager
+  ) {}
+
+  async deleteMedia(org: string, id: string) {
+    return this._mediaRepository.deleteMedia(org, id);
+  }
+
+  getMediaById(id: string) {
+    return this._mediaRepository.getMediaById(id);
+  }
+
+  async generateImage(
+    prompt: string,
+    org: Organization,
+    generatePromptFirst?: boolean
+  ) {
+    try {
+      const generating = await this._subscriptionService.useCredit(
+        org,
+        'ai_images',
+        async () => {
+          if (generatePromptFirst) {
+            prompt = await this._openAi.generatePromptForPicture(prompt);
+            console.log('Prompt:', prompt);
+          }
+          return this._openAi.generateImage(prompt);
+        }
+      );
+
+      return generating;
+    } catch (err) {
+      throw generationError(err);
+    }
+  }
+
+  saveFile(org: string, fileName: string, filePath: string, originalName?: string) {
+    return this._mediaRepository.saveFile(org, fileName, filePath, originalName);
+  }
+
+  getMedia(org: string, page: number, search?: string) {
+    return this._mediaRepository.getMedia(org, page, search);
+  }
+
+  saveMediaInformation(org: string, data: SaveMediaInformationDto) {
+    return this._mediaRepository.saveMediaInformation(org, data);
+  }
+
+  getVideoOptions() {
+    return this._videoManager.getAllVideos();
+  }
+
+  async generateVideoAllowed(org: Organization, type: string) {
+    const video = this._videoManager.getVideoByName(type);
+    if (!video) {
+      throw new Error(`Video type ${type} not found`);
+    }
+
+    if (!video.trial && org.isTrailing) {
+      throw new HttpException('This video is not available in trial mode', 406);
+    }
+
+    return true;
+  }
+
+  async generateVideo(org: Organization, body: VideoDto) {
+    try {
+      const totalCredits = await this._subscriptionService.checkCredits(
+        org,
+        'ai_videos'
+      );
+
+      if (totalCredits.credits <= 0) {
+        throw new SubscriptionException({
+          action: AuthorizationActions.Create,
+          section: Sections.VIDEOS_PER_MONTH,
+        });
+      }
+
+      const video = this._videoManager.getVideoByName(body.type);
+      if (!video) {
+        throw new Error(`Video type ${body.type} not found`);
+      }
+
+      if (!video.trial && org.isTrailing) {
+        throw new HttpException(
+          'This video is not available in trial mode',
+          406
+        );
+      }
+
+      console.log(body.customParams);
+      await video.instance.processAndValidate(body.customParams);
+      console.log('no err');
+
+      return await this._subscriptionService.useCredit(
+        org,
+        'ai_videos',
+        async () => {
+          const loadedData = await video.instance.process(
+            body.output,
+            body.customParams
+          );
+
+          const file = await this.storage.uploadSimple(loadedData);
+          return this.saveFile(org.id, file.split('/').pop(), file);
+        }
+      );
+    } catch (err) {
+      throw generationError(err);
+    }
+  }
+
+  async videoFunction(identifier: string, functionName: string, body: any) {
+    const video = this._videoManager.getVideoByName(identifier);
+    if (!video) {
+      throw new Error(`Video with identifier ${identifier} not found`);
+    }
+
+    // @ts-ignore
+    const functionToCall = video.instance[functionName];
+    if (
+      typeof functionToCall !== 'function' ||
+      this._videoManager.checkAvailableVideoFunction(functionToCall)
+    ) {
+      throw new HttpException(
+        `Function ${functionName} not found on video instance`,
+        400
+      );
+    }
+
+    return functionToCall(body);
+  }
+}

libraries/nestjs-libraries/src/database/prisma/notifications/notification.service.ts

@@ -0,0 +1,117 @@
+import { Injectable } from '@nestjs/common';
+import { NotificationsRepository } from '@gitroom/nestjs-libraries/database/prisma/notifications/notifications.repository';
+import { EmailService } from '@gitroom/nestjs-libraries/services/email.service';
+import { OrganizationRepository } from '@gitroom/nestjs-libraries/database/prisma/organizations/organization.repository';
+import { TemporalService } from 'nestjs-temporal-core';
+import { TypedSearchAttributes } from '@temporalio/common';
+import { organizationId } from '@gitroom/nestjs-libraries/temporal/temporal.search.attribute';
+
+export type NotificationType = 'success' | 'fail' | 'info';
+
+@Injectable()
+export class NotificationService {
+  constructor(
+    private _notificationRepository: NotificationsRepository,
+    private _emailService: EmailService,
+    private _organizationRepository: OrganizationRepository,
+    private _temporalService: TemporalService
+  ) {}
+
+  getMainPageCount(organizationId: string, userId: string) {
+    return this._notificationRepository.getMainPageCount(
+      organizationId,
+      userId
+    );
+  }
+
+  getNotificationsPaginated(organizationId: string, page: number) {
+    return this._notificationRepository.getNotificationsPaginated(
+      organizationId,
+      page
+    );
+  }
+
+  getNotifications(organizationId: string, userId: string) {
+    return this._notificationRepository.getNotifications(
+      organizationId,
+      userId
+    );
+  }
+
+  async inAppNotification(
+    orgId: string,
+    subject: string,
+    message: string,
+    sendEmail = false,
+    digest = false,
+    type: NotificationType = 'success'
+  ) {
+    await this._notificationRepository.createNotification(orgId, message);
+    if (!sendEmail) {
+      return;
+    }
+
+    if (digest) {
+      try {
+        await this._temporalService.client
+          .getRawClient()
+          ?.workflow.signalWithStart('digestEmailWorkflow', {
+            workflowId: 'digest_email_workflow_' + orgId,
+            signal: 'email',
+            signalArgs: [
+              [
+                {
+                  title: subject,
+                  message,
+                  type,
+                },
+              ],
+            ],
+            taskQueue: 'main',
+            workflowIdConflictPolicy: 'USE_EXISTING',
+            args: [{ organizationId: orgId }],
+            typedSearchAttributes: new TypedSearchAttributes([
+              {
+                key: organizationId,
+                value: orgId,
+              },
+            ]),
+          });
+      } catch (err) {}
+
+      return;
+    }
+
+    await this.sendEmailsToOrg(orgId, subject, message, type);
+  }
+
+  async sendEmailsToOrg(
+    orgId: string,
+    subject: string,
+    message: string,
+    type?: NotificationType
+  ) {
+    const userOrg = await this._organizationRepository.getAllUsersOrgs(orgId);
+    for (const user of userOrg?.users || []) {
+      // 'info' type is always sent regardless of preferences
+      if (type !== 'info') {
+        // Filter users based on their email preferences
+        if (type === 'success' && !user.user.sendSuccessEmails) {
+          continue;
+        }
+        if (type === 'fail' && !user.user.sendFailureEmails) {
+          continue;
+        }
+      }
+      await this.sendEmail(user.user.email, subject, message);
+    }
+  }
+
+  async sendEmail(to: string, subject: string, html: string, replyTo?: string) {
+    await this._emailService.sendEmail(to, subject, html, 'top', replyTo);
+  }
+
+  hasEmailProvider() {
+    return this._emailService.hasProvider();
+  }
+}

libraries/nestjs-libraries/src/database/prisma/notifications/notifications.repository.ts

@@ -0,0 +1,126 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class NotificationsRepository {
+  constructor(
+    private _notifications: PrismaRepository<'notifications'>,
+    private _user: PrismaRepository<'user'>
+  ) {}
+
+  getLastReadNotification(userId: string) {
+    return this._user.model.user.findFirst({
+      where: {
+        id: userId,
+      },
+      select: {
+        lastReadNotifications: true,
+      },
+    });
+  }
+
+  async getMainPageCount(organizationId: string, userId: string) {
+    const { lastReadNotifications } = (await this.getLastReadNotification(
+      userId
+    ))!;
+
+    return {
+      total: await this._notifications.model.notifications.count({
+        where: {
+          organizationId,
+          createdAt: {
+            gt: lastReadNotifications!,
+          },
+        },
+      }),
+    };
+  }
+
+  async createNotification(organizationId: string, content: string) {
+    await this._notifications.model.notifications.create({
+      data: {
+        organizationId,
+        content,
+      },
+    });
+  }
+
+  async getNotificationsSince(organizationId: string, since: string) {
+    return this._notifications.model.notifications.findMany({
+      where: {
+        organizationId,
+        createdAt: {
+          gte: new Date(since),
+        },
+      },
+    });
+  }
+
+  async getNotificationsPaginated(organizationId: string, page: number) {
+    const limit = 100;
+    const skip = page * limit;
+
+    const where = {
+      organizationId,
+      deletedAt: null as Date | null,
+    };
+
+    const [notifications, total] = await Promise.all([
+      this._notifications.model.notifications.findMany({
+        where,
+        orderBy: {
+          createdAt: 'desc',
+        },
+        skip,
+        take: limit,
+        select: {
+          id: true,
+          content: true,
+          link: true,
+          createdAt: true,
+        },
+      }),
+      this._notifications.model.notifications.count({ where }),
+    ]);
+
+    return {
+      notifications,
+      total,
+      page,
+      limit,
+      hasMore: skip + notifications.length < total,
+    };
+  }
+
+  async getNotifications(organizationId: string, userId: string) {
+    const { lastReadNotifications } = (await this.getLastReadNotification(
+      userId
+    ))!;
+
+    await this._user.model.user.update({
+      where: {
+        id: userId,
+      },
+      data: {
+        lastReadNotifications: new Date(),
+      },
+    });
+
+    return {
+      lastReadNotifications,
+      notifications: await this._notifications.model.notifications.findMany({
+        orderBy: {
+          createdAt: 'desc',
+        },
+        take: 10,
+        where: {
+          organizationId,
+        },
+        select: {
+          createdAt: true,
+          content: true,
+        },
+      }),
+    };
+  }
+}

libraries/nestjs-libraries/src/database/prisma/oauth/oauth.repository.ts

@@ -0,0 +1,252 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+
+@Injectable()
+export class OAuthRepository {
+  constructor(
+    private _oauthApp: PrismaRepository<'oAuthApp'>,
+    private _oauthAuth: PrismaRepository<'oAuthAuthorization'>
+  ) {}
+
+  getAppByOrgId(orgId: string) {
+    return this._oauthApp.model.oAuthApp.findFirst({
+      where: {
+        organizationId: orgId,
+        deletedAt: null,
+      },
+      include: {
+        picture: true,
+      },
+    });
+  }
+
+  getAppByClientId(clientId: string) {
+    return this._oauthApp.model.oAuthApp.findFirst({
+      where: {
+        clientId,
+        deletedAt: null,
+      },
+      include: {
+        picture: true,
+      },
+    });
+  }
+
+  createApp(
+    orgId: string,
+    data: {
+      name: string;
+      description?: string;
+      pictureId?: string;
+      redirectUrl: string;
+      clientId: string;
+      clientSecret: string;
+    }
+  ) {
+    return this._oauthApp.model.oAuthApp.create({
+      data: {
+        organizationId: orgId,
+        name: data.name,
+        description: data.description,
+        pictureId: data.pictureId,
+        redirectUrl: data.redirectUrl,
+        clientId: data.clientId,
+        clientSecret: data.clientSecret,
+      },
+      include: {
+        picture: true,
+      },
+    });
+  }
+
+  async updateApp(
+    orgId: string,
+    data: {
+      name?: string;
+      description?: string;
+      pictureId?: string;
+      redirectUrl?: string;
+    }
+  ) {
+    const app = await this._oauthApp.model.oAuthApp.findFirst({
+      where: {
+        organizationId: orgId,
+        deletedAt: null,
+      },
+    });
+    if (!app) {
+      return null;
+    }
+    return this._oauthApp.model.oAuthApp.update({
+      where: { id: app.id },
+      data,
+      include: {
+        picture: true,
+      },
+    });
+  }
+
+  async deleteApp(orgId: string) {
+    const app = await this._oauthApp.model.oAuthApp.findFirst({
+      where: {
+        organizationId: orgId,
+        deletedAt: null,
+      },
+    });
+    if (!app) {
+      return null;
+    }
+    return this._oauthApp.model.oAuthApp.update({
+      where: { id: app.id },
+      data: {
+        deletedAt: new Date(),
+      },
+    });
+  }
+
+  async updateClientSecret(orgId: string, newSecret: string) {
+    const app = await this._oauthApp.model.oAuthApp.findFirst({
+      where: {
+        organizationId: orgId,
+        deletedAt: null,
+      },
+    });
+    if (!app) {
+      return null;
+    }
+    return this._oauthApp.model.oAuthApp.update({
+      where: { id: app.id },
+      data: {
+        clientSecret: newSecret,
+      },
+    });
+  }
+
+  createAuthorization(data: {
+    oauthAppId: string;
+    userId: string;
+    organizationId: string;
+    authorizationCode: string;
+    codeExpiresAt: Date;
+  }) {
+    return this._oauthAuth.model.oAuthAuthorization.upsert({
+      where: {
+        oauthAppId_userId_organizationId: {
+          oauthAppId: data.oauthAppId,
+          userId: data.userId,
+          organizationId: data.organizationId,
+        },
+      },
+      create: {
+        oauthAppId: data.oauthAppId,
+        userId: data.userId,
+        organizationId: data.organizationId,
+        authorizationCode: data.authorizationCode,
+        codeExpiresAt: data.codeExpiresAt,
+      },
+      update: {
+        authorizationCode: data.authorizationCode,
+        codeExpiresAt: data.codeExpiresAt,
+        accessToken: null,
+        revokedAt: null,
+      },
+    });
+  }
+
+  findByCode(encryptedCode: string) {
+    return this._oauthAuth.model.oAuthAuthorization.findFirst({
+      where: {
+        authorizationCode: encryptedCode,
+        revokedAt: null,
+      },
+    });
+  }
+
+  exchangeCodeForToken(id: string, encryptedToken: string) {
+    return this._oauthAuth.model.oAuthAuthorization.update({
+      where: { id },
+      select: {
+        organizationId: true,
+        organization: {
+          select: {
+            paymentId: true,
+          }
+        }
+      },
+      data: {
+        accessToken: encryptedToken,
+        authorizationCode: null,
+        codeExpiresAt: null,
+      },
+    });
+  }
+
+  findByAccessToken(encryptedToken: string) {
+    return this._oauthAuth.model.oAuthAuthorization.findFirst({
+      where: {
+        accessToken: encryptedToken,
+        revokedAt: null,
+      },
+      include: {
+        organization: {
+          include: {
+            subscription: {
+              select: {
+                subscriptionTier: true,
+                totalChannels: true,
+                isLifetime: true,
+              },
+            },
+          },
+        },
+        user: {
+          select: { id: true },
+        },
+      },
+    });
+  }
+
+  getApprovedApps(userId: string) {
+    return this._oauthAuth.model.oAuthAuthorization.findMany({
+      where: {
+        userId,
+        revokedAt: null,
+        accessToken: { not: null },
+      },
+      include: {
+        oauthApp: {
+          include: {
+            picture: true,
+          },
+        },
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+  }
+
+  revokeAuthorization(userId: string, authId: string) {
+    return this._oauthAuth.model.oAuthAuthorization.update({
+      where: {
+        id: authId,
+        userId,
+      },
+      data: {
+        revokedAt: new Date(),
+      },
+    });
+  }
+
+  revokeAllForApp(oauthAppId: string) {
+    return this._oauthAuth.model.oAuthAuthorization.updateMany({
+      where: {
+        oauthAppId,
+        revokedAt: null,
+      },
+      data: {
+        revokedAt: new Date(),
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/oauth/oauth.service.ts

@@ -0,0 +1,170 @@
+import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
+import { OAuthRepository } from '@gitroom/nestjs-libraries/database/prisma/oauth/oauth.repository';
+import { CreateOAuthAppDto } from '@gitroom/nestjs-libraries/dtos/oauth/create-oauth-app.dto';
+import { UpdateOAuthAppDto } from '@gitroom/nestjs-libraries/dtos/oauth/update-oauth-app.dto';
+import { makeId } from '@gitroom/nestjs-libraries/services/make.is';
+import { AuthService } from '@gitroom/helpers/auth/auth.service';
+
+@Injectable()
+export class OAuthService {
+  constructor(private _oauthRepository: OAuthRepository) {}
+
+  async getApp(orgId: string) {
+    const app = await this._oauthRepository.getAppByOrgId(orgId);
+    if (!app) return false;
+    const { clientSecret, ...rest } = app;
+    return rest;
+  }
+
+  async createApp(orgId: string, dto: CreateOAuthAppDto) {
+    const existing = await this._oauthRepository.getAppByOrgId(orgId);
+    if (existing) {
+      throw new HttpException(
+        'You can only have one OAuth application per organization',
+        HttpStatus.BAD_REQUEST
+      );
+    }
+
+    const clientId = 'pca_' + makeId(32);
+    const clientSecret = 'pcs_' + makeId(48);
+    const encryptedSecret = AuthService.fixedEncryption(clientSecret);
+
+    const app = await this._oauthRepository.createApp(orgId, {
+      name: dto.name,
+      description: dto.description,
+      pictureId: dto.pictureId,
+      redirectUrl: dto.redirectUrl,
+      clientId,
+      clientSecret: encryptedSecret,
+    });
+
+    return { ...app, clientSecret };
+  }
+
+  async updateApp(orgId: string, dto: UpdateOAuthAppDto) {
+    return this._oauthRepository.updateApp(orgId, {
+      ...(dto.name && { name: dto.name }),
+      ...(dto.description !== undefined && { description: dto.description }),
+      ...(dto.pictureId !== undefined && { pictureId: dto.pictureId }),
+      ...(dto.redirectUrl && { redirectUrl: dto.redirectUrl }),
+    });
+  }
+
+  async deleteApp(orgId: string) {
+    const app = await this._oauthRepository.getAppByOrgId(orgId);
+    if (!app) {
+      throw new HttpException('No OAuth app found', HttpStatus.NOT_FOUND);
+    }
+    await this._oauthRepository.revokeAllForApp(app.id);
+    await this._oauthRepository.deleteApp(orgId);
+    return { success: true };
+  }
+
+  async rotateSecret(orgId: string) {
+    const app = await this._oauthRepository.getAppByOrgId(orgId);
+    if (!app) {
+      throw new HttpException('No OAuth app found', HttpStatus.NOT_FOUND);
+    }
+
+    const newSecret = 'pcs_' + makeId(48);
+    const encrypted = AuthService.fixedEncryption(newSecret);
+    await this._oauthRepository.updateClientSecret(orgId, encrypted);
+    return { clientSecret: newSecret };
+  }
+
+  async validateAuthorizationRequest(clientId: string) {
+    const app = await this._oauthRepository.getAppByClientId(clientId);
+    if (!app) {
+      throw new HttpException('Invalid client_id', HttpStatus.BAD_REQUEST);
+    }
+    return app;
+  }
+
+  async createAuthorizationCode(
+    oauthAppId: string,
+    userId: string,
+    organizationId: string
+  ) {
+    const code = makeId(32);
+    const encryptedCode = AuthService.fixedEncryption(code);
+    const codeExpiresAt = new Date(Date.now() + 10 * 60 * 1000);
+
+    await this._oauthRepository.createAuthorization({
+      oauthAppId,
+      userId,
+      organizationId,
+      authorizationCode: encryptedCode,
+      codeExpiresAt,
+    });
+
+    return code;
+  }
+
+  async exchangeCodeForToken(
+    code: string,
+    clientId: string,
+    clientSecret: string
+  ) {
+    const app = await this._oauthRepository.getAppByClientId(clientId);
+    if (!app) {
+      throw new HttpException(
+        { error: 'invalid_client' },
+        HttpStatus.UNAUTHORIZED
+      );
+    }
+
+    if (app.clientSecret !== AuthService.fixedEncryption(clientSecret)) {
+      throw new HttpException(
+        { error: 'invalid_client' },
+        HttpStatus.UNAUTHORIZED
+      );
+    }
+
+    const encryptedCode = AuthService.fixedEncryption(code);
+    const auth = await this._oauthRepository.findByCode(encryptedCode);
+    if (!auth || auth.oauthAppId !== app.id) {
+      throw new HttpException(
+        { error: 'invalid_grant' },
+        HttpStatus.BAD_REQUEST
+      );
+    }
+
+    if (!auth.codeExpiresAt || new Date() > auth.codeExpiresAt) {
+      throw new HttpException(
+        { error: 'invalid_grant', error_description: 'Code has expired' },
+        HttpStatus.BAD_REQUEST
+      );
+    }
+
+    const token = 'pos_' + makeId(40);
+    const encryptedToken = AuthService.fixedEncryption(token);
+    const {
+      organizationId,
+      organization: { paymentId },
+    } = await this._oauthRepository.exchangeCodeForToken(
+      auth.id,
+      encryptedToken
+    );
+
+    return {
+      id: organizationId,
+      cus: paymentId,
+      access_token: token,
+      token_type: 'bearer',
+    };
+  }
+
+  async getOrgByOAuthToken(token: string) {
+    const encrypted = AuthService.fixedEncryption(token);
+    return this._oauthRepository.findByAccessToken(encrypted);
+  }
+
+  async getApprovedApps(userId: string) {
+    return this._oauthRepository.getApprovedApps(userId);
+  }
+
+  async revokeApp(userId: string, authId: string) {
+    await this._oauthRepository.revokeAuthorization(userId, authId);
+    return { success: true };
+  }
+}

libraries/nestjs-libraries/src/database/prisma/organizations/organization.repository.ts

@@ -0,0 +1,422 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Role, ShortLinkPreference, SubscriptionTier } from '@prisma/client';
+import { Injectable } from '@nestjs/common';
+import { AuthService } from '@gitroom/helpers/auth/auth.service';
+import { CreateOrgUserDto } from '@gitroom/nestjs-libraries/dtos/auth/create.org.user.dto';
+import { makeId } from '@gitroom/nestjs-libraries/services/make.is';
+
+@Injectable()
+export class OrganizationRepository {
+  constructor(
+    private _organization: PrismaRepository<'organization'>,
+    private _userOrg: PrismaRepository<'userOrganization'>,
+    private _user: PrismaRepository<'user'>
+  ) {}
+
+  createMaxUser(id: string, name: string, saasName: string, email: string) {
+    return this._organization.model.organization.create({
+      select: {
+        id: true,
+        apiKey: true,
+      },
+      data: {
+        name: name ? `${name}###${id}` : `Unnamed User###${id}`,
+        apiKey: AuthService.fixedEncryption(makeId(20)),
+        isTrailing: false,
+        subscription: {
+          create: {
+            totalChannels: 1000000,
+            subscriptionTier: 'ULTIMATE',
+            isLifetime: true,
+            period: 'YEARLY',
+          },
+        },
+        users: {
+          create: {
+            role: Role.SUPERADMIN,
+            user: {
+              create: {
+                activated: true,
+                email: email
+                  ? email.split('@').join(`+${saasName}@`)
+                  : `${saasName}+` + makeId(10) + '@postiz.com',
+                name: name ? `${name}###${id}` : `Unnamed User###${id}`,
+                providerName: 'LOCAL',
+                password: AuthService.hashPassword(makeId(500)),
+                timezone: 0,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  getOrgByApiKey(api: string) {
+    return this._organization.model.organization.findFirst({
+      where: {
+        apiKey: api,
+      },
+      include: {
+        subscription: {
+          select: {
+            subscriptionTier: true,
+            totalChannels: true,
+            isLifetime: true,
+          },
+        },
+      },
+    });
+  }
+
+  getCount() {
+    return this._organization.model.organization.count();
+  }
+
+  getUserOrg(id: string) {
+    return this._userOrg.model.userOrganization.findFirst({
+      where: {
+        id,
+      },
+      select: {
+        user: true,
+        organization: {
+          include: {
+            users: {
+              select: {
+                id: true,
+                disabled: true,
+                role: true,
+                userId: true,
+              },
+            },
+            subscription: {
+              select: {
+                subscriptionTier: true,
+                totalChannels: true,
+                isLifetime: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  getImpersonateUser(name: string) {
+    return this._userOrg.model.userOrganization.findMany({
+      where: {
+        OR: [
+          {
+            organizationId: {
+              contains: name,
+            },
+          },
+          {
+            user: {
+              OR: [
+                {
+                  name: {
+                    contains: name,
+                  },
+                },
+                {
+                  email: {
+                    contains: name,
+                  },
+                },
+                {
+                  id: {
+                    contains: name,
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      },
+      select: {
+        id: true,
+        organization: {
+          select: {
+            id: true,
+          },
+        },
+        user: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+      },
+    });
+  }
+
+  updateApiKey(orgId: string) {
+    return this._organization.model.organization.update({
+      where: {
+        id: orgId,
+      },
+      data: {
+        apiKey: AuthService.fixedEncryption(makeId(20)),
+      },
+    });
+  }
+
+  async getOrgsByUserId(userId: string) {
+    return this._organization.model.organization.findMany({
+      where: {
+        users: {
+          some: {
+            userId,
+          },
+        },
+      },
+      include: {
+        users: {
+          where: {
+            userId,
+          },
+          select: {
+            disabled: true,
+            role: true,
+          },
+        },
+        subscription: {
+          select: {
+            subscriptionTier: true,
+            totalChannels: true,
+            isLifetime: true,
+            createdAt: true,
+          },
+        },
+      },
+    });
+  }
+
+  async getOrgById(id: string) {
+    return this._organization.model.organization.findUnique({
+      where: {
+        id,
+      },
+    });
+  }
+
+  async addUserToOrg(
+    userId: string,
+    id: string,
+    orgId: string,
+    role: 'USER' | 'ADMIN'
+  ) {
+    const checkIfInviteExists = await this._user.model.user.findFirst({
+      where: {
+        inviteId: id,
+      },
+    });
+
+    if (checkIfInviteExists) {
+      return false;
+    }
+
+    const checkForSubscription =
+      await this._organization.model.organization.findFirst({
+        where: {
+          id: orgId,
+        },
+        select: {
+          subscription: true,
+        },
+      });
+
+    if (
+      process.env.STRIPE_PUBLISHABLE_KEY &&
+      checkForSubscription?.subscription?.subscriptionTier ===
+        SubscriptionTier.STANDARD
+    ) {
+      return false;
+    }
+
+    const create = await this._userOrg.model.userOrganization.create({
+      data: {
+        role,
+        userId,
+        organizationId: orgId,
+      },
+    });
+
+    await this._user.model.user.update({
+      where: {
+        id: userId,
+      },
+      data: {
+        inviteId: id,
+      },
+    });
+
+    return create;
+  }
+
+  async createOrgAndUser(
+    body: Omit<CreateOrgUserDto, 'providerToken'> & { providerId?: string },
+    hasEmail: boolean,
+    ip: string,
+    userAgent: string
+  ) {
+    return this._organization.model.organization.create({
+      data: {
+        name: body.company,
+        apiKey: AuthService.fixedEncryption(makeId(20)),
+        allowTrial: true,
+        isTrailing: true,
+        users: {
+          create: {
+            role: Role.SUPERADMIN,
+            user: {
+              create: {
+                activated: body.provider !== 'LOCAL' || !hasEmail,
+                email: body.email,
+                password: body.password
+                  ? AuthService.hashPassword(body.password)
+                  : '',
+                providerName: body.provider,
+                providerId: body.providerId || '',
+                timezone: 0,
+                ip,
+                agent: userAgent,
+              },
+            },
+          },
+        },
+      },
+      select: {
+        id: true,
+        users: {
+          select: {
+            user: true,
+          },
+        },
+      },
+    });
+  }
+
+  getOrgByCustomerId(customerId: string) {
+    return this._organization.model.organization.findFirst({
+      where: {
+        paymentId: customerId,
+      },
+    });
+  }
+
+  async setStreak(organizationId: string, type: 'start' | 'end') {
+    try {
+      await this._organization.model.organization.update({
+        where: {
+          id: organizationId,
+          ...(type === 'start'
+            ? {
+                streakSince: null,
+              }
+            : {}),
+        },
+        data: {
+          ...(type === 'end' ? { streakSince: null } : {}),
+          ...(type === 'start' ? { streakSince: new Date() } : {}),
+        },
+      });
+    } catch (err) {}
+  }
+
+  async getTeam(orgId: string) {
+    return this._organization.model.organization.findUnique({
+      where: {
+        id: orgId,
+      },
+      select: {
+        users: {
+          select: {
+            role: true,
+            user: {
+              select: {
+                email: true,
+                id: true,
+                sendSuccessEmails: true,
+                sendFailureEmails: true,
+                sendStreakEmails: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  getAllUsersOrgs(orgId: string) {
+    return this._organization.model.organization.findUnique({
+      where: {
+        id: orgId,
+      },
+      select: {
+        users: {
+          select: {
+            user: {
+              select: {
+                email: true,
+                id: true,
+                sendSuccessEmails: true,
+                sendFailureEmails: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  async deleteTeamMember(orgId: string, userId: string) {
+    return this._userOrg.model.userOrganization.delete({
+      where: {
+        userId_organizationId: {
+          userId,
+          organizationId: orgId,
+        },
+      },
+    });
+  }
+
+  disableOrEnableNonSuperAdminUsers(orgId: string, disable: boolean) {
+    return this._userOrg.model.userOrganization.updateMany({
+      where: {
+        organizationId: orgId,
+        role: {
+          not: Role.SUPERADMIN,
+        },
+      },
+      data: {
+        disabled: disable,
+      },
+    });
+  }
+
+  getShortlinkPreference(orgId: string) {
+    return this._organization.model.organization.findUnique({
+      where: {
+        id: orgId,
+      },
+      select: {
+        shortlink: true,
+      },
+    });
+  }
+
+  updateShortlinkPreference(orgId: string, shortlink: ShortLinkPreference) {
+    return this._organization.model.organization.update({
+      where: {
+        id: orgId,
+      },
+      data: {
+        shortlink,
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/organizations/organization.service.ts

@@ -0,0 +1,133 @@
+import { CreateOrgUserDto } from '@gitroom/nestjs-libraries/dtos/auth/create.org.user.dto';
+import { Injectable } from '@nestjs/common';
+import { OrganizationRepository } from '@gitroom/nestjs-libraries/database/prisma/organizations/organization.repository';
+import { NotificationService } from '@gitroom/nestjs-libraries/database/prisma/notifications/notification.service';
+import { AddTeamMemberDto } from '@gitroom/nestjs-libraries/dtos/settings/add.team.member.dto';
+import { AuthService } from '@gitroom/helpers/auth/auth.service';
+import dayjs from 'dayjs';
+import { makeId } from '@gitroom/nestjs-libraries/services/make.is';
+import { Organization, ShortLinkPreference } from '@prisma/client';
+import { AutopostService } from '@gitroom/nestjs-libraries/database/prisma/autopost/autopost.service';
+
+@Injectable()
+export class OrganizationService {
+  constructor(
+    private _organizationRepository: OrganizationRepository,
+    private _notificationsService: NotificationService
+  ) {}
+  async createOrgAndUser(
+    body: Omit<CreateOrgUserDto, 'providerToken'> & { providerId?: string },
+    ip: string,
+    userAgent: string
+  ) {
+    return this._organizationRepository.createOrgAndUser(
+      body,
+      this._notificationsService.hasEmailProvider(),
+      ip,
+      userAgent
+    );
+  }
+
+  async getCount() {
+    return this._organizationRepository.getCount();
+  }
+
+  async createMaxUser(id: string, name: string, saasName: string, email: string) {
+    return this._organizationRepository.createMaxUser(id, name, saasName, email);
+  }
+
+  addUserToOrg(
+    userId: string,
+    id: string,
+    orgId: string,
+    role: 'USER' | 'ADMIN'
+  ) {
+    return this._organizationRepository.addUserToOrg(userId, id, orgId, role);
+  }
+
+  getOrgById(id: string) {
+    return this._organizationRepository.getOrgById(id);
+  }
+
+  getOrgByApiKey(api: string) {
+    return this._organizationRepository.getOrgByApiKey(api);
+  }
+
+  getUserOrg(id: string) {
+    return this._organizationRepository.getUserOrg(id);
+  }
+
+  getOrgsByUserId(userId: string) {
+    return this._organizationRepository.getOrgsByUserId(userId);
+  }
+
+  updateApiKey(orgId: string) {
+    return this._organizationRepository.updateApiKey(orgId);
+  }
+
+  getTeam(orgId: string) {
+    return this._organizationRepository.getTeam(orgId);
+  }
+
+  async setStreak(organizationId: string, type: 'start' | 'end') {
+    return this._organizationRepository.setStreak(organizationId, type);
+  }
+
+  getOrgByCustomerId(customerId: string) {
+    return this._organizationRepository.getOrgByCustomerId(customerId);
+  }
+
+  async inviteTeamMember(orgId: string, body: AddTeamMemberDto) {
+    const timeLimit = dayjs().add(2, 'day').format('YYYY-MM-DD HH:mm:ss');
+    const id = makeId(5);
+    const url =
+      process.env.FRONTEND_URL +
+      `/?org=${AuthService.signJWT({ ...body, orgId, timeLimit, id })}`;
+    if (body.sendEmail) {
+      await this._notificationsService.sendEmail(
+        body.email,
+        'You have been invited to join an organization',
+        `You have been invited to join an organization. Click <a href="${url}">here</a> to join.<br />The link will expire in 2 days.`
+      );
+    }
+    return { url };
+  }
+
+  async deleteTeamMember(org: Organization, userId: string) {
+    const userOrgs = await this._organizationRepository.getOrgsByUserId(userId);
+    const findOrgToDelete = userOrgs.find((orgUser) => orgUser.id === org.id);
+    if (!findOrgToDelete) {
+      throw new Error('User is not part of this organization');
+    }
+
+    // @ts-ignore
+    const myRole = org.users[0].role;
+    const userRole = findOrgToDelete.users[0].role;
+    const myLevel = myRole === 'USER' ? 0 : myRole === 'ADMIN' ? 1 : 2;
+    const userLevel = userRole === 'USER' ? 0 : userRole === 'ADMIN' ? 1 : 2;
+
+    if (myLevel < userLevel) {
+      throw new Error('You do not have permission to delete this user');
+    }
+
+    return this._organizationRepository.deleteTeamMember(org.id, userId);
+  }
+
+  disableOrEnableNonSuperAdminUsers(orgId: string, disable: boolean) {
+    return this._organizationRepository.disableOrEnableNonSuperAdminUsers(
+      orgId,
+      disable
+    );
+  }
+
+  getShortlinkPreference(orgId: string) {
+    return this._organizationRepository.getShortlinkPreference(orgId);
+  }
+
+  updateShortlinkPreference(orgId: string, shortlink: ShortLinkPreference) {
+    return this._organizationRepository.updateShortlinkPreference(
+      orgId,
+      shortlink
+    );
+  }
+}

libraries/nestjs-libraries/src/database/prisma/posts/posts.repository.ts

@@ -0,0 +1,923 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { Post as PostBody } from '@gitroom/nestjs-libraries/dtos/posts/create.post.dto';
+import {
+  APPROVED_SUBMIT_FOR_ORDER,
+  CreationMethod,
+  Post,
+  State,
+} from '@prisma/client';
+import { GetPostsDto } from '@gitroom/nestjs-libraries/dtos/posts/get.posts.dto';
+import { GetPostsListDto } from '@gitroom/nestjs-libraries/dtos/posts/get.posts.list.dto';
+import dayjs from 'dayjs';
+import isoWeek from 'dayjs/plugin/isoWeek';
+import weekOfYear from 'dayjs/plugin/weekOfYear';
+import isSameOrAfter from 'dayjs/plugin/isSameOrAfter';
+import utc from 'dayjs/plugin/utc';
+import { v4 as uuidv4 } from 'uuid';
+import { CreateTagDto } from '@gitroom/nestjs-libraries/dtos/posts/create.tag.dto';
+
+dayjs.extend(isoWeek);
+dayjs.extend(weekOfYear);
+dayjs.extend(isSameOrAfter);
+dayjs.extend(utc);
+
+@Injectable()
+export class PostsRepository {
+  constructor(
+    private _post: PrismaRepository<'post'>,
+    private _popularPosts: PrismaRepository<'popularPosts'>,
+    private _comments: PrismaRepository<'comments'>,
+    private _tags: PrismaRepository<'tags'>,
+    private _tagsPosts: PrismaRepository<'tagsPosts'>,
+    private _errors: PrismaRepository<'errors'>
+  ) {}
+
+  searchForMissingThreeHoursPosts() {
+    return this._post.model.post.findMany({
+      where: {
+        integration: {
+          refreshNeeded: false,
+          inBetweenSteps: false,
+          disabled: false,
+          deletedAt: null,
+        },
+        publishDate: {
+          gte: dayjs.utc().subtract(2, 'day').toDate(),
+          lt: dayjs.utc().toDate(),
+        },
+        state: 'QUEUE',
+        deletedAt: null,
+        parentPostId: null,
+      },
+      select: {
+        id: true,
+        organizationId: true,
+        integration: {
+          select: {
+            providerIdentifier: true,
+          },
+        },
+        publishDate: true,
+      },
+    });
+  }
+
+  getOldPosts(orgId: string, date: string) {
+    return this._post.model.post.findMany({
+      where: {
+        integration: {
+          refreshNeeded: false,
+          inBetweenSteps: false,
+          disabled: false,
+        },
+        organizationId: orgId,
+        publishDate: {
+          lte: dayjs(date).toDate(),
+        },
+        deletedAt: null,
+        parentPostId: null,
+      },
+      orderBy: {
+        publishDate: 'desc',
+      },
+      select: {
+        id: true,
+        content: true,
+        publishDate: true,
+        releaseURL: true,
+        state: true,
+        integration: {
+          select: {
+            id: true,
+            name: true,
+            providerIdentifier: true,
+            picture: true,
+            type: true,
+          },
+        },
+      },
+    });
+  }
+
+  updateImages(id: string, images: string) {
+    return this._post.model.post.update({
+      where: {
+        id,
+      },
+      data: {
+        image: images,
+      },
+    });
+  }
+
+  getPostUrls(orgId: string, ids: string[]) {
+    return this._post.model.post.findMany({
+      where: {
+        organizationId: orgId,
+        id: {
+          in: ids,
+        },
+      },
+      select: {
+        id: true,
+        releaseURL: true,
+      },
+    });
+  }
+
+  async getPosts(orgId: string, query: GetPostsDto) {
+    // Use the provided start and end dates directly
+    const startDate = dayjs.utc(query.startDate).toDate();
+    const endDate = dayjs.utc(query.endDate).toDate();
+
+    const list = await this._post.model.post.findMany({
+      where: {
+        AND: [
+          {
+            OR: [
+              {
+                organizationId: orgId,
+              },
+            ],
+          },
+          {
+            OR: [
+              {
+                publishDate: {
+                  gte: startDate,
+                  lte: endDate,
+                },
+              },
+              {
+                intervalInDays: {
+                  not: null,
+                },
+              },
+            ],
+          },
+        ],
+        integration: {
+          deletedAt: null,
+          organizationId: orgId,
+        },
+        deletedAt: null,
+        parentPostId: null,
+        ...(query.customer
+          ? {
+              integration: {
+                customerId: query.customer,
+              },
+            }
+          : {}),
+      },
+      select: {
+        id: true,
+        content: true,
+        publishDate: true,
+        releaseURL: true,
+        releaseId: true,
+        state: true,
+        intervalInDays: true,
+        group: true,
+        creationMethod: true,
+        tags: {
+          select: {
+            tag: true,
+          },
+        },
+        integration: {
+          select: {
+            id: true,
+            providerIdentifier: true,
+            name: true,
+            picture: true,
+          },
+        },
+      },
+    });
+
+    return list.reduce((all, post) => {
+      if (!post.intervalInDays) {
+        return [...all, post];
+      }
+
+      const addMorePosts = [];
+      let startingDate = dayjs.utc(post.publishDate);
+      while (dayjs.utc(endDate).isSameOrAfter(startingDate)) {
+        if (dayjs(startingDate).isSameOrAfter(dayjs.utc(post.publishDate))) {
+          addMorePosts.push({
+            ...post,
+            publishDate: startingDate.toDate(),
+            actualDate: post.publishDate,
+          });
+        }
+
+        startingDate = startingDate.add(post.intervalInDays, 'days');
+      }
+
+      return [...all, ...addMorePosts];
+    }, [] as any[]);
+  }
+
+  async getPostsList(orgId: string, query: GetPostsListDto) {
+    const page = query.page || 0;
+    const limit = query.limit || 20;
+    const skip = page * limit;
+
+    const stateFilter = query.state || 'all';
+    const stateAndDate =
+      stateFilter === 'scheduled'
+        ? {
+            state: State.QUEUE,
+          }
+        : stateFilter === 'draft'
+        ? { state: State.DRAFT }
+        : stateFilter === 'published'
+        ? { state: State.PUBLISHED }
+        : {
+            state: {
+              in: [State.QUEUE, State.DRAFT, State.PUBLISHED, State.ERROR],
+            },
+          };
+
+    const orderDirection: 'asc' | 'desc' =
+      stateFilter === 'published' ? 'desc' : 'asc';
+
+    const where = {
+      AND: [
+        {
+          OR: [
+            {
+              organizationId: orgId,
+            },
+          ],
+        },
+      ],
+      ...stateAndDate,
+      // Published posts were already posted (publishDate in the past), so fetch
+      // all of them; everything else stays upcoming. Ordering handles the rest.
+      ...(stateFilter === 'published'
+        ? {}
+        : { publishDate: { gte: dayjs.utc().toDate() } }),
+      deletedAt: null as Date | null,
+      parentPostId: null as string | null,
+      intervalInDays: null as number | null,
+
+      integration: {
+        deletedAt: null as any,
+        organizationId: orgId,
+        ...(query.customer
+          ? {
+              customerId: query.customer,
+            }
+          : {}),
+      },
+    };
+
+    const [posts, total] = await Promise.all([
+      this._post.model.post.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy: {
+          publishDate: orderDirection,
+        },
+        select: {
+          id: true,
+          content: true,
+          publishDate: true,
+          releaseURL: true,
+          releaseId: true,
+          state: true,
+          intervalInDays: true,
+          group: true,
+          creationMethod: true,
+          tags: {
+            select: {
+              tag: true,
+            },
+          },
+          integration: {
+            select: {
+              id: true,
+              providerIdentifier: true,
+              name: true,
+              picture: true,
+            },
+          },
+        },
+      }),
+      this._post.model.post.count({ where }),
+    ]);
+
+    return {
+      posts,
+      total,
+      page,
+      limit,
+      hasMore: skip + posts.length < total,
+    };
+  }
+
+  async deletePost(orgId: string, group: string) {
+    await this._post.model.post.updateMany({
+      where: {
+        organizationId: orgId,
+        group,
+      },
+      data: {
+        deletedAt: new Date(),
+      },
+    });
+
+    return this._post.model.post.findFirst({
+      where: {
+        organizationId: orgId,
+        group,
+        parentPostId: null,
+      },
+      select: {
+        id: true,
+      },
+    });
+  }
+
+  getPostsByGroup(orgId: string, group: string) {
+    return this._post.model.post.findMany({
+      where: {
+        group,
+        ...(orgId ? { organizationId: orgId } : {}),
+        deletedAt: null,
+      },
+      include: {
+        integration: true,
+        tags: {
+          select: {
+            tag: true,
+          },
+        },
+      },
+    });
+  }
+
+  getPost(
+    id: string,
+    includeIntegration = false,
+    orgId?: string,
+    isFirst?: boolean
+  ) {
+    return this._post.model.post.findUnique({
+      where: {
+        id,
+        ...(orgId ? { organizationId: orgId } : {}),
+        deletedAt: null,
+      },
+      include: {
+        ...(includeIntegration
+          ? {
+              integration: true,
+              tags: {
+                select: {
+                  tag: true,
+                },
+              },
+            }
+          : {}),
+        childrenPost: true,
+      },
+    });
+  }
+
+  updatePost(id: string, postId: string, releaseURL: string) {
+    return this._post.model.post.update({
+      where: {
+        id,
+      },
+      data: {
+        state: 'PUBLISHED',
+        releaseURL,
+        releaseId: postId,
+      },
+    });
+  }
+
+  updateReleaseId(id: string, orgId: string, releaseId: string) {
+    return this._post.model.post.update({
+      where: {
+        id,
+        organizationId: orgId,
+        releaseId: 'missing',
+      },
+      data: {
+        releaseId: String(releaseId),
+      },
+    });
+  }
+
+  async changeState(id: string, state: State, err?: any, body?: any) {
+    const update = await this._post.model.post.update({
+      where: {
+        id,
+      },
+      data: {
+        state,
+        ...(err
+          ? { error: typeof err === 'string' ? err : JSON.stringify(err) }
+          : {}),
+      },
+      include: {
+        integration: {
+          select: {
+            providerIdentifier: true,
+          },
+        },
+      },
+    });
+
+    if (state === 'ERROR' && err && body) {
+      try {
+        await this._errors.model.errors.create({
+          data: {
+            message: typeof err === 'string' ? err : JSON.stringify(err),
+            organizationId: update.organizationId,
+            platform: update.integration.providerIdentifier,
+            postId: update.id,
+            body: typeof body === 'string' ? body : JSON.stringify(body),
+          },
+        });
+      } catch (err) {}
+    }
+
+    return update;
+  }
+
+  getErrorsByPostIds(postIds: string[]) {
+    return this._errors.model.errors.findMany({
+      where: {
+        postId: { in: postIds },
+      },
+      orderBy: { createdAt: 'desc' },
+    });
+  }
+
+  async changeDate(
+    orgId: string,
+    id: string,
+    date: string,
+    isDraft: boolean,
+    action: 'schedule' | 'update' = 'schedule'
+  ) {
+    return this._post.model.post.update({
+      where: {
+        organizationId: orgId,
+        id,
+      },
+      data: {
+        publishDate: dayjs(date).toDate(),
+        // schedule: set state to QUEUE (or DRAFT if it was a draft)
+        // update: don't change the state
+        ...(action === 'schedule'
+          ? {
+              state: isDraft ? 'DRAFT' : 'QUEUE',
+              releaseId: null,
+              releaseURL: null,
+            }
+          : {}),
+      },
+    });
+  }
+
+  countPostsFromDay(orgId: string, date: Date) {
+    return this._post.model.post.count({
+      where: {
+        organizationId: orgId,
+        publishDate: {
+          gte: date,
+        },
+        OR: [
+          {
+            deletedAt: null,
+            state: {
+              in: ['QUEUE'],
+            },
+          },
+          {
+            state: 'PUBLISHED',
+          },
+        ],
+      },
+    });
+  }
+
+  async createOrUpdatePost(
+    state: 'draft' | 'schedule' | 'now' | 'update',
+    orgId: string,
+    date: string,
+    body: PostBody,
+    tags: { value: string; label: string }[],
+    creationMethod: CreationMethod,
+    inter?: number
+  ) {
+    const posts: Post[] = [];
+    const uuid = uuidv4();
+
+    for (const value of body.value) {
+      const updateData = (type: 'create' | 'update') => ({
+        publishDate: dayjs(date).toDate(),
+        integration: {
+          connect: {
+            id: body.integration.id,
+            organizationId: orgId,
+          },
+        },
+        ...(posts?.[posts.length - 1]?.id
+          ? {
+              parentPost: {
+                connect: {
+                  id: posts[posts.length - 1]?.id,
+                },
+              },
+            }
+          : type === 'update'
+          ? {
+              parentPost: {
+                disconnect: true,
+              },
+            }
+          : {}),
+        content: value.content,
+        delay: value.delay || 0,
+        group: uuid,
+        intervalInDays: inter ? +inter : null,
+        approvedSubmitForOrder: APPROVED_SUBMIT_FOR_ORDER.NO,
+        ...(type === 'create' ? { creationMethod } : {}),
+        ...(state === 'update'
+          ? {}
+          : {
+              state:
+                state === 'draft' ? ('DRAFT' as const) : ('QUEUE' as const),
+            }),
+        image: JSON.stringify(value.image),
+        settings: JSON.stringify(body.settings),
+        organization: {
+          connect: {
+            id: orgId,
+          },
+        },
+      });
+
+      posts.push(
+        await this._post.model.post.upsert({
+          where: {
+            id: value.id || uuidv4(),
+          },
+          create: { ...updateData('create') },
+          update: {
+            ...updateData('update'),
+            lastMessage: {
+              disconnect: true,
+            },
+            submittedForOrder: {
+              disconnect: true,
+            },
+          },
+        })
+      );
+
+      if (posts.length === 1) {
+        await this._tagsPosts.model.tagsPosts.deleteMany({
+          where: {
+            post: {
+              id: posts[0].id,
+            },
+          },
+        });
+
+        if (tags.length) {
+          const tagsList = await this._tags.model.tags.findMany({
+            where: {
+              orgId: orgId,
+              name: {
+                in: tags.map((tag) => tag.label).filter((f) => f),
+              },
+            },
+          });
+
+          if (tagsList.length) {
+            await this._post.model.post.update({
+              where: {
+                id: posts[posts.length - 1].id,
+              },
+              data: {
+                tags: {
+                  createMany: {
+                    data: tagsList.map((tag) => ({
+                      tagId: tag.id,
+                    })),
+                  },
+                },
+              },
+            });
+          }
+        }
+      }
+    }
+
+    const previousPost = body.group
+      ? (
+          await this._post.model.post.findFirst({
+            where: {
+              group: body.group,
+              deletedAt: null,
+              parentPostId: null,
+            },
+            select: {
+              id: true,
+            },
+          })
+        )?.id!
+      : undefined;
+
+    if (body.group) {
+      await this._post.model.post.updateMany({
+        where: {
+          group: body.group,
+          deletedAt: null,
+        },
+        data: {
+          parentPostId: null,
+          deletedAt: new Date(),
+        },
+      });
+    }
+
+    return { previousPost, posts };
+  }
+
+  async submit(id: string, order: string, buyerOrganizationId: string) {
+    return this._post.model.post.update({
+      where: {
+        id,
+      },
+      data: {
+        submittedForOrderId: order,
+        approvedSubmitForOrder: 'WAITING_CONFIRMATION',
+        submittedForOrganizationId: buyerOrganizationId,
+      },
+      select: {
+        id: true,
+        description: true,
+        submittedForOrder: {
+          select: {
+            messageGroupId: true,
+          },
+        },
+      },
+    });
+  }
+
+  updateMessage(id: string, messageId: string) {
+    return this._post.model.post.update({
+      where: {
+        id,
+      },
+      data: {
+        lastMessageId: messageId,
+      },
+    });
+  }
+
+  getPostById(id: string, org?: string) {
+    return this._post.model.post.findUnique({
+      where: {
+        id,
+        ...(org ? { organizationId: org } : {}),
+      },
+      include: {
+        integration: true,
+        submittedForOrder: {
+          include: {
+            posts: {
+              where: {
+                state: 'PUBLISHED',
+              },
+            },
+            ordersItems: true,
+            seller: {
+              select: {
+                id: true,
+                account: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  findAllExistingCategories() {
+    return this._popularPosts.model.popularPosts.findMany({
+      select: {
+        category: true,
+      },
+      distinct: ['category'],
+    });
+  }
+
+  findAllExistingTopicsOfCategory(category: string) {
+    return this._popularPosts.model.popularPosts.findMany({
+      where: {
+        category,
+      },
+      select: {
+        topic: true,
+      },
+      distinct: ['topic'],
+    });
+  }
+
+  findPopularPosts(category: string, topic?: string) {
+    return this._popularPosts.model.popularPosts.findMany({
+      where: {
+        category,
+        ...(topic ? { topic } : {}),
+      },
+      select: {
+        content: true,
+        hook: true,
+      },
+    });
+  }
+
+  createPopularPosts(post: {
+    category: string;
+    topic: string;
+    content: string;
+    hook: string;
+  }) {
+    return this._popularPosts.model.popularPosts.create({
+      data: {
+        category: 'category',
+        topic: 'topic',
+        content: 'content',
+        hook: 'hook',
+      },
+    });
+  }
+
+  async getPostsCountsByDates(
+    orgId: string,
+    times: number[],
+    date: dayjs.Dayjs
+  ) {
+    const dates = await this._post.model.post.findMany({
+      where: {
+        deletedAt: null,
+        organizationId: orgId,
+        publishDate: {
+          in: times.map((time) => {
+            return date.clone().add(time, 'minutes').toDate();
+          }),
+        },
+      },
+    });
+
+    return times.filter(
+      (time) =>
+        date.clone().add(time, 'minutes').isAfter(dayjs.utc()) &&
+        !dates.find((dateFind) => {
+          return (
+            dayjs
+              .utc(dateFind.publishDate)
+              .diff(date.clone().startOf('day'), 'minutes') == time
+          );
+        })
+    );
+  }
+
+  async getComments(postId: string) {
+    return this._comments.model.comments.findMany({
+      where: {
+        postId,
+      },
+      orderBy: {
+        createdAt: 'asc',
+      },
+    });
+  }
+
+  async getTags(orgId: string) {
+    return this._tags.model.tags.findMany({
+      where: {
+        orgId,
+        deletedAt: null,
+      },
+    });
+  }
+
+  createTag(orgId: string, body: CreateTagDto) {
+    return this._tags.model.tags.create({
+      data: {
+        orgId,
+        name: body.name,
+        color: body.color,
+      },
+    });
+  }
+
+  editTag(id: string, orgId: string, body: CreateTagDto) {
+    return this._tags.model.tags.update({
+      where: {
+        id,
+      },
+      data: {
+        name: body.name,
+        color: body.color,
+      },
+    });
+  }
+
+  deleteTag(id: string, orgId: string) {
+    return this._tags.model.tags.update({
+      where: {
+        id,
+        orgId,
+      },
+      data: {
+        deletedAt: new Date(),
+      },
+    });
+  }
+
+  createComment(
+    orgId: string,
+    userId: string,
+    postId: string,
+    content: string
+  ) {
+    return this._comments.model.comments.create({
+      data: {
+        organizationId: orgId,
+        userId,
+        postId,
+        content,
+      },
+    });
+  }
+
+  async getPostByForWebhookId(postId: string) {
+    return this._post.model.post.findMany({
+      where: {
+        id: postId,
+        deletedAt: null,
+        parentPostId: null,
+      },
+      select: {
+        id: true,
+        content: true,
+        publishDate: true,
+        releaseURL: true,
+        state: true,
+        integration: {
+          select: {
+            id: true,
+            name: true,
+            providerIdentifier: true,
+            picture: true,
+            type: true,
+          },
+        },
+      },
+    });
+  }
+
+  async getPostsSince(orgId: string, since: string) {
+    return this._post.model.post.findMany({
+      where: {
+        organizationId: orgId,
+        publishDate: {
+          gte: new Date(since),
+        },
+        deletedAt: null,
+        parentPostId: null,
+      },
+      select: {
+        id: true,
+        content: true,
+        publishDate: true,
+        releaseURL: true,
+        state: true,
+        integration: {
+          select: {
+            id: true,
+            name: true,
+            providerIdentifier: true,
+            picture: true,
+            type: true,
+          },
+        },
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/posts/posts.service.ts

@@ -0,0 +1,1174 @@
+import {
+  BadRequestException,
+  Injectable,
+  ValidationPipe,
+} from '@nestjs/common';
+import { PostsRepository } from '@gitroom/nestjs-libraries/database/prisma/posts/posts.repository';
+import { CreatePostDto } from '@gitroom/nestjs-libraries/dtos/posts/create.post.dto';
+import dayjs from 'dayjs';
+import { IntegrationManager } from '@gitroom/nestjs-libraries/integrations/integration.manager';
+import {
+  Integration,
+  Post,
+  Media,
+  From,
+  CreationMethod,
+  State,
+} from '@prisma/client';
+import { GetPostsDto } from '@gitroom/nestjs-libraries/dtos/posts/get.posts.dto';
+import { GetPostsListDto } from '@gitroom/nestjs-libraries/dtos/posts/get.posts.list.dto';
+import { shuffle } from 'lodash';
+import { CreateGeneratedPostsDto } from '@gitroom/nestjs-libraries/dtos/generator/create.generated.posts.dto';
+import { IntegrationService } from '@gitroom/nestjs-libraries/database/prisma/integrations/integration.service';
+import { makeId } from '@gitroom/nestjs-libraries/services/make.is';
+import utc from 'dayjs/plugin/utc';
+import { MediaService } from '@gitroom/nestjs-libraries/database/prisma/media/media.service';
+import { ShortLinkService } from '@gitroom/nestjs-libraries/short-linking/short.link.service';
+import { CreateTagDto } from '@gitroom/nestjs-libraries/dtos/posts/create.tag.dto';
+import {
+  minifyPostsList,
+  minifyPosts,
+} from '@gitroom/helpers/utils/posts.list.minify';
+import axios from 'axios';
+import sharp from 'sharp';
+import { UploadFactory } from '@gitroom/nestjs-libraries/upload/upload.factory';
+import { Readable } from 'stream';
+import { OpenaiService } from '@gitroom/nestjs-libraries/openai/openai.service';
+dayjs.extend(utc);
+import * as Sentry from '@sentry/nestjs';
+import { TemporalService } from 'nestjs-temporal-core';
+import { TypedSearchAttributes } from '@temporalio/common';
+import {
+  organizationId,
+  postId as postIdSearchParam,
+} from '@gitroom/nestjs-libraries/temporal/temporal.search.attribute';
+import { AnalyticsData } from '@gitroom/nestjs-libraries/integrations/social/social.integrations.interface';
+import { timer } from '@gitroom/helpers/utils/timer';
+import { ioRedis } from '@gitroom/nestjs-libraries/redis/redis.service';
+import { RefreshToken } from '@gitroom/nestjs-libraries/integrations/social.abstract';
+import { RefreshIntegrationService } from '@gitroom/nestjs-libraries/integrations/refresh.integration.service';
+import { hasExtension } from '@gitroom/helpers/utils/has.extension';
+import { stripLinks } from '@gitroom/helpers/utils/strip.links';
+import { validate } from 'class-validator';
+import { plainToInstance } from 'class-transformer';
+import { stripHtmlValidation } from '@gitroom/helpers/utils/strip.html.validation';
+import { weightedLength } from '@gitroom/helpers/utils/count.length';
+
+type PostWithConditionals = Post & {
+  integration?: Integration;
+  childrenPost: Post[];
+};
+
+@Injectable()
+export class PostsService {
+  private storage = UploadFactory.createStorage();
+  constructor(
+    private _postRepository: PostsRepository,
+    private _integrationManager: IntegrationManager,
+    private _integrationService: IntegrationService,
+    private _mediaService: MediaService,
+    private _shortLinkService: ShortLinkService,
+    private _openaiService: OpenaiService,
+    private _temporalService: TemporalService,
+    private _refreshIntegrationService: RefreshIntegrationService
+  ) {}
+
+  searchForMissingThreeHoursPosts() {
+    return this._postRepository.searchForMissingThreeHoursPosts();
+  }
+
+  updatePost(id: string, postId: string, releaseURL: string) {
+    return this._postRepository.updatePost(id, postId, releaseURL);
+  }
+
+  async getMissingContent(
+    orgId: string,
+    postId: string,
+    forceRefresh = false
+  ): Promise<{ id: string; url: string }[]> {
+    const post = await this._postRepository.getPostById(postId, orgId);
+    if (!post || post.releaseId !== 'missing') {
+      return [];
+    }
+
+    const integrationProvider = this._integrationManager.getSocialIntegration(
+      post.integration.providerIdentifier
+    );
+
+    if (!integrationProvider.missing) {
+      return [];
+    }
+
+    const getIntegration = post.integration!;
+
+    if (
+      dayjs(getIntegration?.tokenExpiration).isBefore(dayjs()) ||
+      forceRefresh
+    ) {
+      const data = await this._refreshIntegrationService.refresh(
+        getIntegration
+      );
+      if (!data) {
+        return [];
+      }
+
+      const { accessToken } = data;
+
+      if (accessToken) {
+        getIntegration.token = accessToken;
+
+        if (integrationProvider.refreshWait) {
+          await timer(10000);
+        }
+      } else {
+        await this._integrationService.disconnectChannel(orgId, getIntegration);
+        return [];
+      }
+    }
+
+    try {
+      return await integrationProvider.missing(
+        getIntegration.internalId,
+        getIntegration.token
+      );
+    } catch (e) {
+      console.log(e);
+      if (e instanceof RefreshToken) {
+        return this.getMissingContent(orgId, postId, true);
+      }
+    }
+
+    return [];
+  }
+
+  async getPostById(postId: string, orgId: string) {
+    return this._postRepository.getPostById(postId, orgId);
+  }
+
+  async updateReleaseId(orgId: string, postId: string, releaseId: string) {
+    return this._postRepository.updateReleaseId(postId, orgId, releaseId);
+  }
+
+  async checkPostAnalytics(
+    orgId: string,
+    postId: string,
+    date: number,
+    forceRefresh = false
+  ): Promise<AnalyticsData[] | { missing: true }> {
+    const post = await this._postRepository.getPostById(postId, orgId);
+    if (!post || !post.releaseId) {
+      return [];
+    }
+
+    if (post.releaseId === 'missing') {
+      return { missing: true };
+    }
+
+    const integrationProvider = this._integrationManager.getSocialIntegration(
+      post.integration.providerIdentifier
+    );
+
+    if (!integrationProvider.postAnalytics) {
+      return [];
+    }
+
+    const getIntegration = post.integration!;
+
+    if (
+      dayjs(getIntegration?.tokenExpiration).isBefore(dayjs()) ||
+      forceRefresh
+    ) {
+      const data = await this._refreshIntegrationService.refresh(
+        getIntegration
+      );
+      if (!data) {
+        return [];
+      }
+
+      const { accessToken } = data;
+
+      if (accessToken) {
+        getIntegration.token = accessToken;
+
+        if (integrationProvider.refreshWait) {
+          await timer(10000);
+        }
+      } else {
+        await this._integrationService.disconnectChannel(orgId, getIntegration);
+        return [];
+      }
+    }
+
+    // const getIntegrationData = await ioRedis.get(
+    //   `integration:${orgId}:${post.id}:${date}`
+    // );
+    // if (getIntegrationData) {
+    //   return JSON.parse(getIntegrationData);
+    // }
+
+    try {
+      const loadAnalytics = await integrationProvider.postAnalytics(
+        getIntegration.internalId,
+        getIntegration.token,
+        post.releaseId,
+        date
+      );
+      await ioRedis.set(
+        `integration:${orgId}:${post.id}:${date}`,
+        JSON.stringify(loadAnalytics),
+        'EX',
+        !process.env.NODE_ENV || process.env.NODE_ENV === 'development'
+          ? 1
+          : 3600
+      );
+      return loadAnalytics;
+    } catch (e) {
+      console.log(e);
+      if (e instanceof RefreshToken) {
+        return this.checkPostAnalytics(orgId, postId, date, true);
+      }
+    }
+
+    return [];
+  }
+
+  async getStatistics(orgId: string, id: string) {
+    const getPost = await this.getPostsRecursively(id, true, orgId, true);
+    const content = getPost.map((p) => p.content);
+    const shortLinksTracking = await this._shortLinkService.getStatistics(
+      content
+    );
+
+    return {
+      clicks: shortLinksTracking,
+    };
+  }
+
+  async mapTypeToPost(
+    body: CreatePostDto,
+    organization: string,
+    replaceDraft: boolean = false
+  ): Promise<CreatePostDto> {
+    if (!body?.posts?.every((p) => p?.integration?.id)) {
+      throw new BadRequestException('All posts must have an integration id');
+    }
+
+    const mappedValues = {
+      ...body,
+      type: replaceDraft ? 'schedule' : body?.type,
+      posts: await Promise.all(
+        body?.posts?.map(async (post) => {
+          const integration = await this._integrationService.getIntegrationById(
+            organization,
+            post.integration.id
+          );
+
+          if (!integration) {
+            throw new BadRequestException(
+              `Integration with id ${post.integration.id} not found`
+            );
+          }
+
+          return {
+            type: replaceDraft ? 'schedule' : body?.type,
+            ...post,
+            settings: {
+              ...(post.settings || ({} as any)),
+              __type: integration.providerIdentifier,
+            },
+          };
+        }) || []
+      ),
+    };
+
+    const validationPipe = new ValidationPipe({
+      skipMissingProperties: false,
+      transform: true,
+      transformOptions: {
+        enableImplicitConversion: true,
+      },
+    });
+
+    return await validationPipe.transform(mappedValues, {
+      type: 'body',
+      metatype: CreatePostDto,
+    });
+  }
+
+  async getPostsRecursively(
+    id: string,
+    includeIntegration = false,
+    orgId?: string,
+    isFirst?: boolean
+  ): Promise<PostWithConditionals[]> {
+    const post = await this._postRepository.getPost(
+      id,
+      includeIntegration,
+      orgId,
+      isFirst
+    );
+
+    if (!post) {
+      return [];
+    }
+
+    return [
+      post!,
+      ...(post?.childrenPost?.length
+        ? await this.getPostsRecursively(
+            post?.childrenPost?.[0]?.id,
+            false,
+            orgId,
+            false
+          )
+        : []),
+    ];
+  }
+
+  async getPosts(orgId: string, query: GetPostsDto) {
+    return this._postRepository.getPosts(orgId, query);
+  }
+
+  async getPostsMinified(orgId: string, query: GetPostsDto) {
+    return minifyPosts({
+      posts: await this._postRepository.getPosts(orgId, query),
+    });
+  }
+
+  async getPostsList(orgId: string, query: GetPostsListDto) {
+    return minifyPostsList(
+      await this._postRepository.getPostsList(orgId, query)
+    );
+  }
+
+  async updateMedia(id: string, imagesList: any[], convertToJPEG = false) {
+    try {
+      let imageUpdateNeeded = false;
+      const getImageList = await Promise.all(
+        (
+          await Promise.all(
+            (imagesList || []).map(async (p: any) => {
+              if (!p.path && p.id) {
+                imageUpdateNeeded = true;
+                return this._mediaService.getMediaById(p.id);
+              }
+
+              return p;
+            })
+          )
+        )
+          .map((m) => {
+            return {
+              ...m,
+              url:
+                m.path.indexOf('http') === -1
+                  ? process.env.FRONTEND_URL +
+                    '/' +
+                    process.env.NEXT_PUBLIC_UPLOAD_STATIC_DIRECTORY +
+                    m.path
+                  : m.path,
+              type: 'image',
+              path:
+                m.path.indexOf('http') === -1
+                  ? process.env.UPLOAD_DIRECTORY + m.path
+                  : m.path,
+            };
+          })
+          .map(async (m) => {
+            if (!convertToJPEG) {
+              return m;
+            }
+
+            if (hasExtension(m.path, 'png')) {
+              imageUpdateNeeded = true;
+              const response = await axios.get(m.url, {
+                responseType: 'arraybuffer',
+              });
+
+              const imageBuffer = Buffer.from(response.data);
+
+              // Use sharp to get the metadata of the image
+              const buffer = await sharp(imageBuffer)
+                .jpeg({ quality: 100 })
+                .toBuffer();
+
+              const { path, originalname } = await this.storage.uploadFile({
+                buffer,
+                mimetype: 'image/jpeg',
+                size: buffer.length,
+                path: '',
+                fieldname: '',
+                destination: '',
+                stream: new Readable(),
+                filename: '',
+                originalname: '',
+                encoding: '',
+              });
+
+              return {
+                ...m,
+                name: originalname,
+                url:
+                  path.indexOf('http') === -1
+                    ? process.env.FRONTEND_URL +
+                      '/' +
+                      process.env.NEXT_PUBLIC_UPLOAD_STATIC_DIRECTORY +
+                      path
+                    : path,
+                type: 'image',
+                path:
+                  path.indexOf('http') === -1
+                    ? process.env.UPLOAD_DIRECTORY + path
+                    : path,
+              };
+            }
+
+            return m;
+          })
+      );
+
+      if (imageUpdateNeeded) {
+        await this._postRepository.updateImages(
+          id,
+          JSON.stringify(getImageList)
+        );
+      }
+
+      return getImageList;
+    } catch (err: any) {
+      return imagesList;
+    }
+  }
+
+  async getPostGroupDebugExport(orgId: string, group: string) {
+    const loadAll = await this._postRepository.getPostsByGroup(orgId, group);
+    const errors = await this._postRepository.getErrorsByPostIds(
+      loadAll.map((p) => p.id)
+    );
+    const posts = this.arrangePostsByGroup(loadAll, undefined);
+    const rootPost = posts[0] as any;
+
+    return {
+      type: 'draft' as const,
+      shortLink: false,
+      date: rootPost.publishDate.toISOString(),
+      tags:
+        rootPost.tags?.map((t: any) => ({
+          value: t.tag.id,
+          label: t.tag.name,
+        })) || [],
+      posts: [
+        {
+          integration: { id: 'REPLACE_WITH_LOCAL_INTEGRATION_ID' },
+          group: rootPost.group,
+          settings: JSON.parse(rootPost.settings || '{}'),
+          value: posts.map((post) => ({
+            content: post.content,
+            image: JSON.parse(post.image || '[]'),
+            delay: post.delay || 0,
+          })),
+        },
+      ],
+      _debug: {
+        providerIdentifier: rootPost.integration?.providerIdentifier,
+        providerName: rootPost.integration?.name,
+        state: rootPost.state,
+        error: rootPost.error,
+        errors: errors.map((e) => ({
+          message: e.message,
+          platform: e.platform,
+          body: e.body,
+          createdAt: e.createdAt,
+        })),
+        originalGroup: group,
+        originalPublishDate: rootPost.publishDate,
+        exportedAt: new Date().toISOString(),
+      },
+    };
+  }
+
+  async getPostsByGroup(orgId: string, group: string) {
+    const convertToJPEG = false;
+    const loadAll = await this._postRepository.getPostsByGroup(orgId, group);
+    const posts = this.arrangePostsByGroup(loadAll, undefined);
+
+    return {
+      group: posts?.[0]?.group,
+      posts: await Promise.all(
+        (posts || []).map(async (post) => ({
+          ...post,
+          image: await this.updateMedia(
+            post.id,
+            JSON.parse(post.image || '[]'),
+            convertToJPEG
+          ),
+        }))
+      ),
+      integrationPicture: posts[0]?.integration?.picture,
+      integration: posts[0].integrationId,
+      settings: JSON.parse(posts[0].settings || '{}'),
+    };
+  }
+
+  arrangePostsByGroup(all: any, parent?: string): PostWithConditionals[] {
+    const findAll = all
+      .filter((p: any) =>
+        !parent ? !p.parentPostId : p.parentPostId === parent
+      )
+      .map(({ integration, ...all }: any) => ({
+        ...all,
+        ...(!parent ? { integration } : {}),
+      }));
+
+    return [
+      ...findAll,
+      ...(findAll.length
+        ? findAll.flatMap((p: any) => this.arrangePostsByGroup(all, p.id))
+        : []),
+    ];
+  }
+
+  async getPost(orgId: string, id: string, convertToJPEG = false) {
+    const posts = await this.getPostsRecursively(id, true, orgId, true);
+    const list = {
+      group: posts?.[0]?.group,
+      posts: await Promise.all(
+        (posts || []).map(async (post) => ({
+          ...post,
+          image: await this.updateMedia(
+            post.id,
+            JSON.parse(post.image || '[]'),
+            convertToJPEG
+          ),
+        }))
+      ),
+      integrationPicture: posts[0]?.integration?.picture,
+      integration: posts[0].integrationId,
+      settings: JSON.parse(posts[0].settings || '{}'),
+    };
+
+    return list;
+  }
+
+  async getOldPosts(orgId: string, date: string) {
+    return this._postRepository.getOldPosts(orgId, date);
+  }
+
+  public async updateTags(orgId: string, post: Post[]): Promise<Post[]> {
+    const plainText = JSON.stringify(post);
+    const extract = Array.from(
+      plainText.match(/\(post:[a-zA-Z0-9-_]+\)/g) || []
+    );
+    if (!extract.length) {
+      return post;
+    }
+
+    const ids = (extract || []).map((e) =>
+      e.replace('(post:', '').replace(')', '')
+    );
+    const urls = await this._postRepository.getPostUrls(orgId, ids);
+    const newPlainText = ids.reduce((acc, value) => {
+      const findUrl = urls?.find?.((u) => u.id === value)?.releaseURL || '';
+      return acc.replace(
+        new RegExp(`\\(post:${value}\\)`, 'g'),
+        findUrl.split(',')[0]
+      );
+    }, plainText);
+
+    return this.updateTags(orgId, JSON.parse(newPlainText) as Post[]);
+  }
+
+  public async checkInternalPlug(
+    integration: Integration,
+    orgId: string,
+    id: string,
+    settings: any
+  ) {
+    const plugs = Object.entries(settings).filter(([key]) => {
+      return key.indexOf('plug-') > -1;
+    });
+
+    if (plugs.length === 0) {
+      return [];
+    }
+
+    const parsePlugs = plugs.reduce((all, [key, value]) => {
+      const [_, name, identifier] = key.split('--');
+      all[name] = all[name] || { name };
+      all[name][identifier] = value;
+      return all;
+    }, {} as any);
+
+    const list: {
+      name: string;
+      integrations: { id: string }[];
+      delay: string;
+      active: boolean;
+    }[] = Object.values(parsePlugs);
+
+    return (list || []).flatMap((trigger) => {
+      return (trigger?.integrations || []).flatMap((int) => ({
+        type: 'internal-plug',
+        post: id,
+        originalIntegration: integration.id,
+        integration: int.id,
+        plugName: trigger.name,
+        orgId: orgId,
+        delay: +trigger.delay,
+        information: trigger,
+      }));
+    });
+  }
+
+  public async checkPlugs(
+    orgId: string,
+    providerName: string,
+    integrationId: string
+  ) {
+    const loadAllPlugs = this._integrationManager.getAllPlugs();
+    const getPlugs = await this._integrationService.getPlugs(
+      orgId,
+      integrationId
+    );
+
+    const currentPlug = loadAllPlugs.find((p) => p.identifier === providerName);
+
+    return getPlugs
+      .filter((plug) => {
+        return currentPlug?.plugs?.some(
+          (p: any) => p.methodName === plug.plugFunction
+        );
+      })
+      .map((plug) => {
+        const runPlug = currentPlug?.plugs?.find(
+          (p: any) => p.methodName === plug.plugFunction
+        )!;
+        return {
+          type: 'global',
+          plugId: plug.id,
+          delay: runPlug.runEveryMilliseconds,
+          totalRuns: runPlug.totalRuns,
+        };
+      });
+  }
+
+  async deletePost(orgId: string, group: string) {
+    const post = await this._postRepository.deletePost(orgId, group);
+
+    if (post?.id) {
+      try {
+        const workflows = this._temporalService.client
+          .getRawClient()
+          ?.workflow.list({
+            query: `postId="${post.id}" AND ExecutionStatus="Running"`,
+          });
+
+        for await (const executionInfo of workflows) {
+          try {
+            const workflow =
+              await this._temporalService.client.getWorkflowHandle(
+                executionInfo.workflowId
+              );
+            if (
+              workflow &&
+              (await workflow.describe()).status.name !== 'TERMINATED'
+            ) {
+              await workflow.terminate();
+            }
+          } catch (err) {}
+        }
+      } catch (err) {}
+    }
+
+    return { error: true };
+  }
+
+  async countPostsFromDay(orgId: string, date: Date) {
+    return this._postRepository.countPostsFromDay(orgId, date);
+  }
+
+  getPostByForWebhookId(id: string) {
+    return this._postRepository.getPostByForWebhookId(id);
+  }
+
+  async startWorkflow(
+    taskQueue: string,
+    postId: string,
+    orgId: string,
+    state: State
+  ) {
+    try {
+      const workflows = this._temporalService.client
+        .getRawClient()
+        ?.workflow.list({
+          query: `postId="${postId}" AND ExecutionStatus="Running"`,
+        });
+
+      for await (const executionInfo of workflows) {
+        try {
+          const workflow = await this._temporalService.client.getWorkflowHandle(
+            executionInfo.workflowId
+          );
+          if (
+            workflow &&
+            (await workflow.describe()).status.name !== 'TERMINATED'
+          ) {
+            await workflow.terminate();
+          }
+        } catch (err) {}
+      }
+    } catch (err) {}
+
+    if (state === 'DRAFT') {
+      return;
+    }
+
+    try {
+      await this._temporalService.client
+        .getRawClient()
+        ?.workflow.start('postWorkflowV105', {
+          workflowId: `post_${postId}`,
+          taskQueue: 'main',
+          workflowIdConflictPolicy: 'TERMINATE_EXISTING',
+          args: [
+            {
+              taskQueue: taskQueue,
+              postId: postId,
+              organizationId: orgId,
+            },
+          ],
+          typedSearchAttributes: new TypedSearchAttributes([
+            {
+              key: postIdSearchParam,
+              value: postId,
+            },
+            {
+              key: organizationId,
+              value: orgId,
+            },
+          ]),
+        });
+    } catch (err) {}
+  }
+
+  /**
+   * Server-side validation that used to live on the client (`checkValidity` +
+   * the manage modal loop). Runs the provider's settings DTO validation, the
+   * provider `checkValidity` (media rules) and the empty-content / too-long
+   * character checks. Returns one result per post so the frontend can show the
+   * same toasts it did before — and so `/posts` can refuse to create invalid
+   * posts.
+   */
+  async validatePosts(
+    orgId: string,
+    posts: Array<{
+      integration: { id: string };
+      value: Array<{
+        content?: string;
+        image?: Array<{ path: string; thumbnail?: string }>;
+      }>;
+      settings?: any;
+    }>
+  ) {
+    return Promise.all(
+      (posts || []).map(async (post) => {
+        const integration = await this._integrationService.getIntegrationById(
+          orgId,
+          post?.integration?.id
+        );
+
+        if (!integration) {
+          throw new BadRequestException(
+            `Integration with id ${post?.integration?.id} not found`
+          );
+        }
+
+        const provider = this._integrationManager.getSocialIntegration(
+          integration.providerIdentifier
+        );
+
+        let additionalSettings: any[] = [];
+        try {
+          additionalSettings = JSON.parse(
+            integration.additionalSettings || '[]'
+          );
+        } catch {
+          additionalSettings = [];
+        }
+
+        const settings = post.settings || {};
+        const media = (post.value || []).map((p) => p.image || []);
+
+        // Settings DTO validation — mirrors the client `form.trigger()`.
+        let valid = true;
+        let settingsError = '';
+        if (provider?.dto) {
+          const instance = plainToInstance(provider.dto, settings, {
+            enableImplicitConversion: false,
+          });
+          const validationErrors = await validate(instance as object, {
+            skipMissingProperties: false,
+          });
+          settingsError = this.firstValidationError(validationErrors);
+          valid = validationErrors.length === 0;
+        }
+
+        // Provider-specific media validation (the old client `checkValidity`).
+        let errors: string | true = true;
+        try {
+          errors = await provider.checkValidity(
+            media,
+            settings,
+            additionalSettings
+          );
+        } catch (err: any) {
+          errors = err?.message || 'Invalid media';
+        }
+
+        const maximumCharacters = provider.maxLength(additionalSettings);
+        const isX = integration.providerIdentifier === 'x';
+
+        const emptyContent = (post.value || []).some((a) => {
+          const strip = stripHtmlValidation('normal', a.content || '', true);
+          const length = isX ? weightedLength(strip) : strip.length;
+          return length === 0 && (a.image || []).length === 0;
+        });
+
+        const tooLong = (post.value || []).some((a) => {
+          const strip = stripHtmlValidation('normal', a.content || '', true);
+          const weighted = isX ? weightedLength(strip) : strip.length;
+          const totalCharacters =
+            weighted > strip.length ? weighted : strip.length;
+          return totalCharacters > (maximumCharacters || 1000000);
+        });
+
+        return {
+          id: integration.id,
+          identifier: integration.providerIdentifier,
+          name: integration.name,
+          valid,
+          settingsError,
+          errors,
+          emptyContent,
+          tooLong,
+          maximumCharacters,
+        };
+      })
+    );
+  }
+
+  /** Returns the first class-validator message (incl. nested children), or ''. */
+  private firstValidationError(errors: any[]): string {
+    for (const e of errors || []) {
+      if (e?.constraints) {
+        return Object.values(e.constraints as Record<string, string>)[0] || '';
+      }
+      const child = e?.children?.length
+        ? this.firstValidationError(e.children)
+        : '';
+      if (child) {
+        return child;
+      }
+    }
+    return '';
+  }
+
+  async createPost(
+    orgId: string,
+    body: CreatePostDto,
+    creationMethod: CreationMethod
+  ): Promise<any[]> {
+    const postList = [];
+    for (const post of body.posts) {
+      const provider = this._integrationManager.getSocialIntegration(
+        (post.settings as any)?.__type
+      );
+      const removeLinks = !!provider?.stripLinks?.();
+
+      const messages = (post.value || []).map((p) => p.content);
+      // No point shortlinking links on platforms that strip them out anyway
+      const updateContent =
+        !body.shortLink || removeLinks
+          ? messages
+          : await this._shortLinkService.convertTextToShortLinks(
+              orgId,
+              messages
+            );
+
+      post.value = (post.value || []).map((p, i) => ({
+        ...p,
+        content: removeLinks ? stripLinks(updateContent[i]) : updateContent[i],
+      }));
+
+      const { posts } = await this._postRepository.createOrUpdatePost(
+        body.type,
+        orgId,
+        body.type === 'now' ? dayjs().format('YYYY-MM-DDTHH:mm:00') : body.date,
+        post,
+        body.tags,
+        creationMethod,
+        body.inter
+      );
+
+      if (!posts?.length) {
+        return [] as any[];
+      }
+
+      if (body.type !== 'update') {
+        this.startWorkflow(
+          post.settings.__type.split('-')[0].toLowerCase(),
+          posts[0].id,
+          orgId,
+          posts[0].state
+        ).catch((err) => {});
+      }
+
+      Sentry.metrics.count('post_created', 1);
+      postList.push({
+        postId: posts[0].id,
+        integration: post.integration.id,
+      });
+    }
+
+    return postList;
+  }
+
+  async separatePosts(content: string, len: number) {
+    return this._openaiService.separatePosts(content, len);
+  }
+
+  async changeState(id: string, state: State, err?: any, body?: any) {
+    return this._postRepository.changeState(id, state, err, body);
+  }
+
+  async changePostStatus(
+    orgId: string,
+    id: string,
+    status: 'draft' | 'schedule'
+  ) {
+    const getPostById = await this._postRepository.getPostById(id, orgId);
+    if (!getPostById) {
+      throw new BadRequestException('Post not found');
+    }
+
+    const state: State = status === 'draft' ? 'DRAFT' : 'QUEUE';
+    await this._postRepository.changeState(id, state);
+
+    try {
+      await this.startWorkflow(
+        getPostById.integration.providerIdentifier.split('-')[0].toLowerCase(),
+        getPostById.id,
+        orgId,
+        state
+      );
+    } catch (err) {}
+
+    return { id, state };
+  }
+
+  async changeDate(
+    orgId: string,
+    id: string,
+    date: string,
+    action: 'schedule' | 'update' = 'schedule'
+  ) {
+    const getPostById = await this._postRepository.getPostById(id, orgId);
+
+    // schedule: Set status to QUEUE and change date (reschedule the post)
+    // update: Just change the date without changing the status
+    const newDate = await this._postRepository.changeDate(
+      orgId,
+      id,
+      date,
+      getPostById.state === 'DRAFT',
+      action
+    );
+
+    if (action === 'schedule') {
+      try {
+        await this.startWorkflow(
+          getPostById.integration.providerIdentifier
+            .split('-')[0]
+            .toLowerCase(),
+          getPostById.id,
+          orgId,
+          getPostById.state === 'DRAFT' ? 'DRAFT' : 'QUEUE'
+        );
+      } catch (err) {}
+    }
+
+    return newDate;
+  }
+
+  async generatePostsDraft(orgId: string, body: CreateGeneratedPostsDto) {
+    const getAllIntegrations = (
+      await this._integrationService.getIntegrationsList(orgId)
+    ).filter((f) => !f.disabled && f.providerIdentifier !== 'reddit');
+
+    // const posts = chunk(body.posts, getAllIntegrations.length);
+    const allDates = dayjs()
+      .isoWeek(body.week)
+      .year(body.year)
+      .startOf('isoWeek');
+
+    const dates = [...new Array(7)].map((_, i) => {
+      return allDates.add(i, 'day').format('YYYY-MM-DD');
+    });
+
+    const findTime = (): string => {
+      const totalMinutes = Math.floor(Math.random() * 144) * 10;
+
+      // Convert total minutes to hours and minutes
+      const hours = Math.floor(totalMinutes / 60);
+      const minutes = totalMinutes % 60;
+
+      // Format hours and minutes to always be two digits
+      const formattedHours = hours.toString().padStart(2, '0');
+      const formattedMinutes = minutes.toString().padStart(2, '0');
+      const randomDate =
+        shuffle(dates)[0] + 'T' + `${formattedHours}:${formattedMinutes}:00`;
+
+      if (dayjs(randomDate).isBefore(dayjs())) {
+        return findTime();
+      }
+
+      return randomDate;
+    };
+
+    for (const integration of getAllIntegrations) {
+      for (const toPost of body.posts) {
+        const group = makeId(10);
+        const randomDate = findTime();
+
+        await this.createPost(
+          orgId,
+          {
+            type: 'draft',
+            date: randomDate,
+            order: '',
+            shortLink: false,
+            tags: [],
+            posts: [
+              {
+                group,
+                integration: {
+                  id: integration.id,
+                },
+                settings: {
+                  __type: integration.providerIdentifier as any,
+                  title: '',
+                  tags: [],
+                  subreddit: [],
+                },
+                value: [
+                  ...toPost.list.map((l) => ({
+                    id: '',
+                    content: l.post,
+                    delay: 0,
+                    image: [],
+                  })),
+                  {
+                    id: '',
+                    delay: 0,
+                    content: `Check out the full story here:\n${
+                      body.postId || body.url
+                    }`,
+                    image: [],
+                  },
+                ],
+              },
+            ],
+          },
+          'WEB'
+        );
+      }
+    }
+  }
+
+  findAllExistingCategories() {
+    return this._postRepository.findAllExistingCategories();
+  }
+
+  findAllExistingTopicsOfCategory(category: string) {
+    return this._postRepository.findAllExistingTopicsOfCategory(category);
+  }
+
+  findPopularPosts(category: string, topic?: string) {
+    return this._postRepository.findPopularPosts(category, topic);
+  }
+
+  async findFreeDateTime(orgId: string, integrationId?: string) {
+    const findTimes = await this._integrationService.findFreeDateTime(
+      orgId,
+      integrationId
+    );
+    return this.findFreeDateTimeRecursive(
+      orgId,
+      findTimes,
+      dayjs.utc().startOf('day')
+    );
+  }
+
+  async createPopularPosts(post: {
+    category: string;
+    topic: string;
+    content: string;
+    hook: string;
+  }) {
+    return this._postRepository.createPopularPosts(post);
+  }
+
+  private async findFreeDateTimeRecursive(
+    orgId: string,
+    times: number[],
+    date: dayjs.Dayjs
+  ): Promise<string> {
+    const list = await this._postRepository.getPostsCountsByDates(
+      orgId,
+      times,
+      date
+    );
+
+    if (!list.length) {
+      return this.findFreeDateTimeRecursive(orgId, times, date.add(1, 'day'));
+    }
+
+    const num = list.reduce<null | number>((prev, curr) => {
+      if (prev === null || prev > curr) {
+        return curr;
+      }
+      return prev;
+    }, null) as number;
+
+    return date.clone().add(num, 'minutes').format('YYYY-MM-DDTHH:mm:00');
+  }
+
+  getComments(postId: string) {
+    return this._postRepository.getComments(postId);
+  }
+
+  getTags(orgId: string) {
+    return this._postRepository.getTags(orgId);
+  }
+
+  createTag(orgId: string, body: CreateTagDto) {
+    return this._postRepository.createTag(orgId, body);
+  }
+
+  editTag(id: string, orgId: string, body: CreateTagDto) {
+    return this._postRepository.editTag(id, orgId, body);
+  }
+
+  deleteTag(id: string, orgId: string) {
+    return this._postRepository.deleteTag(id, orgId);
+  }
+
+  createComment(
+    orgId: string,
+    userId: string,
+    postId: string,
+    comment: string
+  ) {
+    return this._postRepository.createComment(orgId, userId, postId, comment);
+  }
+}

libraries/nestjs-libraries/src/database/prisma/prisma.service.ts

@@ -0,0 +1,39 @@
+import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  constructor() {
+    super({
+      log: [
+        {
+          emit: 'event',
+          level: 'query',
+        },
+      ],
+    });
+  }
+  async onModuleInit() {
+    await this.$connect();
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+  }
+}
+
+@Injectable()
+export class PrismaRepository<T extends keyof PrismaService> {
+  public model: Pick<PrismaService, T>;
+  constructor(private _prismaService: PrismaService) {
+    this.model = this._prismaService;
+  }
+}
+
+@Injectable()
+export class PrismaTransaction {
+  public model: Pick<PrismaService, '$transaction'>;
+  constructor(private _prismaService: PrismaService) {
+    this.model = this._prismaService;
+  }
+}

libraries/nestjs-libraries/src/database/prisma/schema.prisma

@@ -0,0 +1,970 @@
+generator client {
+  provider = "prisma-client-js"
+  runtime  = "nodejs"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model Organization {
+  id                  String               @id @default(uuid())
+  name                String
+  description         String?
+  apiKey              String?
+  paymentId           String?
+  streakSince         DateTime?
+  createdAt           DateTime             @default(now())
+  updatedAt           DateTime             @updatedAt
+  allowTrial          Boolean              @default(false)
+  isTrailing          Boolean              @default(false)
+  shortlink           ShortLinkPreference  @default(ASK)
+  autoPost            AutoPost[]
+  Comments            Comments[]
+  credits             Credits[]
+  customers           Customer[]
+  errors              Errors[]
+  github              GitHub[]
+  Integration         Integration[]
+  media               Media[]
+  buyerOrganization   MessagesGroup[]
+  notifications       Notifications[]
+  plugs               Plugs[]
+  post                Post[]               @relation("organization")
+  submittedPost       Post[]               @relation("submittedForOrg")
+  sets                Sets[]
+  signatures          Signatures[]
+  subscription        Subscription?
+  tags                Tags[]
+  thirdParty          ThirdParty[]
+  usedCodes           UsedCodes[]
+  users               UserOrganization[]
+  webhooks            Webhooks[]
+  oauthApp            OAuthApp[]
+  oauthAuthorizations OAuthAuthorization[]
+
+  @@index([apiKey])
+  @@index([streakSince])
+  @@index([paymentId])
+}
+
+model Tags {
+  id           String       @id @default(uuid())
+  name         String
+  color        String
+  orgId        String
+  deletedAt    DateTime?
+  createdAt    DateTime     @default(now())
+  updatedAt    DateTime     @updatedAt
+  organization Organization @relation(fields: [orgId], references: [id])
+  posts        TagsPosts[]
+
+  @@index([orgId])
+  @@index([deletedAt])
+}
+
+model TagsPosts {
+  postId    String
+  tagId     String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  post      Post     @relation(fields: [postId], references: [id])
+  tag       Tags     @relation(fields: [tagId], references: [id])
+
+  @@id([postId, tagId])
+  @@unique([postId, tagId])
+}
+
+model User {
+  id                    String               @id @default(uuid())
+  email                 String
+  password              String?
+  providerName          Provider
+  name                  String?
+  lastName              String?
+  isSuperAdmin          Boolean              @default(false)
+  bio                   String?
+  audience              Int                  @default(0)
+  pictureId             String?
+  providerId            String?
+  timezone              Int
+  createdAt             DateTime             @default(now())
+  updatedAt             DateTime             @updatedAt
+  lastReadNotifications DateTime             @default(now())
+  inviteId              String?
+  activated             Boolean              @default(true)
+  account               String?
+  connectedAccount      Boolean              @default(false)
+  lastOnline            DateTime             @default(now())
+  ip                    String?
+  agent                 String?
+  comments              Comments[]
+  items                 ItemUser[]
+  groupBuyer            MessagesGroup[]      @relation("groupBuyer")
+  groupSeller           MessagesGroup[]      @relation("groupSeller")
+  orderBuyer            Orders[]             @relation("orderBuyer")
+  orderSeller           Orders[]             @relation("orderSeller")
+  payoutProblems        PayoutProblems[]
+  agencies              SocialMediaAgency?
+  picture               Media?               @relation(fields: [pictureId], references: [id])
+  organizations         UserOrganization[]
+  sendSuccessEmails     Boolean              @default(true)
+  sendFailureEmails     Boolean              @default(true)
+  sendStreakEmails      Boolean              @default(true)
+  oauthAuthorizations   OAuthAuthorization[]
+
+  @@unique([email, providerName])
+  @@index([lastReadNotifications])
+  @@index([inviteId])
+  @@index([account])
+  @@index([lastOnline])
+  @@index([pictureId])
+}
+
+model UsedCodes {
+  id           String       @id @default(uuid())
+  code         String
+  orgId        String
+  createdAt    DateTime     @default(now())
+  updatedAt    DateTime     @updatedAt
+  organization Organization @relation(fields: [orgId], references: [id])
+
+  @@index([code])
+}
+
+model UserOrganization {
+  id             String       @id @default(uuid())
+  userId         String
+  organizationId String
+  disabled       Boolean      @default(false)
+  role           Role         @default(USER)
+  createdAt      DateTime     @default(now())
+  updatedAt      DateTime     @updatedAt
+  organization   Organization @relation(fields: [organizationId], references: [id])
+  user           User         @relation(fields: [userId], references: [id])
+
+  @@unique([userId, organizationId])
+  @@index([disabled])
+}
+
+model GitHub {
+  id             String       @id @default(uuid())
+  login          String?
+  name           String?
+  token          String
+  jobId          String?
+  organizationId String
+  createdAt      DateTime     @default(now())
+  updatedAt      DateTime     @updatedAt
+  organization   Organization @relation(fields: [organizationId], references: [id])
+
+  @@index([login])
+  @@index([organizationId])
+}
+
+model Trending {
+  id           String   @id @default(uuid())
+  trendingList String
+  language     String?  @unique
+  hash         String
+  date         DateTime
+  createdAt    DateTime @default(now())
+  updatedAt    DateTime @updatedAt
+
+  @@index([hash])
+}
+
+model TrendingLog {
+  id       String   @id @default(uuid())
+  language String?
+  date     DateTime
+}
+
+model ItemUser {
+  id     String @id @default(uuid())
+  userId String
+  key    String
+  user   User   @relation(fields: [userId], references: [id])
+
+  @@unique([userId, key])
+  @@index([userId])
+  @@index([key])
+}
+
+model Star {
+  id         String   @id @default(uuid())
+  stars      Int
+  totalStars Int
+  forks      Int
+  totalForks Int
+  login      String
+  date       DateTime @default(now()) @db.Date
+  createdAt  DateTime @default(now())
+  updatedAt  DateTime @updatedAt
+
+  @@unique([login, date])
+}
+
+model Media {
+  id                 String              @id @default(uuid())
+  name               String
+  originalName       String?
+  path               String
+  organizationId     String
+  createdAt          DateTime            @default(now())
+  updatedAt          DateTime            @updatedAt
+  deletedAt          DateTime?
+  fileSize           Int                 @default(0)
+  type               String              @default("image")
+  thumbnail          String?
+  alt                String?
+  thumbnailTimestamp Int?
+  organization       Organization        @relation(fields: [organizationId], references: [id])
+  agencies           SocialMediaAgency[]
+  userPicture        User[]
+  oauthApps          OAuthApp[]
+
+  @@index([name])
+  @@index([organizationId])
+  @@index([type])
+}
+
+model SocialMediaAgency {
+  id               String                   @id @default(uuid())
+  userId           String                   @unique
+  name             String
+  logoId           String?
+  website          String?
+  slug             String?
+  facebook         String?
+  instagram        String?
+  twitter          String?
+  linkedIn         String?
+  youtube          String?
+  tiktok           String?
+  otherSocialMedia String?
+  shortDescription String
+  description      String
+  approved         Boolean                  @default(false)
+  createdAt        DateTime                 @default(now())
+  updatedAt        DateTime                 @updatedAt
+  deletedAt        DateTime?
+  logo             Media?                   @relation(fields: [logoId], references: [id])
+  user             User                     @relation(fields: [userId], references: [id])
+  niches           SocialMediaAgencyNiche[]
+
+  @@index([userId])
+  @@index([deletedAt])
+  @@index([id])
+}
+
+model SocialMediaAgencyNiche {
+  agencyId String
+  niche    String
+  agency   SocialMediaAgency @relation(fields: [agencyId], references: [id])
+
+  @@id([agencyId, niche])
+}
+
+model Credits {
+  id             String       @id @default(uuid())
+  organizationId String
+  credits        Int
+  createdAt      DateTime     @default(now())
+  updatedAt      DateTime     @updatedAt
+  type           String       @default("ai_images")
+  organization   Organization @relation(fields: [organizationId], references: [id])
+
+  @@index([organizationId])
+  @@index([createdAt])
+}
+
+model Subscription {
+  id               String           @id @default(cuid())
+  organizationId   String           @unique
+  subscriptionTier SubscriptionTier
+  identifier       String?
+  cancelAt         DateTime?
+  period           Period
+  totalChannels    Int
+  isLifetime       Boolean          @default(false)
+  createdAt        DateTime         @default(now())
+  updatedAt        DateTime         @updatedAt
+  deletedAt        DateTime?
+  organization     Organization     @relation(fields: [organizationId], references: [id])
+
+  @@index([organizationId])
+  @@index([deletedAt])
+}
+
+model Customer {
+  id           String        @id @default(uuid())
+  name         String
+  orgId        String
+  createdAt    DateTime      @default(now())
+  updatedAt    DateTime      @updatedAt
+  deletedAt    DateTime?
+  organization Organization  @relation(fields: [orgId], references: [id])
+  integrations Integration[]
+
+  @@unique([orgId, name, deletedAt])
+}
+
+model Integration {
+  id                    String                 @id @default(cuid())
+  internalId            String
+  organizationId        String
+  name                  String
+  picture               String?
+  providerIdentifier    String
+  type                  String
+  token                 String
+  disabled              Boolean                @default(false)
+  tokenExpiration       DateTime?
+  refreshToken          String?
+  profile               String?
+  deletedAt             DateTime?
+  createdAt             DateTime               @default(now())
+  updatedAt             DateTime?              @updatedAt
+  inBetweenSteps        Boolean                @default(false)
+  refreshNeeded         Boolean                @default(false)
+  postingTimes          String                 @default("[{\"time\":120}, {\"time\":400}, {\"time\":700}]")
+  customInstanceDetails String?
+  customerId            String?
+  rootInternalId        String?
+  additionalSettings    String?                @default("[]")
+  exisingPlugData       ExisingPlugData[]
+  customer              Customer?              @relation(fields: [customerId], references: [id])
+  organization          Organization           @relation(fields: [organizationId], references: [id])
+  webhooks              IntegrationsWebhooks[]
+  orderItems            OrderItems[]
+  plugs                 Plugs[]
+  posts                 Post[]
+
+  @@unique([organizationId, internalId])
+  @@index([rootInternalId])
+  @@index([organizationId])
+  @@index([providerIdentifier])
+  @@index([updatedAt])
+  @@index([createdAt])
+  @@index([deletedAt])
+  @@index([customerId])
+  @@index([inBetweenSteps])
+  @@index([refreshNeeded])
+  @@index([disabled])
+}
+
+model Signatures {
+  id             String       @id @default(uuid())
+  organizationId String
+  content        String
+  autoAdd        Boolean
+  createdAt      DateTime     @default(now())
+  updatedAt      DateTime     @updatedAt
+  deletedAt      DateTime?
+  organization   Organization @relation(fields: [organizationId], references: [id])
+
+  @@index([createdAt])
+  @@index([organizationId])
+  @@index([deletedAt])
+}
+
+model Comments {
+  id             String       @id @default(uuid())
+  content        String
+  organizationId String
+  postId         String
+  userId         String
+  createdAt      DateTime     @default(now())
+  updatedAt      DateTime     @updatedAt
+  deletedAt      DateTime?
+  organization   Organization @relation(fields: [organizationId], references: [id])
+  post           Post         @relation(fields: [postId], references: [id])
+  user           User         @relation(fields: [userId], references: [id])
+
+  @@index([createdAt])
+  @@index([organizationId])
+  @@index([userId])
+  @@index([postId])
+  @@index([deletedAt])
+}
+
+model Post {
+  id                         String                    @id @default(cuid())
+  state                      State                     @default(QUEUE)
+  publishDate                DateTime
+  organizationId             String
+  integrationId              String
+  content                    String
+  delay                      Int                       @default(0)
+  group                      String
+  title                      String?
+  description                String?
+  parentPostId               String?
+  releaseId                  String?
+  releaseURL                 String?
+  settings                   String?
+  image                      String?
+  submittedForOrderId        String?
+  submittedForOrganizationId String?
+  approvedSubmitForOrder     APPROVED_SUBMIT_FOR_ORDER @default(NO)
+  creationMethod             CreationMethod            @default(UNKNOWN)
+  lastMessageId              String?
+  intervalInDays             Int?
+  error                      String?
+  createdAt                  DateTime                  @default(now())
+  updatedAt                  DateTime                  @updatedAt
+  deletedAt                  DateTime?
+  comments                   Comments[]
+  errors                     Errors[]
+  payoutProblems             PayoutProblems[]
+  integration                Integration               @relation(fields: [integrationId], references: [id])
+  lastMessage                Messages?                 @relation(fields: [lastMessageId], references: [id])
+  organization               Organization              @relation("organization", fields: [organizationId], references: [id])
+  parentPost                 Post?                     @relation("parentPostId", fields: [parentPostId], references: [id])
+  childrenPost               Post[]                    @relation("parentPostId")
+  submittedForOrder          Orders?                   @relation(fields: [submittedForOrderId], references: [id])
+  submittedForOrganization   Organization?             @relation("submittedForOrg", fields: [submittedForOrganizationId], references: [id])
+  tags                       TagsPosts[]
+
+  @@index([group])
+  @@index([deletedAt])
+  @@index([publishDate])
+  @@index([state])
+  @@index([organizationId])
+  @@index([parentPostId])
+  @@index([submittedForOrderId])
+  @@index([intervalInDays])
+  @@index([approvedSubmitForOrder])
+  @@index([creationMethod])
+  @@index([lastMessageId])
+  @@index([createdAt])
+  @@index([updatedAt])
+  @@index([releaseURL])
+  @@index([integrationId])
+}
+
+model Notifications {
+  id             String       @id @default(uuid())
+  organizationId String
+  content        String
+  link           String?
+  createdAt      DateTime     @default(now())
+  updatedAt      DateTime     @updatedAt
+  deletedAt      DateTime?
+  organization   Organization @relation(fields: [organizationId], references: [id])
+
+  @@index([createdAt])
+  @@index([organizationId])
+  @@index([deletedAt])
+}
+
+model MessagesGroup {
+  id                  String       @id @default(uuid())
+  buyerOrganizationId String
+  buyerId             String
+  sellerId            String
+  createdAt           DateTime     @default(now())
+  updatedAt           DateTime     @updatedAt
+  messages            Messages[]
+  buyer               User         @relation("groupBuyer", fields: [buyerId], references: [id])
+  buyerOrganization   Organization @relation(fields: [buyerOrganizationId], references: [id])
+  seller              User         @relation("groupSeller", fields: [sellerId], references: [id])
+  orders              Orders[]
+
+  @@unique([buyerId, sellerId])
+  @@index([createdAt])
+  @@index([updatedAt])
+  @@index([buyerOrganizationId])
+}
+
+model PayoutProblems {
+  id        String   @id @default(uuid())
+  status    String
+  orderId   String
+  userId    String
+  postId    String?
+  amount    Int
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  order     Orders   @relation(fields: [orderId], references: [id])
+  post      Post?    @relation(fields: [postId], references: [id])
+  user      User     @relation(fields: [userId], references: [id])
+}
+
+model Orders {
+  id             String           @id @default(uuid())
+  buyerId        String
+  sellerId       String
+  status         OrderStatus
+  messageGroupId String
+  captureId      String?
+  createdAt      DateTime         @default(now())
+  updatedAt      DateTime         @updatedAt
+  ordersItems    OrderItems[]
+  buyer          User             @relation("orderBuyer", fields: [buyerId], references: [id])
+  messageGroup   MessagesGroup    @relation(fields: [messageGroupId], references: [id])
+  seller         User             @relation("orderSeller", fields: [sellerId], references: [id])
+  payoutProblems PayoutProblems[]
+  posts          Post[]
+
+  @@index([buyerId])
+  @@index([sellerId])
+  @@index([updatedAt])
+  @@index([createdAt])
+  @@index([messageGroupId])
+}
+
+model OrderItems {
+  id            String      @id @default(uuid())
+  orderId       String
+  integrationId String
+  quantity      Int
+  price         Int
+  integration   Integration @relation(fields: [integrationId], references: [id])
+  order         Orders      @relation(fields: [orderId], references: [id])
+
+  @@index([orderId])
+  @@index([integrationId])
+}
+
+model Messages {
+  id        String        @id @default(uuid())
+  from      From
+  content   String?
+  groupId   String
+  special   String?
+  createdAt DateTime      @default(now())
+  updatedAt DateTime      @updatedAt
+  deletedAt DateTime?
+  group     MessagesGroup @relation(fields: [groupId], references: [id])
+  posts     Post[]
+
+  @@index([groupId])
+  @@index([createdAt])
+  @@index([deletedAt])
+}
+
+model Plugs {
+  id             String       @id @default(uuid())
+  organizationId String
+  plugFunction   String
+  data           String
+  integrationId  String
+  activated      Boolean      @default(true)
+  integration    Integration  @relation(fields: [integrationId], references: [id])
+  organization   Organization @relation(fields: [organizationId], references: [id])
+
+  @@unique([plugFunction, integrationId])
+  @@index([organizationId])
+}
+
+model ExisingPlugData {
+  id            String      @id @default(uuid())
+  integrationId String
+  methodName    String
+  value         String
+  integration   Integration @relation(fields: [integrationId], references: [id])
+
+  @@unique([integrationId, methodName, value])
+}
+
+model PopularPosts {
+  id        String   @id @default(uuid())
+  category  String
+  topic     String
+  content   String
+  hook      String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+model IntegrationsWebhooks {
+  integrationId String
+  webhookId     String
+  integration   Integration @relation(fields: [integrationId], references: [id])
+  webhook       Webhooks    @relation(fields: [webhookId], references: [id])
+
+  @@id([integrationId, webhookId])
+  @@unique([integrationId, webhookId])
+  @@index([integrationId])
+  @@index([webhookId])
+}
+
+model Webhooks {
+  id             String                 @id @default(uuid())
+  name           String
+  organizationId String
+  url            String
+  deletedAt      DateTime?
+  createdAt      DateTime               @default(now())
+  updatedAt      DateTime               @updatedAt
+  integrations   IntegrationsWebhooks[]
+  organization   Organization           @relation(fields: [organizationId], references: [id])
+
+  @@index([organizationId])
+  @@index([deletedAt])
+}
+
+model AutoPost {
+  id              String       @id @default(uuid())
+  organizationId  String
+  title           String
+  content         String?
+  onSlot          Boolean
+  syncLast        Boolean
+  url             String
+  lastUrl         String
+  active          Boolean
+  addPicture      Boolean
+  generateContent Boolean
+  integrations    String
+  deletedAt       DateTime?
+  createdAt       DateTime     @default(now())
+  updatedAt       DateTime     @updatedAt
+  organization    Organization @relation(fields: [organizationId], references: [id])
+
+  @@index([deletedAt])
+}
+
+model Sets {
+  id             String       @id @default(uuid())
+  organizationId String
+  name           String
+  content        String
+  createdAt      DateTime     @default(now())
+  updatedAt      DateTime     @updatedAt
+  organization   Organization @relation(fields: [organizationId], references: [id])
+
+  @@index([organizationId])
+}
+
+model ThirdParty {
+  id             String       @id @default(uuid())
+  organizationId String
+  identifier     String
+  name           String
+  internalId     String
+  apiKey         String
+  createdAt      DateTime     @default(now())
+  updatedAt      DateTime     @updatedAt
+  deletedAt      DateTime?
+  organization   Organization @relation(fields: [organizationId], references: [id])
+
+  @@unique([organizationId, internalId])
+  @@index([organizationId])
+  @@index([deletedAt])
+}
+
+model Errors {
+  id             String       @id @default(uuid())
+  message        String
+  platform       String
+  organizationId String
+  createdAt      DateTime     @default(now())
+  updatedAt      DateTime     @updatedAt
+  postId         String
+  body           String       @default("{}")
+  organization   Organization @relation(fields: [organizationId], references: [id])
+  post           Post         @relation(fields: [postId], references: [id])
+
+  @@index([organizationId])
+  @@index([createdAt])
+}
+
+model Mentions {
+  name      String
+  username  String
+  platform  String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  image     String
+
+  @@id([name, username, platform, image])
+  @@index([createdAt])
+}
+
+/// The underlying table does not contain a valid unique identifier and can therefore currently not be handled by Prisma Client.
+model mastra_ai_spans {
+  traceId      String
+  spanId       String
+  parentSpanId String?
+  name         String
+  scope        Json?
+  spanType     String
+  attributes   Json?
+  metadata     Json?
+  links        Json?
+  input        Json?
+  output       Json?
+  error        Json?
+  startedAt    DateTime  @db.Timestamp(6)
+  endedAt      DateTime? @db.Timestamp(6)
+  createdAt    DateTime  @db.Timestamp(6)
+  updatedAt    DateTime? @db.Timestamp(6)
+  isEvent      Boolean
+  startedAtZ   DateTime? @default(now()) @db.Timestamptz(6)
+  endedAtZ     DateTime? @default(now()) @db.Timestamptz(6)
+  createdAtZ   DateTime? @default(now()) @db.Timestamptz(6)
+  updatedAtZ   DateTime? @default(now()) @db.Timestamptz(6)
+
+  @@index([name], map: "public_mastra_ai_spans_name_idx")
+  @@index([parentSpanId, startedAt(sort: Desc)], map: "public_mastra_ai_spans_parentspanid_startedat_idx")
+  @@index([spanType, startedAt(sort: Desc)], map: "public_mastra_ai_spans_spantype_startedat_idx")
+  @@index([traceId, startedAt(sort: Desc)], map: "public_mastra_ai_spans_traceid_startedat_idx")
+  @@ignore
+}
+
+/// The underlying table does not contain a valid unique identifier and can therefore currently not be handled by Prisma Client.
+model mastra_evals {
+  input         String
+  output        String
+  result        Json
+  agent_name    String
+  metric_name   String
+  instructions  String
+  test_info     Json?
+  global_run_id String
+  run_id        String
+  created_at    DateTime  @db.Timestamp(6)
+  createdAt     DateTime? @db.Timestamp(6)
+  created_atZ   DateTime? @default(now()) @db.Timestamptz(6)
+  createdAtZ    DateTime? @default(now()) @db.Timestamptz(6)
+
+  @@index([agent_name, created_at(sort: Desc)], map: "public_mastra_evals_agent_name_created_at_idx")
+  @@ignore
+}
+
+model mastra_messages {
+  id         String    @id
+  thread_id  String
+  content    String
+  role       String
+  type       String
+  createdAt  DateTime  @db.Timestamp(6)
+  resourceId String?
+  createdAtZ DateTime? @default(now()) @db.Timestamptz(6)
+
+  @@index([thread_id, createdAt(sort: Desc)], map: "public_mastra_messages_thread_id_createdat_idx")
+}
+
+model mastra_resources {
+  id            String    @id
+  workingMemory String?
+  metadata      Json?
+  createdAt     DateTime  @db.Timestamp(6)
+  updatedAt     DateTime  @db.Timestamp(6)
+  createdAtZ    DateTime? @default(now()) @db.Timestamptz(6)
+  updatedAtZ    DateTime? @default(now()) @db.Timestamptz(6)
+}
+
+model mastra_scorers {
+  id                   String    @id
+  scorerId             String
+  traceId              String?
+  runId                String
+  scorer               Json
+  preprocessStepResult Json?
+  extractStepResult    Json?
+  analyzeStepResult    Json?
+  score                Float
+  reason               String?
+  metadata             Json?
+  preprocessPrompt     String?
+  extractPrompt        String?
+  generateScorePrompt  String?
+  generateReasonPrompt String?
+  analyzePrompt        String?
+  reasonPrompt         String?
+  input                Json
+  output               Json
+  additionalContext    Json?
+  runtimeContext       Json?
+  entityType           String?
+  entity               Json?
+  entityId             String?
+  source               String
+  resourceId           String?
+  threadId             String?
+  createdAt            DateTime  @db.Timestamp(6)
+  updatedAt            DateTime  @db.Timestamp(6)
+  createdAtZ           DateTime? @default(now()) @db.Timestamptz(6)
+  updatedAtZ           DateTime? @default(now()) @db.Timestamptz(6)
+  spanId               String?
+
+  @@index([traceId, spanId, createdAt(sort: Desc)], map: "public_mastra_scores_trace_id_span_id_created_at_idx")
+}
+
+model mastra_threads {
+  id         String    @id
+  resourceId String
+  title      String
+  metadata   String?
+  createdAt  DateTime  @db.Timestamp(6)
+  updatedAt  DateTime  @db.Timestamp(6)
+  createdAtZ DateTime? @default(now()) @db.Timestamptz(6)
+  updatedAtZ DateTime? @default(now()) @db.Timestamptz(6)
+
+  @@index([resourceId, createdAt(sort: Desc)], map: "public_mastra_threads_resourceid_createdat_idx")
+}
+
+model mastra_traces {
+  id           String    @id
+  parentSpanId String?
+  name         String
+  traceId      String
+  scope        String
+  kind         Int
+  attributes   Json?
+  status       Json?
+  events       Json?
+  links        Json?
+  other        String?
+  startTime    BigInt
+  endTime      BigInt
+  createdAt    DateTime  @db.Timestamp(6)
+  createdAtZ   DateTime? @default(now()) @db.Timestamptz(6)
+
+  @@index([name, startTime(sort: Desc)], map: "public_mastra_traces_name_starttime_idx")
+}
+
+model mastra_workflow_snapshot {
+  workflow_name String
+  run_id        String
+  resourceId    String?
+  snapshot      String
+  createdAt     DateTime  @db.Timestamp(6)
+  updatedAt     DateTime  @db.Timestamp(6)
+  createdAtZ    DateTime? @default(now()) @db.Timestamptz(6)
+  updatedAtZ    DateTime? @default(now()) @db.Timestamptz(6)
+
+  @@unique([workflow_name, run_id], map: "public_mastra_workflow_snapshot_workflow_name_run_id_key")
+}
+
+model OAuthApp {
+  id             String               @id @default(uuid())
+  organizationId String
+  name           String
+  description    String?
+  pictureId      String?
+  redirectUrl    String
+  clientId       String               @unique
+  clientSecret   String
+  createdAt      DateTime             @default(now())
+  updatedAt      DateTime             @updatedAt
+  deletedAt      DateTime?
+  organization   Organization         @relation(fields: [organizationId], references: [id])
+  picture        Media?               @relation(fields: [pictureId], references: [id])
+  authorizations OAuthAuthorization[]
+
+  @@unique([organizationId, deletedAt])
+  @@index([clientId])
+  @@index([organizationId])
+  @@index([deletedAt])
+}
+
+model OAuthAuthorization {
+  id                String       @id @default(uuid())
+  oauthAppId        String
+  userId            String
+  organizationId    String
+  accessToken       String?
+  authorizationCode String?
+  codeExpiresAt     DateTime?
+  revokedAt         DateTime?
+  createdAt         DateTime     @default(now())
+  updatedAt         DateTime     @updatedAt
+  oauthApp          OAuthApp     @relation(fields: [oauthAppId], references: [id])
+  user              User         @relation(fields: [userId], references: [id])
+  organization      Organization @relation(fields: [organizationId], references: [id])
+
+  @@unique([oauthAppId, userId, organizationId])
+  @@index([accessToken])
+  @@index([authorizationCode])
+  @@index([oauthAppId])
+  @@index([userId])
+  @@index([organizationId])
+  @@index([revokedAt])
+}
+
+enum OrderStatus {
+  PENDING
+  ACCEPTED
+  CANCELED
+  COMPLETED
+}
+
+enum From {
+  BUYER
+  SELLER
+}
+
+enum State {
+  QUEUE
+  PUBLISHED
+  ERROR
+  DRAFT
+}
+
+enum SubscriptionTier {
+  STANDARD
+  PRO
+  TEAM
+  ULTIMATE
+}
+
+enum Period {
+  MONTHLY
+  YEARLY
+}
+
+enum Provider {
+  LOCAL
+  GITHUB
+  GOOGLE
+  FARCASTER
+  WALLET
+  GENERIC
+}
+
+enum Role {
+  SUPERADMIN
+  ADMIN
+  USER
+}
+
+enum APPROVED_SUBMIT_FOR_ORDER {
+  NO
+  WAITING_CONFIRMATION
+  YES
+}
+
+enum CreationMethod {
+  UNKNOWN
+  WEB
+  MCP
+  API
+  AUTOPOST
+  CLI
+}
+
+enum ShortLinkPreference {
+  ASK
+  YES
+  NO
+}
+
+enum AnnouncementColor {
+  INFO
+  WARNING
+  ERROR
+}
+
+model Announcement {
+  id          String            @id @default(uuid())
+  title       String
+  description String
+  color       AnnouncementColor @default(INFO)
+  createdAt   DateTime          @default(now())
+}

libraries/nestjs-libraries/src/database/prisma/sets/sets.repository.ts

@@ -0,0 +1,58 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { SetsDto } from '@gitroom/nestjs-libraries/dtos/sets/sets.dto';
+import { v4 as uuidv4 } from 'uuid';
+
+@Injectable()
+export class SetsRepository {
+  constructor(private _sets: PrismaRepository<'sets'>) {}
+
+  getTotal(orgId: string) {
+    return this._sets.model.sets.count({
+      where: {
+        organizationId: orgId,
+      },
+    });
+  }
+
+  getSets(orgId: string) {
+    return this._sets.model.sets.findMany({
+      where: {
+        organizationId: orgId,
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    });
+  }
+
+  deleteSet(orgId: string, id: string) {
+    return this._sets.model.sets.delete({
+      where: {
+        id,
+        organizationId: orgId,
+      },
+    });
+  }
+
+  async createSet(orgId: string, body: SetsDto) {
+    const { id } = await this._sets.model.sets.upsert({
+      where: {
+        id: body.id || uuidv4(),
+        organizationId: orgId,
+      },
+      create: {
+        id: body.id || uuidv4(),
+        organizationId: orgId,
+        name: body.name,
+        content: body.content,
+      },
+      update: {
+        name: body.name,
+        content: body.content,
+      },
+    });
+
+    return { id };
+  }
+} 

libraries/nestjs-libraries/src/database/prisma/sets/sets.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+import { SetsRepository } from '@gitroom/nestjs-libraries/database/prisma/sets/sets.repository';
+import { SetsDto } from '@gitroom/nestjs-libraries/dtos/sets/sets.dto';
+
+@Injectable()
+export class SetsService {
+  constructor(private _setsRepository: SetsRepository) {}
+
+  getTotal(orgId: string) {
+    return this._setsRepository.getTotal(orgId);
+  }
+
+  getSets(orgId: string) {
+    return this._setsRepository.getSets(orgId);
+  }
+
+  createSet(orgId: string, body: SetsDto) {
+    return this._setsRepository.createSet(orgId, body);
+  }
+
+  deleteSet(orgId: string, id: string) {
+    return this._setsRepository.deleteSet(orgId, id);
+  }
+} 

libraries/nestjs-libraries/src/database/prisma/signatures/signature.repository.ts

@@ -0,0 +1,55 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { v4 as uuidv4 } from 'uuid';
+import { SignatureDto } from '@gitroom/nestjs-libraries/dtos/signature/signature.dto';
+
+@Injectable()
+export class SignatureRepository {
+  constructor(private _signatures: PrismaRepository<'signatures'>) {}
+
+  getSignaturesByOrgId(orgId: string) {
+    return this._signatures.model.signatures.findMany({
+      where: { organizationId: orgId, deletedAt: null },
+    });
+  }
+
+  getDefaultSignature(orgId: string) {
+    return this._signatures.model.signatures.findFirst({
+      where: { organizationId: orgId, autoAdd: true, deletedAt: null },
+    });
+  }
+
+  async createOrUpdateSignature(
+    orgId: string,
+    signature: SignatureDto,
+    id?: string
+  ) {
+    const values = {
+      organizationId: orgId,
+      content: signature.content,
+      autoAdd: signature.autoAdd,
+    };
+
+    const { id: updatedId } = await this._signatures.model.signatures.upsert({
+      where: { id: id || uuidv4(), organizationId: orgId },
+      update: values,
+      create: values,
+    });
+
+    if (values.autoAdd) {
+      await this._signatures.model.signatures.updateMany({
+        where: { organizationId: orgId, id: { not: updatedId } },
+        data: { autoAdd: false },
+      });
+    }
+
+    return { id: updatedId };
+  }
+
+  deleteSignature(orgId: string, id: string) {
+    return this._signatures.model.signatures.update({
+      where: { id, organizationId: orgId },
+      data: { deletedAt: new Date() },
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/signatures/signature.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common';
+import { SignatureRepository } from '@gitroom/nestjs-libraries/database/prisma/signatures/signature.repository';
+import { SignatureDto } from '@gitroom/nestjs-libraries/dtos/signature/signature.dto';
+
+@Injectable()
+export class SignatureService {
+  constructor(private _signatureRepository: SignatureRepository) {}
+
+  getSignaturesByOrgId(orgId: string) {
+    return this._signatureRepository.getSignaturesByOrgId(orgId);
+  }
+
+  getDefaultSignature(orgId: string) {
+    return this._signatureRepository.getDefaultSignature(orgId);
+  }
+
+  createOrUpdateSignature(orgId: string, signature: SignatureDto, id?: string) {
+    return this._signatureRepository.createOrUpdateSignature(
+      orgId,
+      signature,
+      id
+    );
+  }
+
+  deleteSignature(orgId: string, id: string) {
+    return this._signatureRepository.deleteSignature(orgId, id);
+  }
+}

libraries/nestjs-libraries/src/database/prisma/subscriptions/pricing.ts

@@ -0,0 +1,113 @@
+export interface PricingInnerInterface {
+  current: string;
+  month_price: number;
+  year_price: number;
+  channel?: number;
+  posts_per_month: number;
+  team_members: boolean;
+  community_features: boolean;
+  featured_by_gitroom: boolean;
+  ai: boolean;
+  import_from_channels: boolean;
+  image_generator?: boolean;
+  image_generation_count: number;
+  generate_videos: number;
+  public_api: boolean;
+  webhooks: number;
+  autoPost: boolean;
+}
+export interface PricingInterface {
+  [key: string]: PricingInnerInterface;
+}
+export const pricing: PricingInterface = {
+  FREE: {
+    current: 'FREE',
+    month_price: 0,
+    year_price: 0,
+    channel: 0,
+    image_generation_count: 0,
+    posts_per_month: 0,
+    team_members: false,
+    community_features: false,
+    featured_by_gitroom: false,
+    ai: false,
+    import_from_channels: false,
+    image_generator: false,
+    public_api: false,
+    webhooks: 0,
+    autoPost: false,
+    generate_videos: 0,
+  },
+  STANDARD: {
+    current: 'STANDARD',
+    month_price: 29,
+    year_price: 278,
+    channel: 5,
+    posts_per_month: 400,
+    image_generation_count: 20,
+    team_members: false,
+    ai: true,
+    community_features: false,
+    featured_by_gitroom: false,
+    import_from_channels: true,
+    image_generator: false,
+    public_api: true,
+    webhooks: 2,
+    autoPost: false,
+    generate_videos: 3,
+  },
+  TEAM: {
+    current: 'TEAM',
+    month_price: 39,
+    year_price: 374,
+    channel: 10,
+    posts_per_month: 1000000,
+    image_generation_count: 100,
+    community_features: true,
+    team_members: true,
+    featured_by_gitroom: true,
+    ai: true,
+    import_from_channels: true,
+    image_generator: true,
+    public_api: true,
+    webhooks: 10,
+    autoPost: true,
+    generate_videos: 10,
+  },
+  PRO: {
+    current: 'PRO',
+    month_price: 49,
+    year_price: 470,
+    channel: 30,
+    posts_per_month: 1000000,
+    image_generation_count: 300,
+    community_features: true,
+    team_members: true,
+    featured_by_gitroom: true,
+    ai: true,
+    import_from_channels: true,
+    image_generator: true,
+    public_api: true,
+    webhooks: 30,
+    autoPost: true,
+    generate_videos: 30,
+  },
+  ULTIMATE: {
+    current: 'ULTIMATE',
+    month_price: 99,
+    year_price: 950,
+    channel: 100,
+    posts_per_month: 1000000,
+    image_generation_count: 500,
+    community_features: true,
+    team_members: true,
+    featured_by_gitroom: true,
+    ai: true,
+    import_from_channels: true,
+    image_generator: true,
+    public_api: true,
+    webhooks: 10000,
+    autoPost: true,
+    generate_videos: 60,
+  },
+};

libraries/nestjs-libraries/src/database/prisma/subscriptions/subscription.repository.ts

@@ -0,0 +1,286 @@
+import { Injectable } from '@nestjs/common';
+import {
+  PrismaRepository,
+  PrismaTransaction,
+} from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import dayjs from 'dayjs';
+import { Organization } from '@prisma/client';
+
+@Injectable()
+export class SubscriptionRepository {
+  constructor(
+    private readonly _subscription: PrismaRepository<'subscription'>,
+    private readonly _organization: PrismaRepository<'organization'>,
+    private readonly _user: PrismaRepository<'user'>,
+    private readonly _credits: PrismaRepository<'credits'>,
+    private _usedCodes: PrismaRepository<'usedCodes'>
+  ) {}
+
+  getUserAccount(userId: string) {
+    return this._user.model.user.findFirst({
+      where: {
+        id: userId,
+      },
+      select: {
+        account: true,
+        connectedAccount: true,
+      },
+    });
+  }
+
+  getCode(code: string) {
+    return this._usedCodes.model.usedCodes.findFirst({
+      where: {
+        code,
+      },
+    });
+  }
+
+  updateAccount(userId: string, account: string) {
+    return this._user.model.user.update({
+      where: {
+        id: userId,
+      },
+      data: {
+        account,
+      },
+    });
+  }
+
+  getSubscriptionByOrganizationId(organizationId: string) {
+    return this._subscription.model.subscription.findFirst({
+      where: {
+        organizationId,
+        deletedAt: null,
+      },
+    });
+  }
+
+  updateConnectedStatus(account: string, accountCharges: boolean) {
+    return this._user.model.user.updateMany({
+      where: {
+        account,
+      },
+      data: {
+        connectedAccount: accountCharges,
+      },
+    });
+  }
+
+  getCustomerIdByOrgId(organizationId: string) {
+    return this._organization.model.organization.findFirst({
+      where: {
+        id: organizationId,
+      },
+      select: {
+        paymentId: true,
+      },
+    });
+  }
+
+  checkSubscription(organizationId: string, subscriptionId: string) {
+    return this._subscription.model.subscription.findFirst({
+      where: {
+        organizationId,
+        identifier: subscriptionId,
+        deletedAt: null,
+      },
+    });
+  }
+
+  deleteSubscriptionByCustomerId(customerId: string) {
+    return this._subscription.model.subscription.deleteMany({
+      where: {
+        organization: {
+          paymentId: customerId,
+        },
+      },
+    });
+  }
+
+  updateCustomerId(organizationId: string, customerId: string) {
+    return this._organization.model.organization.update({
+      where: {
+        id: organizationId,
+      },
+      data: {
+        paymentId: customerId,
+      },
+    });
+  }
+
+  async getSubscriptionByOrgId(orgId: string) {
+    return this._subscription.model.subscription.findFirst({
+      where: {
+        organizationId: orgId,
+      },
+    });
+  }
+
+  async getSubscriptionByCustomerId(customerId: string) {
+    return this._subscription.model.subscription.findFirst({
+      where: {
+        organization: {
+          paymentId: customerId,
+        },
+      },
+    });
+  }
+
+  async getOrganizationByCustomerId(customerId: string) {
+    return this._organization.model.organization.findFirst({
+      where: {
+        paymentId: customerId,
+      },
+    });
+  }
+
+  async createOrUpdateSubscription(
+    isTrailing: boolean,
+    identifier: string,
+    customerId: string,
+    totalChannels: number,
+    billing: 'STANDARD' | 'TEAM' | 'PRO' | 'ULTIMATE',
+    period: 'MONTHLY' | 'YEARLY',
+    cancelAt: number | null,
+    code?: string,
+    org?: { id: string }
+  ) {
+    const findOrg =
+      org || (await this.getOrganizationByCustomerId(customerId))!;
+
+    if (!findOrg) {
+      return;
+    }
+
+    await this._subscription.model.subscription.upsert({
+      where: {
+        organizationId: findOrg.id,
+        ...(!code
+          ? {
+              organization: {
+                paymentId: customerId,
+              },
+            }
+          : {}),
+      },
+      update: {
+        subscriptionTier: billing,
+        totalChannels,
+        period,
+        identifier,
+        isLifetime: !!code,
+        cancelAt: cancelAt ? new Date(cancelAt * 1000) : null,
+        deletedAt: null,
+      },
+      create: {
+        organizationId: findOrg.id,
+        subscriptionTier: billing,
+        isLifetime: !!code,
+        totalChannels,
+        period,
+        cancelAt: cancelAt ? new Date(cancelAt * 1000) : null,
+        identifier,
+        deletedAt: null,
+      },
+    });
+
+    await this._organization.model.organization.update({
+      where: {
+        id: findOrg.id,
+      },
+      data: {
+        isTrailing,
+        allowTrial: false,
+      },
+    });
+
+    if (code) {
+      await this._usedCodes.model.usedCodes.create({
+        data: {
+          code,
+          orgId: findOrg.id,
+        },
+      });
+    }
+  }
+
+  getSubscriptionByIdentifier(identifier: string) {
+    return this._subscription.model.subscription.findFirst({
+      where: {
+        identifier,
+        deletedAt: null,
+      },
+      include: {
+        organization: true,
+      },
+    });
+  }
+
+  getSubscription(organizationId: string) {
+    return this._subscription.model.subscription.findFirst({
+      where: {
+        organizationId,
+        deletedAt: null,
+      },
+    });
+  }
+
+  async getCreditsFrom(
+    organizationId: string,
+    from: dayjs.Dayjs,
+    type = 'ai_images'
+  ) {
+    const load = await this._credits.model.credits.groupBy({
+      by: ['organizationId'],
+      where: {
+        organizationId,
+        type,
+        createdAt: {
+          gte: from.toDate(),
+        },
+      },
+      _sum: {
+        credits: true,
+      },
+    });
+
+    return load?.[0]?._sum?.credits || 0;
+  }
+
+  async useCredit<T>(
+    org: Organization,
+    type = 'ai_images',
+    func: () => Promise<T>
+  ) {
+    const data = await this._credits.model.credits.create({
+      data: {
+        organizationId: org.id,
+        credits: 1,
+        type,
+      },
+    });
+
+    try {
+      return await func();
+    } catch (err) {
+      await this._credits.model.credits.delete({
+        where: {
+          id: data.id,
+        },
+      });
+      throw err;
+    }
+  }
+
+  setCustomerId(orgId: string, customerId: string) {
+    return this._organization.model.organization.update({
+      where: {
+        id: orgId,
+      },
+      data: {
+        paymentId: customerId,
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/subscriptions/subscription.service.ts

@@ -0,0 +1,264 @@
+import { Injectable } from '@nestjs/common';
+import { pricing } from '@gitroom/nestjs-libraries/database/prisma/subscriptions/pricing';
+import { SubscriptionRepository } from '@gitroom/nestjs-libraries/database/prisma/subscriptions/subscription.repository';
+import { IntegrationService } from '@gitroom/nestjs-libraries/database/prisma/integrations/integration.service';
+import { OrganizationService } from '@gitroom/nestjs-libraries/database/prisma/organizations/organization.service';
+import { Organization } from '@prisma/client';
+import dayjs from 'dayjs';
+import { makeId } from '@gitroom/nestjs-libraries/services/make.is';
+
+@Injectable()
+export class SubscriptionService {
+  constructor(
+    private readonly _subscriptionRepository: SubscriptionRepository,
+    private readonly _integrationService: IntegrationService,
+    private readonly _organizationService: OrganizationService
+  ) {}
+
+  getSubscriptionByOrganizationId(organizationId: string) {
+    return this._subscriptionRepository.getSubscriptionByOrganizationId(
+      organizationId
+    );
+  }
+
+  useCredit<T>(
+    organization: Organization,
+    type = 'ai_images',
+    func: () => Promise<T>
+  ): Promise<T> {
+    return this._subscriptionRepository.useCredit(organization, type, func);
+  }
+
+  getCode(code: string) {
+    return this._subscriptionRepository.getCode(code);
+  }
+
+  async deleteSubscription(customerId: string) {
+    await this.modifySubscription(
+      customerId,
+      pricing.FREE.channel || 0,
+      'FREE'
+    );
+    return this._subscriptionRepository.deleteSubscriptionByCustomerId(
+      customerId
+    );
+  }
+
+  updateCustomerId(organizationId: string, customerId: string) {
+    return this._subscriptionRepository.updateCustomerId(
+      organizationId,
+      customerId
+    );
+  }
+
+  async checkSubscription(organizationId: string, subscriptionId: string) {
+    return await this._subscriptionRepository.checkSubscription(
+      organizationId,
+      subscriptionId
+    );
+  }
+
+  async modifySubscriptionByOrg(
+    organizationId: string,
+    totalChannels: number,
+    billing: 'FREE' | 'STANDARD' | 'TEAM' | 'PRO' | 'ULTIMATE'
+  ) {
+    if (!organizationId) {
+      return false;
+    }
+
+    const getCurrentSubscription =
+      (await this._subscriptionRepository.getSubscriptionByOrgId(
+        organizationId
+      ))!;
+
+    const from = pricing[getCurrentSubscription?.subscriptionTier || 'FREE'];
+    const to = pricing[billing];
+
+    const currentTotalChannels = (
+      await this._integrationService.getIntegrationsList(organizationId)
+    ).filter((f) => !f.disabled);
+
+    if (currentTotalChannels.length > totalChannels) {
+      await this._integrationService.disableIntegrations(
+        organizationId,
+        currentTotalChannels.length - totalChannels
+      );
+    }
+
+    if (from.team_members && !to.team_members) {
+      await this._organizationService.disableOrEnableNonSuperAdminUsers(
+        organizationId,
+        true
+      );
+    }
+
+    if (!from.team_members && to.team_members) {
+      await this._organizationService.disableOrEnableNonSuperAdminUsers(
+        organizationId,
+        false
+      );
+    }
+
+    if (billing === 'FREE') {
+      await this._integrationService.changeActiveCron(organizationId);
+    }
+
+    return true;
+  }
+
+  async modifySubscription(
+    customerId: string,
+    totalChannels: number,
+    billing: 'FREE' | 'STANDARD' | 'TEAM' | 'PRO' | 'ULTIMATE'
+  ) {
+    if (!customerId) {
+      return false;
+    }
+
+    const getOrgByCustomerId =
+      await this._subscriptionRepository.getOrganizationByCustomerId(
+        customerId
+      );
+
+    const getCurrentSubscription =
+      (await this._subscriptionRepository.getSubscriptionByCustomerId(
+        customerId
+      ))!;
+
+    if (
+      !getOrgByCustomerId ||
+      (getCurrentSubscription && getCurrentSubscription?.isLifetime)
+    ) {
+      return false;
+    }
+
+    const from = pricing[getCurrentSubscription?.subscriptionTier || 'FREE'];
+    const to = pricing[billing];
+
+    const currentTotalChannels = (
+      await this._integrationService.getIntegrationsList(
+        getOrgByCustomerId?.id!
+      )
+    ).filter((f) => !f.disabled);
+
+    if (currentTotalChannels.length > totalChannels) {
+      await this._integrationService.disableIntegrations(
+        getOrgByCustomerId?.id!,
+        currentTotalChannels.length - totalChannels
+      );
+    }
+
+    if (from.team_members && !to.team_members) {
+      await this._organizationService.disableOrEnableNonSuperAdminUsers(
+        getOrgByCustomerId?.id!,
+        true
+      );
+    }
+
+    if (!from.team_members && to.team_members) {
+      await this._organizationService.disableOrEnableNonSuperAdminUsers(
+        getOrgByCustomerId?.id!,
+        false
+      );
+    }
+
+    if (billing === 'FREE') {
+      await this._integrationService.changeActiveCron(getOrgByCustomerId?.id!);
+    }
+
+    return true;
+  }
+
+  async createOrUpdateSubscription(
+    isTrailing: boolean,
+    identifier: string,
+    customerId: string,
+    totalChannels: number,
+    billing: 'STANDARD' | 'TEAM' | 'PRO' | 'ULTIMATE',
+    period: 'MONTHLY' | 'YEARLY',
+    cancelAt: number | null,
+    code?: string,
+    org?: string
+  ) {
+    if (!code) {
+      try {
+        const load = await this.modifySubscription(
+          customerId,
+          totalChannels,
+          billing
+        );
+        if (!load) {
+          return {};
+        }
+      } catch (e) {
+        return {};
+      }
+    }
+    return this._subscriptionRepository.createOrUpdateSubscription(
+      isTrailing,
+      identifier,
+      customerId,
+      totalChannels,
+      billing,
+      period,
+      cancelAt,
+      code,
+      org ? { id: org } : undefined
+    );
+  }
+
+  getSubscriptionByIdentifier(identifier: string) {
+    return this._subscriptionRepository.getSubscriptionByIdentifier(identifier);
+  }
+
+  async getSubscription(organizationId: string) {
+    return this._subscriptionRepository.getSubscription(organizationId);
+  }
+
+  async checkCredits(organization: Organization, checkType = 'ai_images') {
+    // @ts-ignore
+    const type = organization?.subscription?.subscriptionTier || 'FREE';
+
+    if (type === 'FREE') {
+      return { credits: 0 };
+    }
+
+    // @ts-ignore
+    let date = dayjs(organization.subscription.createdAt);
+    while (date.isBefore(dayjs())) {
+      date = date.add(1, 'month');
+    }
+
+    const checkFromMonth = date.subtract(1, 'month');
+    const imageGenerationCount =
+      checkType === 'ai_images'
+        ? pricing[type].image_generation_count
+        : pricing[type].generate_videos;
+
+    const totalUse = await this._subscriptionRepository.getCreditsFrom(
+      organization.id,
+      checkFromMonth,
+      checkType
+    );
+
+    return {
+      credits: imageGenerationCount - totalUse,
+    };
+  }
+
+  async addSubscription(orgId: string, userId: string, subscription: any) {
+    await this._subscriptionRepository.setCustomerId(orgId, userId);
+    return this.createOrUpdateSubscription(
+      false,
+      makeId(5),
+      userId,
+      pricing[subscription].channel!,
+      subscription,
+      'MONTHLY',
+      null,
+      undefined,
+      orgId
+    );
+  }
+}

libraries/nestjs-libraries/src/database/prisma/third-party/third-party.repository.ts

@@ -0,0 +1,64 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { AuthService } from '@gitroom/helpers/auth/auth.service';
+
+@Injectable()
+export class ThirdPartyRepository {
+  constructor(private _thirdParty: PrismaRepository<'thirdParty'>) {}
+
+  getAllThirdPartiesByOrganization(org: string) {
+    return this._thirdParty.model.thirdParty.findMany({
+      where: { organizationId: org, deletedAt: null },
+      select: {
+        id: true,
+        name: true,
+        identifier: true,
+      },
+    });
+  }
+
+  deleteIntegration(org: string, id: string) {
+    return this._thirdParty.model.thirdParty.update({
+      where: { id, organizationId: org },
+      data: { deletedAt: new Date() },
+    });
+  }
+
+  getIntegrationById(org: string, id: string) {
+    return this._thirdParty.model.thirdParty.findFirst({
+      where: { id, organizationId: org, deletedAt: null },
+    });
+  }
+
+  saveIntegration(
+    org: string,
+    identifier: string,
+    apiKey: string,
+    data: { name: string; username: string; id: string }
+  ) {
+    return this._thirdParty.model.thirdParty.upsert({
+      where: {
+        organizationId_internalId: {
+          internalId: data.id,
+          organizationId: org,
+        },
+      },
+      create: {
+        organizationId: org,
+        name: data.name,
+        internalId: data.id,
+        identifier,
+        apiKey: AuthService.fixedEncryption(apiKey),
+        deletedAt: null,
+      },
+      update: {
+        organizationId: org,
+        name: data.name,
+        internalId: data.id,
+        identifier,
+        apiKey: AuthService.fixedEncryption(apiKey),
+        deletedAt: null,
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/third-party/third-party.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common';
+import { ThirdPartyRepository } from '@gitroom/nestjs-libraries/database/prisma/third-party/third-party.repository';
+
+@Injectable()
+export class ThirdPartyService {
+  constructor(private _thirdPartyRepository: ThirdPartyRepository) {}
+
+  getAllThirdPartiesByOrganization(org: string) {
+    return this._thirdPartyRepository.getAllThirdPartiesByOrganization(org);
+  }
+
+  deleteIntegration(org: string, id: string) {
+    return this._thirdPartyRepository.deleteIntegration(org, id);
+  }
+
+  getIntegrationById(org: string, id: string) {
+    return this._thirdPartyRepository.getIntegrationById(org, id);
+  }
+
+  saveIntegration(
+    org: string,
+    identifier: string,
+    apiKey: string,
+    data: { name: string; username: string; id: string }
+  ) {
+    return this._thirdPartyRepository.saveIntegration(org, identifier, apiKey, data);
+  }
+}

libraries/nestjs-libraries/src/database/prisma/users/users.repository.ts

@@ -0,0 +1,177 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { Provider } from '@prisma/client';
+import { AuthService } from '@gitroom/helpers/auth/auth.service';
+import { UserDetailDto } from '@gitroom/nestjs-libraries/dtos/users/user.details.dto';
+import { EmailNotificationsDto } from '@gitroom/nestjs-libraries/dtos/users/email-notifications.dto';
+
+@Injectable()
+export class UsersRepository {
+  constructor(private _user: PrismaRepository<'user'>) {}
+
+  getImpersonateUser(name: string) {
+    return this._user.model.user.findMany({
+      where: {
+        OR: [
+          {
+            name: {
+              contains: name,
+            },
+          },
+          {
+            email: {
+              contains: name,
+            },
+          },
+          {
+            id: {
+              contains: name,
+            },
+          },
+        ],
+      },
+      select: {
+        id: true,
+        name: true,
+        email: true,
+      },
+      take: 10,
+    });
+  }
+
+  getUserById(id: string) {
+    return this._user.model.user.findFirst({
+      where: {
+        id,
+      },
+    });
+  }
+
+  getUserByEmail(email: string) {
+    return this._user.model.user.findFirst({
+      where: {
+        email,
+        providerName: Provider.LOCAL,
+      },
+      include: {
+        picture: {
+          select: {
+            id: true,
+            path: true,
+          },
+        },
+      },
+    });
+  }
+
+  activateUser(id: string) {
+    return this._user.model.user.update({
+      where: {
+        id,
+      },
+      data: {
+        activated: true,
+      },
+    });
+  }
+
+  getUserByProvider(providerId: string, provider: Provider) {
+    return this._user.model.user.findFirst({
+      where: {
+        providerId,
+        providerName: provider,
+      },
+    });
+  }
+
+  updatePassword(id: string, password: string) {
+    return this._user.model.user.update({
+      where: {
+        id,
+        providerName: Provider.LOCAL,
+      },
+      data: {
+        password: AuthService.hashPassword(password),
+      },
+    });
+  }
+
+  changeAudienceSize(userId: string, audience: number) {
+    return this._user.model.user.update({
+      where: {
+        id: userId,
+      },
+      data: {
+        audience,
+      },
+    });
+  }
+
+  async getPersonal(userId: string) {
+    const user = await this._user.model.user.findUnique({
+      where: {
+        id: userId,
+      },
+      select: {
+        id: true,
+        name: true,
+        bio: true,
+        picture: {
+          select: {
+            id: true,
+            path: true,
+          },
+        },
+      },
+    });
+
+    return user;
+  }
+
+  async changePersonal(userId: string, body: UserDetailDto) {
+    await this._user.model.user.update({
+      where: {
+        id: userId,
+      },
+      data: {
+        name: body.fullname,
+        bio: body.bio,
+        picture: body.picture
+          ? {
+              connect: {
+                id: body.picture.id,
+              },
+            }
+          : {
+              disconnect: true,
+            },
+      },
+    });
+  }
+
+  async getEmailNotifications(userId: string) {
+    return this._user.model.user.findUnique({
+      where: {
+        id: userId,
+      },
+      select: {
+        sendSuccessEmails: true,
+        sendFailureEmails: true,
+        sendStreakEmails: true,
+      },
+    });
+  }
+
+  async updateEmailNotifications(userId: string, body: EmailNotificationsDto) {
+    await this._user.model.user.update({
+      where: {
+        id: userId,
+      },
+      data: {
+        sendSuccessEmails: body.sendSuccessEmails,
+        sendFailureEmails: body.sendFailureEmails,
+        sendStreakEmails: body.sendStreakEmails,
+      },
+    });
+  }
+}

libraries/nestjs-libraries/src/database/prisma/users/users.service.ts

@@ -0,0 +1,54 @@
+import { Injectable } from '@nestjs/common';
+import { UsersRepository } from '@gitroom/nestjs-libraries/database/prisma/users/users.repository';
+import { Provider } from '@prisma/client';
+import { UserDetailDto } from '@gitroom/nestjs-libraries/dtos/users/user.details.dto';
+import { EmailNotificationsDto } from '@gitroom/nestjs-libraries/dtos/users/email-notifications.dto';
+import { OrganizationRepository } from '@gitroom/nestjs-libraries/database/prisma/organizations/organization.repository';
+
+@Injectable()
+export class UsersService {
+  constructor(
+    private _usersRepository: UsersRepository,
+    private _organizationRepository: OrganizationRepository
+  ) {}
+
+  getUserByEmail(email: string) {
+    return this._usersRepository.getUserByEmail(email);
+  }
+
+  getUserById(id: string) {
+    return this._usersRepository.getUserById(id);
+  }
+
+  getImpersonateUser(name: string) {
+    return this._organizationRepository.getImpersonateUser(name);
+  }
+
+  getUserByProvider(providerId: string, provider: Provider) {
+    return this._usersRepository.getUserByProvider(providerId, provider);
+  }
+
+  activateUser(id: string) {
+    return this._usersRepository.activateUser(id);
+  }
+
+  updatePassword(id: string, password: string) {
+    return this._usersRepository.updatePassword(id, password);
+  }
+
+  getPersonal(userId: string) {
+    return this._usersRepository.getPersonal(userId);
+  }
+
+  changePersonal(userId: string, body: UserDetailDto) {
+    return this._usersRepository.changePersonal(userId, body);
+  }
+
+  getEmailNotifications(userId: string) {
+    return this._usersRepository.getEmailNotifications(userId);
+  }
+
+  updateEmailNotifications(userId: string, body: EmailNotificationsDto) {
+    return this._usersRepository.updateEmailNotifications(userId, body);
+  }
+}

libraries/nestjs-libraries/src/database/prisma/webhooks/webhooks.repository.ts

@@ -0,0 +1,87 @@
+import { PrismaRepository } from '@gitroom/nestjs-libraries/database/prisma/prisma.service';
+import { Injectable } from '@nestjs/common';
+import { WebhooksDto } from '@gitroom/nestjs-libraries/dtos/webhooks/webhooks.dto';
+import { v4 as uuidv4 } from 'uuid';
+
+@Injectable()
+export class WebhooksRepository {
+  constructor(private _webhooks: PrismaRepository<'webhooks'>) {}
+
+  getTotal(orgId: string) {
+    return this._webhooks.model.webhooks.count({
+      where: {
+        organizationId: orgId,
+        deletedAt: null,
+      },
+    });
+  }
+
+  getWebhooks(orgId: string) {
+    return this._webhooks.model.webhooks.findMany({
+      where: {
+        organizationId: orgId,
+        deletedAt: null,
+      },
+      include: {
+        integrations: {
+          select: {
+            integration: {
+              select: {
+                id: true,
+                picture: true,
+                name: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  deleteWebhook(orgId: string, id: string) {
+    return this._webhooks.model.webhooks.update({
+      where: {
+        id,
+        organizationId: orgId,
+      },
+      data: {
+        deletedAt: new Date(),
+      },
+    });
+  }
+
+  async createWebhook(orgId: string, body: WebhooksDto) {
+    const { id } = await this._webhooks.model.webhooks.upsert({
+      where: {
+        id: body.id || uuidv4(),
+        organizationId: orgId,
+      },
+      create: {
+        organizationId: orgId,
+        url: body.url,
+        name: body.name,
+      },
+      update: {
+        url: body.url,
+        name: body.name,
+      },
+    });
+
+    await this._webhooks.model.webhooks.update({
+      where: {
+        id,
+        organizationId: orgId,
+      },
+      data: {
+        integrations: {
+          deleteMany: {},
+          create: body.integrations.map((integration) => ({
+            integrationId: integration.id,
+          })),
+        },
+      },
+    });
+
+    return { id };
+  }
+}

libraries/nestjs-libraries/src/database/prisma/webhooks/webhooks.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+import { WebhooksRepository } from '@gitroom/nestjs-libraries/database/prisma/webhooks/webhooks.repository';
+import { WebhooksDto } from '@gitroom/nestjs-libraries/dtos/webhooks/webhooks.dto';
+
+@Injectable()
+export class WebhooksService {
+  constructor(private _webhooksRepository: WebhooksRepository) {}
+
+  getTotal(orgId: string) {
+    return this._webhooksRepository.getTotal(orgId);
+  }
+
+  getWebhooks(orgId: string) {
+    return this._webhooksRepository.getWebhooks(orgId);
+  }
+
+  createWebhook(orgId: string, body: WebhooksDto) {
+    return this._webhooksRepository.createWebhook(orgId, body);
+  }
+
+  deleteWebhook(orgId: string, id: string) {
+    return this._webhooksRepository.deleteWebhook(orgId, id);
+  }
+}

libraries/nestjs-libraries/src/dtos/agencies/create.agency.dto.ts

@@ -0,0 +1,96 @@
+import {
+  ArrayMaxSize,
+  ArrayMinSize,
+  IsDefined,
+  IsIn,
+  IsOptional,
+  IsString,
+  IsUrl,
+  MinLength,
+  ValidateIf,
+} from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class CreateAgencyLogoDto {
+  @IsString()
+  @IsDefined()
+  id: string;
+
+  path: string;
+}
+export class CreateAgencyDto {
+  @IsString()
+  @MinLength(3)
+  name: string;
+
+  @IsUrl()
+  @IsDefined()
+  website: string;
+
+  @IsUrl()
+  @ValidateIf((o) => o.facebook)
+  facebook: string;
+
+  @IsString()
+  @IsOptional()
+  instagram: string;
+
+  @IsString()
+  @IsOptional()
+  twitter: string;
+
+  @IsUrl()
+  @ValidateIf((o) => o.linkedIn)
+  linkedIn: string;
+
+  @IsUrl()
+  @ValidateIf((o) => o.youtube)
+  youtube: string;
+
+  @IsString()
+  @IsOptional()
+  tiktok: string;
+
+  @Type(() => CreateAgencyLogoDto)
+  logo: CreateAgencyLogoDto;
+
+  @IsString()
+  shortDescription: string;
+
+  @IsString()
+  description: string;
+
+  @IsString({
+    each: true,
+  })
+  @ArrayMinSize(1)
+  @ArrayMaxSize(3)
+  @IsIn(
+    [
+      'Real Estate',
+      'Fashion',
+      'Health and Fitness',
+      'Beauty',
+      'Travel',
+      'Food',
+      'Tech',
+      'Gaming',
+      'Parenting',
+      'Education',
+      'Business',
+      'Finance',
+      'DIY',
+      'Pets',
+      'Lifestyle',
+      'Sports',
+      'Entertainment',
+      'Art',
+      'Photography',
+      'Sustainability',
+    ],
+    {
+      each: true,
+    }
+  )
+  niches: string[];
+}

libraries/nestjs-libraries/src/dtos/analytics/stars.list.dto.ts

@@ -0,0 +1,15 @@
+import { IsDefined, IsIn, IsNumber, IsOptional } from 'class-validator';
+
+export class StarsListDto {
+  @IsNumber()
+  @IsDefined()
+  page: number;
+
+  @IsOptional()
+  @IsIn(['login', 'totalStars', 'stars', 'date', 'forks', 'totalForks'])
+  key: 'login' | 'date' | 'stars' | 'totalStars';
+
+  @IsOptional()
+  @IsIn(['desc', 'asc'])
+  state: 'desc' | 'asc';
+}

libraries/nestjs-libraries/src/dtos/announcements/announcements.dto.ts

@@ -0,0 +1,16 @@
+import { IsDefined, IsIn, IsOptional, IsString } from 'class-validator';
+
+export class AnnouncementDto {
+  @IsString()
+  @IsDefined()
+  title: string;
+
+  @IsString()
+  @IsDefined()
+  description: string;
+
+  @IsOptional()
+  @IsString()
+  @IsIn(['INFO', 'WARNING', 'ERROR'])
+  color?: string;
+}

libraries/nestjs-libraries/src/dtos/auth/create.org.user.dto.ts

@@ -0,0 +1,40 @@
+import {
+  IsDefined,
+  IsEmail,
+  IsString,
+  MaxLength,
+  MinLength,
+  ValidateIf,
+} from 'class-validator';
+import { Provider } from '@prisma/client';
+
+export class CreateOrgUserDto {
+  @IsString()
+  @MinLength(3)
+  @MaxLength(64)
+  @IsDefined()
+  @ValidateIf((o) => !o.providerToken)
+  password: string;
+
+  @IsString()
+  @IsDefined()
+  provider: Provider;
+
+  @IsString()
+  @IsDefined()
+  @ValidateIf((o) => !o.password)
+  providerToken: string;
+
+  @IsEmail()
+  @IsDefined()
+  @ValidateIf((o) => !o.providerToken)
+  email: string;
+
+  @IsString()
+  @IsDefined()
+  @MinLength(3)
+  @MaxLength(128)
+  company: string;
+
+  datafast_visitor_id: string;
+}

libraries/nestjs-libraries/src/dtos/auth/forgot-return.password.dto.ts

@@ -0,0 +1,28 @@
+import {
+  IsDefined,
+  IsIn,
+  IsString,
+  MinLength,
+  ValidateIf,
+} from 'class-validator';
+import { makeId } from '@gitroom/nestjs-libraries/services/make.is';
+
+export class ForgotReturnPasswordDto {
+  @IsString()
+  @IsDefined()
+  @MinLength(3)
+  password: string;
+
+  @IsString()
+  @IsDefined()
+  @IsIn([makeId(10)], {
+    message: 'Passwords do not match',
+  })
+  @ValidateIf((o) => o.password !== o.repeatPassword)
+  repeatPassword: string;
+
+  @IsString()
+  @IsDefined()
+  @MinLength(5)
+  token: string;
+}

libraries/nestjs-libraries/src/dtos/auth/forgot.password.dto.ts

@@ -0,0 +1,8 @@
+import { IsDefined, IsEmail, IsString } from 'class-validator';
+
+export class ForgotPasswordDto {
+  @IsString()
+  @IsDefined()
+  @IsEmail()
+  email: string;
+}

libraries/nestjs-libraries/src/dtos/auth/login.user.dto.ts

@@ -0,0 +1,31 @@
+import {
+  IsDefined,
+  IsEmail,
+  IsString,
+  MinLength,
+  ValidateIf,
+} from 'class-validator';
+import { Provider } from '@prisma/client';
+
+export class LoginUserDto {
+  @IsString()
+  @IsDefined()
+  @ValidateIf((o) => !o.providerToken)
+  @MinLength(3)
+  password: string;
+
+  @IsString()
+  @IsDefined()
+  provider: Provider;
+
+  @IsString()
+  @IsDefined()
+  @ValidateIf((o) => !o.password)
+  providerToken: string;
+
+  @IsEmail()
+  @IsDefined()
+  email: string;
+
+  datafast_visitor_id: string;
+}