projects/invites module

src/pb/projects-events.pb.ts

@@ -0,0 +1,216 @@
+/* eslint-disable */
+import { GrpcMethod, GrpcStreamMethod } from "@nestjs/microservices";
+import Long from "long";
+import * as _m0 from "protobufjs/minimal";
+import { Observable } from "rxjs";
+import { Error } from "./common.pb";
+import { Empty } from "./google/protobuf/empty.pb";
+
+export const protobufPackage = "eventbus";
+
+export interface Project {
+  id?: string | undefined;
+  email?: string | undefined;
+  name?: string | undefined;
+  password?: string | undefined;
+  salt?: string | undefined;
+}
+
+export interface ProjectEvent {
+  error?: Error | undefined;
+  project: Project | undefined;
+}
+
+export interface AddOrRemoveUserFromProjectEvent {
+  error?: Error | undefined;
+  projectId: string;
+  userId: string;
+}
+
+export interface IsUserProjectParticipantEvent {
+  error?: Error | undefined;
+  projectId: string;
+  userId: string;
+  bool: boolean;
+}
+
+export interface SearchProjectsParams {
+  boardId?: string | undefined;
+  projectsIds: string[];
+  limit?: number | undefined;
+  offset?: number | undefined;
+}
+
+export interface SearchProjectsEvent {
+  error?: Error | undefined;
+  searchParams: SearchProjectsParams | undefined;
+  projects: Project[];
+}
+
+export interface Invite {
+  id?: string | undefined;
+  userId?: string | undefined;
+  projectId?: string | undefined;
+}
+
+export interface InviteEvent {
+  error?: Error | undefined;
+  invite: Invite | undefined;
+}
+
+export interface SearchInvitesParams {
+  userId?: string | undefined;
+  projectId?: string | undefined;
+  invitesIds: string[];
+  limit?: number | undefined;
+  offset?: number | undefined;
+}
+
+export interface SearchInvitesEvent {
+  error?: Error | undefined;
+  searchParams: SearchInvitesParams | undefined;
+  invites: Invite[];
+}
+
+export const EVENTBUS_PACKAGE_NAME = "eventbus";
+
+export interface ProjectsEventsServiceClient {
+  getProjectByIdEvent(request: ProjectEvent): Observable<Empty>;
+
+  searchProjectsEvent(request: SearchProjectsEvent): Observable<Empty>;
+
+  isUserProjectParticipantEvent(
+    request: IsUserProjectParticipantEvent
+  ): Observable<Empty>;
+
+  createProjectEvent(request: ProjectEvent): Observable<Empty>;
+
+  updateProjectEvent(request: ProjectEvent): Observable<Empty>;
+
+  deleteProjectEvent(request: ProjectEvent): Observable<Empty>;
+
+  addUserToProject(request: AddOrRemoveUserFromProjectEvent): Observable<Empty>;
+
+  removeUserFromProject(
+    request: AddOrRemoveUserFromProjectEvent
+  ): Observable<Empty>;
+}
+
+export interface ProjectsEventsServiceController {
+  getProjectByIdEvent(request: ProjectEvent): void;
+
+  searchProjectsEvent(request: SearchProjectsEvent): void;
+
+  isUserProjectParticipantEvent(request: IsUserProjectParticipantEvent): void;
+
+  createProjectEvent(request: ProjectEvent): void;
+
+  updateProjectEvent(request: ProjectEvent): void;
+
+  deleteProjectEvent(request: ProjectEvent): void;
+
+  addUserToProject(request: AddOrRemoveUserFromProjectEvent): void;
+
+  removeUserFromProject(request: AddOrRemoveUserFromProjectEvent): void;
+}
+
+export function ProjectsEventsServiceControllerMethods() {
+  return function (constructor: Function) {
+    const grpcMethods: string[] = [
+      "getProjectByIdEvent",
+      "searchProjectsEvent",
+      "isUserProjectParticipantEvent",
+      "createProjectEvent",
+      "updateProjectEvent",
+      "deleteProjectEvent",
+      "addUserToProject",
+      "removeUserFromProject",
+    ];
+    for (const method of grpcMethods) {
+      const descriptor: any = Reflect.getOwnPropertyDescriptor(
+        constructor.prototype,
+        method
+      );
+      GrpcMethod("ProjectsEventsService", method)(
+        constructor.prototype[method],
+        method,
+        descriptor
+      );
+    }
+    const grpcStreamMethods: string[] = [];
+    for (const method of grpcStreamMethods) {
+      const descriptor: any = Reflect.getOwnPropertyDescriptor(
+        constructor.prototype,
+        method
+      );
+      GrpcStreamMethod("ProjectsEventsService", method)(
+        constructor.prototype[method],
+        method,
+        descriptor
+      );
+    }
+  };
+}
+
+export const PROJECTS_EVENTS_SERVICE_NAME = "ProjectsEventsService";
+
+export interface InvitesEventsServiceClient {
+  getInviteByIdEvent(request: InviteEvent): Observable<Empty>;
+
+  searchInvitesEvent(request: SearchInvitesEvent): Observable<Empty>;
+
+  createInviteEvent(request: InviteEvent): Observable<Empty>;
+
+  deleteInviteByIdEvent(request: InviteEvent): Observable<Empty>;
+}
+
+export interface InvitesEventsServiceController {
+  getInviteByIdEvent(request: InviteEvent): void;
+
+  searchInvitesEvent(request: SearchInvitesEvent): void;
+
+  createInviteEvent(request: InviteEvent): void;
+
+  deleteInviteByIdEvent(request: InviteEvent): void;
+}
+
+export function InvitesEventsServiceControllerMethods() {
+  return function (constructor: Function) {
+    const grpcMethods: string[] = [
+      "getInviteByIdEvent",
+      "searchInvitesEvent",
+      "createInviteEvent",
+      "deleteInviteByIdEvent",
+    ];
+    for (const method of grpcMethods) {
+      const descriptor: any = Reflect.getOwnPropertyDescriptor(
+        constructor.prototype,
+        method
+      );
+      GrpcMethod("InvitesEventsService", method)(
+        constructor.prototype[method],
+        method,
+        descriptor
+      );
+    }
+    const grpcStreamMethods: string[] = [];
+    for (const method of grpcStreamMethods) {
+      const descriptor: any = Reflect.getOwnPropertyDescriptor(
+        constructor.prototype,
+        method
+      );
+      GrpcStreamMethod("InvitesEventsService", method)(
+        constructor.prototype[method],
+        method,
+        descriptor
+      );
+    }
+  };
+}
+
+export const INVITES_EVENTS_SERVICE_NAME = "InvitesEventsService";
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}

src/projects-events/controllers/invites-events.controller.ts

@@ -0,0 +1,39 @@
+import { Controller, Inject } from '@nestjs/common'
+import { GrpcMethod } from '@nestjs/microservices'
+import {
+    INVITES_EVENTS_SERVICE_NAME,
+    InvitesEventsServiceController,
+    SearchInvitesEvent,
+    InviteEvent,
+} from '../../pb/projects-events.pb'
+import { InvitesEventsService } from '../services/invites-events.service'
+import { from, Observable } from 'rxjs'
+import { Empty } from 'src/pb/google/protobuf/empty.pb'
+
+@Controller()
+export class InvitesEventsController implements InvitesEventsServiceController {
+
+    @Inject(InvitesEventsService)
+    private readonly invitesEventsService: InvitesEventsService
+
+    @GrpcMethod(INVITES_EVENTS_SERVICE_NAME, 'getInviteByIdEvent')
+    public getInviteByIdEvent(dto: InviteEvent): Observable<Empty> {
+        return from(this.invitesEventsService.onGetInviteByIdEvent(dto))
+    }
+
+    @GrpcMethod(INVITES_EVENTS_SERVICE_NAME, 'searchInvitesEvent')
+    public searchInvitesEvent(dto: SearchInvitesEvent): Observable<Empty> {
+        return from(this.invitesEventsService.onSearchInvitesEvent(dto))
+    }
+
+    @GrpcMethod(INVITES_EVENTS_SERVICE_NAME, 'createInviteEvent')
+    public createInviteEvent(dto: InviteEvent): Observable<Empty> {
+        return from(this.invitesEventsService.onCreateInviteEvent(dto))
+    }
+
+    @GrpcMethod(INVITES_EVENTS_SERVICE_NAME, 'deleteInviteByIdEvent')
+    public deleteInviteByIdEvent(dto: InviteEvent): Observable<Empty> {
+        return from(this.invitesEventsService.onDeleteInviteByIdEvent(dto))
+    }
+
+}

src/projects-events/controllers/projects-events.controller.ts

@@ -0,0 +1,61 @@
+import { Controller, Inject } from '@nestjs/common'
+import { GrpcMethod } from '@nestjs/microservices'
+import {
+    PROJECTS_EVENTS_SERVICE_NAME,
+    ProjectsEventsServiceController,
+    SearchProjectsEvent,
+    ProjectEvent,
+    IsUserProjectParticipantEvent,
+    AddOrRemoveUserFromProjectEvent,
+} from '../../pb/projects-events.pb'
+import { ProjectsEventsService } from '../services/projects-events.service'
+import { from, Observable } from 'rxjs'
+import { Empty } from 'src/pb/google/protobuf/empty.pb'
+
+@Controller()
+export class ProjectsEventsController implements ProjectsEventsServiceController {
+
+    @Inject(ProjectsEventsService)
+    private readonly projectsEventsService: ProjectsEventsService
+
+    @GrpcMethod(PROJECTS_EVENTS_SERVICE_NAME, 'getProjectByIdEvent')
+    public getProjectByIdEvent(dto: ProjectEvent): Observable<Empty> {
+        return from(this.projectsEventsService.onGetProjectByIdEvent(dto))
+    }
+
+    @GrpcMethod(PROJECTS_EVENTS_SERVICE_NAME, 'searchProjectsEvent')
+    public searchProjectsEvent(dto: SearchProjectsEvent): Observable<Empty> {
+        return from(this.projectsEventsService.onSearchProjectsEvent(dto))
+    }
+
+    @GrpcMethod(PROJECTS_EVENTS_SERVICE_NAME, 'isUserProjectParticipantEvent')
+    public isUserProjectParticipantEvent(dto: IsUserProjectParticipantEvent): Observable<Empty> {
+        return from(this.projectsEventsService.onIsUserProjectParticipantEvent(dto))
+    }
+
+    @GrpcMethod(PROJECTS_EVENTS_SERVICE_NAME, 'createProjectEvent')
+    public createProjectEvent(dto: ProjectEvent): Observable<Empty> {
+        return from(this.projectsEventsService.onCreateProjectEvent(dto))
+    }
+
+    @GrpcMethod(PROJECTS_EVENTS_SERVICE_NAME, 'updateProjectEvent')
+    public updateProjectEvent(dto: ProjectEvent): Observable<Empty> {
+        return from(this.projectsEventsService.onUpdateProjectEvent(dto))
+    }
+
+    @GrpcMethod(PROJECTS_EVENTS_SERVICE_NAME, 'deleteProjectEvent')
+    public deleteProjectEvent(dto: ProjectEvent): Observable<Empty> {
+        return from(this.projectsEventsService.onDeleteProjectEvent(dto))
+    }
+
+    @GrpcMethod(PROJECTS_EVENTS_SERVICE_NAME, 'addUserToProject')
+    public addUserToProject(dto: AddOrRemoveUserFromProjectEvent): Observable<Empty> {
+        return from(this.projectsEventsService.onAddUserToProject(dto))
+    }
+
+    @GrpcMethod(PROJECTS_EVENTS_SERVICE_NAME, 'removeUserFromProject')
+    public removeUserFromProject(dto: AddOrRemoveUserFromProjectEvent): Observable<Empty> {
+        return from(this.projectsEventsService.onRemoveUserFromProject(dto))
+    }
+
+}

src/projects-events/projects-events.module.ts

@@ -0,0 +1,24 @@
+import { Module } from '@nestjs/common'
+import { ProjectsEventsController } from './controllers/projects-events.controller'
+import { ProjectsEventsService } from './services/projects-events.service'
+import { CacheModule } from 'src/cache/cache.module'
+import { MongooseModule } from '@nestjs/mongoose'
+import { Event, EventSchema } from 'src/event.schema'
+import { InvitesEventsController } from './controllers/invites-events.controller'
+import { InvitesEventsService } from './services/invites-events.service'
+
+@Module({
+    imports: [
+        CacheModule,
+        MongooseModule.forFeature([ { name: Event.name, schema: EventSchema, collection: 'events' } ]),
+    ],
+    controllers: [
+        ProjectsEventsController,
+        InvitesEventsController,
+    ],
+    providers: [
+        ProjectsEventsService,
+        InvitesEventsService,
+    ],
+})
+export class ProjectsEventsModule {}