@grapadigital/shared-schemas 1.0.172 → 1.0.174

package/src/schemas/group.schema.ts

@@ -0,0 +1,23 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument, Types } from 'mongoose';
+
+export type GroupDocument = HydratedDocument<Group>;
+
+@Schema({ timestamps: true, collection: 'group' })
+export class Group {
+  @Prop({ type: Types.ObjectId, ref: 'Organization', required: true, index: true })
+  organization: Types.ObjectId;
+
+  @Prop({ required: true, trim: true })
+  name: string;
+
+  @Prop({ type: [Types.ObjectId], ref: 'User', default: [] })
+  memberIds: Types.ObjectId[];
+
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export const GroupSchema = SchemaFactory.createForClass(Group);
+
+GroupSchema.index({ organization: 1, name: 1 }, { unique: true });

package/src/schemas/influencer.schema.ts

@@ -1,7 +1,7 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
 import { HydratedDocument, Schema as MongooseSchema, Types, model as MongooseModel } from 'mongoose';
 import { Profile } from './profile.schema';
-import { User } from './user.schema';
+import { Party } from './party.schema';
 
 export type InfluencerDocument = HydratedDocument<Influencer>;
 @Schema({ _id: false })
@@ -34,7 +34,7 @@ export class Note {
 export const NoteSchema = SchemaFactory.createForClass(Note);
 
 @Schema({ timestamps: true })
-export class Influencer extends User {
+export class Influencer extends Party {
   @Prop({ required: false })
   financialManagementSheet?: string;
 

package/src/schemas/notifications.schema.ts

@@ -0,0 +1,61 @@
+
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument, model as MongooseModel } from 'mongoose';
+
+
+
+export type NotificationDocument = HydratedDocument<Notification>;
+
+@Schema({ _id: false })
+export class NotificationRecipient {
+  @Prop({ type: String })
+  name?: string;
+
+  @Prop({ type: String })
+  username?: string;
+
+  @Prop({ type: String })
+  email?: string;
+}
+
+@Schema({ _id: false })
+export class NotificationEntity {
+  @Prop({ type: String })
+  name?: string;
+
+  @Prop({ type: String })
+  title?: string;
+
+  @Prop({ type: String })
+  _id?: string;
+}
+
+@Schema({ timestamps: true, collection: 'notifications' })
+export class Notification {
+  @Prop({ type: NotificationRecipient, required: true })
+  recipient: NotificationRecipient;
+
+  @Prop({ required: true, type: String })
+  event: string;
+
+  @Prop({ type: [String], default: [] })
+  channels: string[];
+
+  @Prop({ type: String })
+  title?: string;
+
+  @Prop({ type: String })
+  body?: string;
+
+  @Prop({ type: NotificationEntity })
+  entity?: NotificationEntity;
+
+  @Prop({ type: Boolean, default: false })
+  read: boolean;
+
+  @Prop({ type: Date, default: Date.now })
+  createdAt: Date;
+}
+
+export const NotificationSchema = SchemaFactory.createForClass(Notification);
+export const NotificationModel = MongooseModel('Notification', NotificationSchema);

package/src/schemas/organization.schema.ts

@@ -0,0 +1,29 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+
+export type OrganizationDocument = HydratedDocument<Organization>;
+
+@Schema({ timestamps: true, collection: 'organizations', strict: true })
+export class Organization {
+  @Prop({ required: true, trim: true })
+  corporateName: string;
+
+  @Prop({ required: true, trim: true })
+  fantasyName: string;
+
+  @Prop({ required: true, unique: true, index: true })
+  cnpj: string;
+
+  @Prop()
+  logo?: string;
+
+  @Prop()
+  logoSmall?: string;
+
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export const OrganizationSchema = SchemaFactory.createForClass(Organization);
+
+OrganizationSchema.index({ fantasyName: 'text', corporateName: 'text' });

package/src/schemas/party.schema.ts

@@ -0,0 +1,65 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument, Schema as MongooseSchema, Types, model as MongooseModel } from 'mongoose';
+
+export type PartyDocument = HydratedDocument<Party>;
+
+@Schema({ _id: false })
+export class Address {
+  @Prop() zipcode: string;
+  @Prop() city: string;
+  @Prop() state: string;
+  @Prop() street: string;
+  @Prop() number: string;
+  @Prop() complement: string;
+}
+export const AddressSchema = SchemaFactory.createForClass(Address);
+
+@Schema({ _id: false })
+export class Company {
+  @Prop() legalName: string;
+  @Prop() document: string;
+  @Prop() bank: string;
+  @Prop() agency: string;
+  @Prop() account: string;
+  @Prop() digit: string;
+  @Prop() pix: string;
+  @Prop() email: string;
+  @Prop({ required: false }) omieGrapaId?: string;
+  @Prop({ required: false }) omieOmaId?: string;
+}
+export const CompanySchema = SchemaFactory.createForClass(Company);
+
+@Schema({ _id: false })
+export class Individual {
+  @Prop() rg: string;
+  @Prop() cpf: string;
+  @Prop() birthday: Date;
+  @Prop() maritalStatus: string;
+  @Prop() nationality: string;
+  @Prop() profession: string;
+}
+export const IndividualSchema = SchemaFactory.createForClass(Individual);
+
+@Schema({ timestamps: true })
+export class Party {
+  @Prop({ type: MongooseSchema.Types.ObjectId, auto: true, required: false })
+  _id?: Types.ObjectId;
+
+  @Prop() name: string;
+  @Prop({ required: false }) email?: string;
+  @Prop({ required: false }) phone?: string;
+  @Prop({ required: false }) picture?: string;
+  @Prop({ type: AddressSchema, required: false }) address?: Address;
+  @Prop({ type: CompanySchema, required: false }) company?: Company;
+  @Prop({ type: IndividualSchema, required: false }) individual?: Individual;
+  @Prop({ default: Date.now, required: false }) createdAt?: Date;
+  @Prop({ default: Date.now, required: false }) updatedAt?: Date;
+}
+export const PartySchema = SchemaFactory.createForClass(Party);
+
+PartySchema.index({ name: 1 });
+PartySchema.index({ 'company.document': 1 });
+PartySchema.index({ 'company.legalName': 1 });
+PartySchema.index({ createdAt: -1 });
+
+export const PartyModel = MongooseModel('Party', PartySchema);

package/src/schemas/supplier.schema.ts

@@ -1,11 +1,11 @@
 import { Schema, SchemaFactory } from '@nestjs/mongoose';
 import { HydratedDocument, model as MongooseModel } from 'mongoose';
-import { User } from './user.schema';
+import { Party } from './party.schema';
 
 export type SupplierDocument = HydratedDocument<Supplier>;
 
 @Schema({ timestamps: true })
-export class Supplier extends User {}
+export class Supplier extends Party {}
 
 export const SupplierSchema = SchemaFactory.createForClass(Supplier);
 export const SupplierModel = MongooseModel('Supplier', SupplierSchema);

package/src/schemas/task.schema.ts

@@ -52,16 +52,7 @@ export const TASK_STATUS_BY_TYPE: Record<TaskType, string[]> = {
   diagnosis: ['awaiting', 'pending', 'late', 'done', 'cancelled'],
 };
 
-export const TASK_STATUS_VALUES = [
-  'awaiting',
-  'pending',
-  'late',
-  'done',
-  'approval',
-  'rework',
-  'cancelled',
-] as const;
-export type TaskStatus = (typeof TASK_STATUS_VALUES)[number];
+export type TaskStatus = 'awaiting' | 'pending' | 'late' | 'done' | 'cancelled' | 'approval' | 'rework';
 
 @Schema({ timestamps: true })
 export class Task {
@@ -111,9 +102,18 @@ export class Task {
   @Prop({ type: String, enum: TASK_TYPE_VALUES, required: true })
   type: TaskType;
 
-  @ApiProperty({ enum: TASK_STATUS_VALUES, example: 'awaiting' })
-  @Prop({ type: String, enum: TASK_STATUS_VALUES, required: true })
-  status: TaskStatus;
+  @ApiProperty({ example: 'awaiting' })
+  @Prop({
+    type: String,
+    required: true,
+    validate: {
+      validator: function (this: Task, value: string) {
+        return TASK_STATUS_BY_TYPE[this.type]?.includes(value) ?? false;
+      },
+      message: 'status inválido para o type da task',
+    },
+  })
+  status: string;
 
   @ApiProperty({ example: 'https://drive.google.com/...', required: false })
   @Prop({ type: String, required: false })

package/src/schemas/user.schema.ts

@@ -1,130 +1,54 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
-import { HydratedDocument, Schema as MongooseSchema, Types, model as MongooseModel } from 'mongoose';
+import { HydratedDocument, Types } from 'mongoose';
 
 export type UserDocument = HydratedDocument<User>;
 
-@Schema({ _id: false })
-export class Address {
-  @Prop()
-  zipcode: string;
-
-  @Prop()
-  city: string;
-
-  @Prop()
-  state: string;
-
-  @Prop()
-  street: string;
-
-  @Prop()
-  number: string;
-
-  @Prop()
-  complement: string;
-}
-
-export const AddressSchema = SchemaFactory.createForClass(Address);
-
-@Schema({ _id: false })
-export class Company {
-  @Prop()
-  legalName: string;
-
-  @Prop()
-  document: string;
-
-  @Prop()
-  bank: string;
-
-  @Prop()
-  agency: string;
-
-  @Prop()
-  account: string;
-
-  @Prop()
-  digit: string;
-
-  @Prop()
-  pix: string;
-
-  @Prop()
-  email: string;
-
-  @Prop({ required: false })
-  omieGrapaId?: string;
-
-  @Prop({ required: false })
-  omieOmaId?: string;
-
-  
+export enum OrganizationTeam {
+  SERVICE = 'service',
+  ADMIN = 'admin',
+  ARTISTIC = 'artistic',
+  FINANCIAL = 'financial',
+  COMERCIAL = 'comercial',
 }
 
-export const CompanySchema = SchemaFactory.createForClass(Company);
-
-@Schema({ _id: false })
-export class Individual {
-  @Prop()
-  rg: string;
-
-  @Prop()
-  cpf: string;
-
-  @Prop()
-  birthday: Date;
-
-  @Prop()
-  maritalStatus: string;
-
-  @Prop()
-  nationality: string;
-
-  @Prop()
-  profession: string;
+export enum UserRole {
+  ADMIN = 'admin',
+  USER = 'user',
+  CLIENT = 'client',
+  INFLUENCER = 'influencer',
 }
 
-export const IndividualSchema = SchemaFactory.createForClass(Individual);
-
-@Schema({ timestamps: true })
+@Schema({ timestamps: true, collection: 'user' })
 export class User {
-  @Prop({ type: MongooseSchema.Types.ObjectId, auto: true, required: false })
-  _id?: Types.ObjectId;
+  @Prop({ type: Types.ObjectId, ref: 'Organization', required: true, index: true })
+  organization: Types.ObjectId;
 
-  @Prop()
-  name: string;
+  @Prop({ required: true, trim: true, lowercase: true, index: true })
+  email: string;
 
-  @Prop({ required: false })
-  email?: string;
+  @Prop({ required: true, trim: true })
+  name: string;
 
-  @Prop({ required: false })
-  phone?: string;
+  @Prop({ required: true, trim: true })
+  username: string;
 
-  @Prop({ required: false })
-  picture?: string;
+  @Prop({ enum: OrganizationTeam })
+  team?: OrganizationTeam;
 
-  @Prop({ type: AddressSchema, required: false })
-  address?: Address;
+  @Prop({ enum: UserRole })
+  role?: UserRole;
 
-  @Prop({ type: CompanySchema, required: false })
-  company?: Company;
+  @Prop({ trim: true })
+  firebaseUid?: string;
 
-  @Prop({ type: IndividualSchema, required: false })
-  individual?: Individual;
+  @Prop({ default: false })
+  disabled?: boolean;
 
-  @Prop({ default: Date.now, required: false })
   createdAt?: Date;
-
-  @Prop({ default: Date.now, required: false })
   updatedAt?: Date;
 }
 
 export const UserSchema = SchemaFactory.createForClass(User);
 
-UserSchema.index({ name: 1 });
-UserSchema.index({ 'company.document': 1 });
-UserSchema.index({ 'company.legalName': 1 });
-UserSchema.index({ createdAt: -1 });
-
-export const UserModel = MongooseModel('User', UserSchema);
-
+UserSchema.index({ organization: 1, email: 1 }, { unique: true });
+UserSchema.index({ organization: 1, username: 1 }, { unique: true });