@grapadigital/shared-schemas 1.0.75 → 1.0.77

package/dist/index.d.ts

@@ -5,7 +5,6 @@ export * from './schemas/influencer.schema';
 export * from './schemas/supplier.schema';
 export * from './schemas/campaign.schema';
 export * from './schemas/payment.schema';
-export * from './schemas/payment_new.schema';
 export * from './schemas/profile.schema';
 export * from './schemas/recruitment.schema';
 export * from './schemas/token.schema';

package/dist/index.js

@@ -21,7 +21,6 @@ __exportStar(require("./schemas/influencer.schema"), exports);
 __exportStar(require("./schemas/supplier.schema"), exports);
 __exportStar(require("./schemas/campaign.schema"), exports);
 __exportStar(require("./schemas/payment.schema"), exports);
-__exportStar(require("./schemas/payment_new.schema"), exports);
 __exportStar(require("./schemas/profile.schema"), exports);
 __exportStar(require("./schemas/recruitment.schema"), exports);
 __exportStar(require("./schemas/token.schema"), exports);

package/dist/schemas/invoice.schema.d.ts

@@ -27,9 +27,7 @@ import { HydratedDocument, Schema as MongooseSchema, Types } from 'mongoose';
 import { Sale } from './sale.schema';
 export type InvoiceDocument = HydratedDocument<Invoice>;
 declare class Inbox {
-    acceptanceDocument: string;
     invoiceDescription: string;
-    approvalDocument: string;
     invoiceEmail: string;
     emissionNotes: string;
     estimatedInvoiceIssueDate: Date;

package/dist/schemas/invoice.schema.js

@@ -14,18 +14,10 @@ const mongoose_1 = require("@nestjs/mongoose");
 const mongoose_2 = require("mongoose");
 let Inbox = class Inbox {
 };
-__decorate([
-    (0, mongoose_1.Prop)({ required: true }),
-    __metadata("design:type", String)
-], Inbox.prototype, "acceptanceDocument", void 0);
 __decorate([
     (0, mongoose_1.Prop)({ required: true }),
     __metadata("design:type", String)
 ], Inbox.prototype, "invoiceDescription", void 0);
-__decorate([
-    (0, mongoose_1.Prop)({ required: true }),
-    __metadata("design:type", String)
-], Inbox.prototype, "approvalDocument", void 0);
 __decorate([
     (0, mongoose_1.Prop)({ required: true }),
     __metadata("design:type", String)

package/dist/schemas/payment.schema.d.ts

@@ -25,70 +25,141 @@
 /// <reference types="mongoose/types/inferrawdoctype" />
 import { HydratedDocument, Schema as MongooseSchema, Types } from 'mongoose';
 import { Influencer } from './influencer.schema';
+import { Supplier } from './supplier.schema';
 import { Action } from './action.schema';
 import { Recruitment } from './recruitment.schema';
+import { Sale } from './sale.schema';
 export type PaymentDocument = HydratedDocument<Payment>;
-export declare class Requester {
+declare class Requester {
     name: string;
     email: string;
     team: string;
 }
-export declare const RequesterSchema: MongooseSchema<Requester, import("mongoose").Model<Requester, any, any, any, import("mongoose").Document<unknown, any, Requester> & Requester & {
+export declare class Review {
+    emissionNotes: string;
+    revisedDueDate: Date;
+    revisedIssueDate: Date;
+}
+export declare const ReviewSchema: MongooseSchema<Review, import("mongoose").Model<Review, any, any, any, import("mongoose").Document<unknown, any, Review> & Review & {
     _id: Types.ObjectId;
 } & {
     __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Requester, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Requester>> & import("mongoose").FlatRecord<Requester> & {
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Review, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Review>> & import("mongoose").FlatRecord<Review> & {
     _id: Types.ObjectId;
 } & {
     __v: number;
 }>;
-export declare class PipefyCard {
-    id: string;
-    title: string;
+export declare class Pending {
+    requester: Requester;
+    type: 'influencer' | 'advisor' | 'supplier' | 'employee' | 'refund';
+    influencer?: Types.ObjectId | Influencer;
+    supplier?: Types.ObjectId | Supplier;
+    recruitment?: Types.ObjectId | Recruitment;
+    value: number;
+    description: string;
+    installmentNumber: number;
+    sale: Types.ObjectId | Sale;
+    action: Types.ObjectId | Action;
 }
-export declare const PipefyCardSchema: MongooseSchema<PipefyCard, import("mongoose").Model<PipefyCard, any, any, any, import("mongoose").Document<unknown, any, PipefyCard> & PipefyCard & {
+export declare const PendingSchema: MongooseSchema<Pending, import("mongoose").Model<Pending, any, any, any, import("mongoose").Document<unknown, any, Pending> & Pending & {
     _id: Types.ObjectId;
 } & {
     __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, PipefyCard, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<PipefyCard>> & import("mongoose").FlatRecord<PipefyCard> & {
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Pending, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Pending>> & import("mongoose").FlatRecord<Pending> & {
     _id: Types.ObjectId;
 } & {
     __v: number;
 }>;
-export declare class PendingChanges {
+export declare class Approval {
+    name: string;
+    approvedAt: Date;
+}
+export declare const ApprovalSchema: MongooseSchema<Approval, import("mongoose").Model<Approval, any, any, any, import("mongoose").Document<unknown, any, Approval> & Approval & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Approval, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Approval>> & import("mongoose").FlatRecord<Approval> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Requested {
+    date: Date;
+}
+export declare const RequestedSchema: MongooseSchema<Requested, import("mongoose").Model<Requested, any, any, any, import("mongoose").Document<unknown, any, Requested> & Requested & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Requested, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Requested>> & import("mongoose").FlatRecord<Requested> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Queued {
+    issueDate: Date;
     dueDate: Date;
-    status: 'pending' | 'approved' | 'denied';
+    code: string;
+}
+export declare const QueuedSchema: MongooseSchema<Queued, import("mongoose").Model<Queued, any, any, any, import("mongoose").Document<unknown, any, Queued> & Queued & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Queued, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Queued>> & import("mongoose").FlatRecord<Queued> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Paid {
+    date: Date;
+}
+export declare const PaidSchema: MongooseSchema<Paid, import("mongoose").Model<Paid, any, any, any, import("mongoose").Document<unknown, any, Paid> & Paid & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Paid, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Paid>> & import("mongoose").FlatRecord<Paid> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Canceled {
     reason: string;
+    notes: string;
 }
-export declare const PendingChangesSchema: MongooseSchema<PendingChanges, import("mongoose").Model<PendingChanges, any, any, any, import("mongoose").Document<unknown, any, PendingChanges> & PendingChanges & {
+export declare const CanceledSchema: MongooseSchema<Canceled, import("mongoose").Model<Canceled, any, any, any, import("mongoose").Document<unknown, any, Canceled> & Canceled & {
     _id: Types.ObjectId;
 } & {
     __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, PendingChanges, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<PendingChanges>> & import("mongoose").FlatRecord<PendingChanges> & {
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Canceled, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Canceled>> & import("mongoose").FlatRecord<Canceled> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Note {
+    text: string;
+    owner: string;
+    createdAt: Date;
+}
+export declare const NoteSchema: MongooseSchema<Note, import("mongoose").Model<Note, any, any, any, import("mongoose").Document<unknown, any, Note> & Note & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Note, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Note>> & import("mongoose").FlatRecord<Note> & {
     _id: Types.ObjectId;
 } & {
     __v: number;
 }>;
 export declare class Payment {
     _id?: Types.ObjectId;
-    requester?: Requester;
-    value: number;
-    installmentNumber: number;
-    dueDate?: Date | null;
-    invoiceIssueDate?: Date | null;
-    invoiceDueDate?: Date | null;
-    paymentDate?: Date | null;
-    financialCard?: PipefyCard;
-    pendingChanges?: PendingChanges;
-    additionalComments?: string;
-    googleSheetRow?: string;
-    status: 'pending' | 'review' | 'processing' | 'failed' | 'completed';
-    type: 'influencer' | 'advisor' | 'provider';
-    influencer: Types.ObjectId | Influencer;
-    action: Types.ObjectId | Action;
-    recruitment: Types.ObjectId | Recruitment;
-    createdAt?: Date;
-    updatedAt?: Date;
+    title: string;
+    phase: 'pending' | 'review' | 'approval' | 'awaiting' | 'requested' | 'queued' | 'paid' | 'client' | 'canceled';
+    pending?: Pending;
+    review?: Review;
+    approval?: Approval;
+    requested?: Requested;
+    queued?: Queued;
+    paid?: Paid;
+    canceled?: Canceled;
+    notes?: Note[];
 }
 export declare const PaymentSchema: MongooseSchema<Payment, import("mongoose").Model<Payment, any, any, any, import("mongoose").Document<unknown, any, Payment> & Payment & Required<{
     _id: Types.ObjectId;
@@ -112,3 +183,4 @@ export declare const PaymentModel: import("mongoose").Model<Payment, {}, {}, {},
 }> & {
     __v: number;
 }>>;
+export {};

package/dist/schemas/payment.schema.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaymentModel = exports.PaymentSchema = exports.Payment = exports.PendingChangesSchema = exports.PendingChanges = exports.PipefyCardSchema = exports.PipefyCard = exports.RequesterSchema = exports.Requester = void 0;
+exports.PaymentModel = exports.PaymentSchema = exports.Payment = exports.NoteSchema = exports.Note = exports.CanceledSchema = exports.Canceled = exports.PaidSchema = exports.Paid = exports.QueuedSchema = exports.Queued = exports.RequestedSchema = exports.Requested = exports.ApprovalSchema = exports.Approval = exports.PendingSchema = exports.Pending = exports.ReviewSchema = exports.Review = void 0;
 const mongoose_1 = require("@nestjs/mongoose");
 const mongoose_2 = require("mongoose");
 let Requester = class Requester {
@@ -29,123 +29,212 @@ __decorate([
 Requester = __decorate([
     (0, mongoose_1.Schema)({ _id: false })
 ], Requester);
-exports.Requester = Requester;
-exports.RequesterSchema = mongoose_1.SchemaFactory.createForClass(Requester);
-let PipefyCard = class PipefyCard {
+const RequesterSchema = mongoose_1.SchemaFactory.createForClass(Requester);
+let Review = class Review {
 };
 __decorate([
     (0, mongoose_1.Prop)(),
     __metadata("design:type", String)
-], PipefyCard.prototype, "id", void 0);
+], Review.prototype, "emissionNotes", void 0);
 __decorate([
     (0, mongoose_1.Prop)(),
-    __metadata("design:type", String)
-], PipefyCard.prototype, "title", void 0);
-PipefyCard = __decorate([
-    (0, mongoose_1.Schema)({ _id: false })
-], PipefyCard);
-exports.PipefyCard = PipefyCard;
-exports.PipefyCardSchema = mongoose_1.SchemaFactory.createForClass(PipefyCard);
-let PendingChanges = class PendingChanges {
-};
+    __metadata("design:type", Date)
+], Review.prototype, "revisedDueDate", void 0);
 __decorate([
     (0, mongoose_1.Prop)(),
     __metadata("design:type", Date)
-], PendingChanges.prototype, "dueDate", void 0);
+], Review.prototype, "revisedIssueDate", void 0);
+Review = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Review);
+exports.Review = Review;
+exports.ReviewSchema = mongoose_1.SchemaFactory.createForClass(Review);
+let Pending = class Pending {
+};
 __decorate([
-    (0, mongoose_1.Prop)({ type: String, enum: ['pending', 'approved', 'denied'] }),
-    __metadata("design:type", String)
-], PendingChanges.prototype, "status", void 0);
+    (0, mongoose_1.Prop)({ type: RequesterSchema, required: true }),
+    __metadata("design:type", Requester)
+], Pending.prototype, "requester", void 0);
 __decorate([
-    (0, mongoose_1.Prop)(),
+    (0, mongoose_1.Prop)({ type: String, enum: ['influencer', 'advisor', 'supplier', 'employee', 'refund'] }),
     __metadata("design:type", String)
-], PendingChanges.prototype, "reason", void 0);
-PendingChanges = __decorate([
-    (0, mongoose_1.Schema)({ _id: false })
-], PendingChanges);
-exports.PendingChanges = PendingChanges;
-exports.PendingChangesSchema = mongoose_1.SchemaFactory.createForClass(PendingChanges);
-let Payment = class Payment {
-};
+], Pending.prototype, "type", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, auto: true, required: false }),
-    __metadata("design:type", mongoose_2.Types.ObjectId)
-], Payment.prototype, "_id", void 0);
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Influencer' }),
+    __metadata("design:type", Object)
+], Pending.prototype, "influencer", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ type: exports.RequesterSchema, required: false }),
-    __metadata("design:type", Requester)
-], Payment.prototype, "requester", void 0);
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Supplier' }),
+    __metadata("design:type", Object)
+], Pending.prototype, "supplier", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Recruitment' }),
+    __metadata("design:type", Object)
+], Pending.prototype, "recruitment", void 0);
 __decorate([
     (0, mongoose_1.Prop)(),
     __metadata("design:type", Number)
-], Payment.prototype, "value", void 0);
+], Pending.prototype, "value", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Pending.prototype, "description", void 0);
 __decorate([
     (0, mongoose_1.Prop)(),
     __metadata("design:type", Number)
-], Payment.prototype, "installmentNumber", void 0);
+], Pending.prototype, "installmentNumber", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ type: Date, default: null, required: false }),
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Sale' }),
     __metadata("design:type", Object)
-], Payment.prototype, "dueDate", void 0);
+], Pending.prototype, "sale", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ type: Date, default: null, required: false }),
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Action' }),
     __metadata("design:type", Object)
-], Payment.prototype, "invoiceIssueDate", void 0);
+], Pending.prototype, "action", void 0);
+Pending = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Pending);
+exports.Pending = Pending;
+exports.PendingSchema = mongoose_1.SchemaFactory.createForClass(Pending);
+let Approval = class Approval {
+};
 __decorate([
-    (0, mongoose_1.Prop)({ type: Date, default: null, required: false }),
-    __metadata("design:type", Object)
-], Payment.prototype, "invoiceDueDate", void 0);
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Approval.prototype, "name", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ type: Date, default: null, required: false }),
-    __metadata("design:type", Object)
-], Payment.prototype, "paymentDate", void 0);
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Approval.prototype, "approvedAt", void 0);
+Approval = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Approval);
+exports.Approval = Approval;
+exports.ApprovalSchema = mongoose_1.SchemaFactory.createForClass(Approval);
+let Requested = class Requested {
+};
 __decorate([
-    (0, mongoose_1.Prop)({ type: exports.PipefyCardSchema, required: false }),
-    __metadata("design:type", PipefyCard)
-], Payment.prototype, "financialCard", void 0);
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Requested.prototype, "date", void 0);
+Requested = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Requested);
+exports.Requested = Requested;
+exports.RequestedSchema = mongoose_1.SchemaFactory.createForClass(Requested);
+let Queued = class Queued {
+};
 __decorate([
-    (0, mongoose_1.Prop)({ type: exports.PendingChangesSchema, required: false }),
-    __metadata("design:type", PendingChanges)
-], Payment.prototype, "pendingChanges", void 0);
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Queued.prototype, "issueDate", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Queued.prototype, "dueDate", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ required: false }),
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Queued.prototype, "code", void 0);
+Queued = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Queued);
+exports.Queued = Queued;
+exports.QueuedSchema = mongoose_1.SchemaFactory.createForClass(Queued);
+let Paid = class Paid {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Paid.prototype, "date", void 0);
+Paid = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Paid);
+exports.Paid = Paid;
+exports.PaidSchema = mongoose_1.SchemaFactory.createForClass(Paid);
+let Canceled = class Canceled {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
     __metadata("design:type", String)
-], Payment.prototype, "additionalComments", void 0);
+], Canceled.prototype, "reason", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ required: false }),
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Canceled.prototype, "notes", void 0);
+Canceled = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Canceled);
+exports.Canceled = Canceled;
+exports.CanceledSchema = mongoose_1.SchemaFactory.createForClass(Canceled);
+let Note = class Note {
+};
+__decorate([
+    (0, mongoose_1.Prop)(),
     __metadata("design:type", String)
-], Payment.prototype, "googleSheetRow", void 0);
+], Note.prototype, "text", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Note.prototype, "owner", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], Note.prototype, "createdAt", void 0);
+Note = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], Note);
+exports.Note = Note;
+exports.NoteSchema = mongoose_1.SchemaFactory.createForClass(Note);
+let Payment = class Payment {
+};
+__decorate([
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, auto: true }),
+    __metadata("design:type", mongoose_2.Types.ObjectId)
+], Payment.prototype, "_id", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], Payment.prototype, "title", void 0);
 __decorate([
     (0, mongoose_1.Prop)({
         type: String,
-        enum: ['pending', 'review', 'processing', 'failed', 'completed'],
+        enum: ['pending', 'review', 'approval', 'awaiting', 'requested', 'queued', 'paid', 'client', 'canceled'],
     }),
     __metadata("design:type", String)
-], Payment.prototype, "status", void 0);
+], Payment.prototype, "phase", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ type: String, enum: ['influencer', 'advisor', 'provider'] }),
-    __metadata("design:type", String)
-], Payment.prototype, "type", void 0);
+    (0, mongoose_1.Prop)({ type: exports.PendingSchema, required: false }),
+    __metadata("design:type", Pending)
+], Payment.prototype, "pending", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Influencer' }),
-    __metadata("design:type", Object)
-], Payment.prototype, "influencer", void 0);
+    (0, mongoose_1.Prop)({ type: exports.ReviewSchema, required: false }),
+    __metadata("design:type", Review)
+], Payment.prototype, "review", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Action' }),
-    __metadata("design:type", Object)
-], Payment.prototype, "action", void 0);
+    (0, mongoose_1.Prop)({ type: exports.ApprovalSchema, required: false }),
+    __metadata("design:type", Approval)
+], Payment.prototype, "approval", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Recruitment' }),
-    __metadata("design:type", Object)
-], Payment.prototype, "recruitment", void 0);
+    (0, mongoose_1.Prop)({ type: exports.RequestedSchema, required: false }),
+    __metadata("design:type", Requested)
+], Payment.prototype, "requested", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ default: Date.now, required: false }),
-    __metadata("design:type", Date)
-], Payment.prototype, "createdAt", void 0);
+    (0, mongoose_1.Prop)({ type: exports.QueuedSchema, required: false }),
+    __metadata("design:type", Queued)
+], Payment.prototype, "queued", void 0);
 __decorate([
-    (0, mongoose_1.Prop)({ default: Date.now, required: false }),
-    __metadata("design:type", Date)
-], Payment.prototype, "updatedAt", void 0);
+    (0, mongoose_1.Prop)({ type: exports.PaidSchema, required: false }),
+    __metadata("design:type", Paid)
+], Payment.prototype, "paid", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: exports.CanceledSchema, required: false }),
+    __metadata("design:type", Canceled)
+], Payment.prototype, "canceled", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: [exports.NoteSchema], default: [] }),
+    __metadata("design:type", Array)
+], Payment.prototype, "notes", void 0);
 Payment = __decorate([
     (0, mongoose_1.Schema)({ timestamps: true })
 ], Payment);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grapadigital/shared-schemas",
-  "version": "1.0.75",
+  "version": "1.0.77",
   "description": "Shared Mongoose Schemas",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -5,7 +5,6 @@ export * from './schemas/influencer.schema';
 export * from './schemas/supplier.schema';
 export * from './schemas/campaign.schema';
 export * from './schemas/payment.schema';
-export * from './schemas/payment_new.schema';
 export * from './schemas/profile.schema';
 export * from './schemas/recruitment.schema';
 export * from './schemas/token.schema';

package/src/schemas/invoice.schema.ts

@@ -6,12 +6,8 @@ export type InvoiceDocument = HydratedDocument<Invoice>;
 
 @Schema({ _id: false })
 class Inbox {
-  @Prop({ required: true }) acceptanceDocument: string;
-
   @Prop({ required: true }) invoiceDescription: string;
 
-  @Prop({ required: true }) approvalDocument: string;
-
   @Prop({ required: true }) invoiceEmail: string;
 
   @Prop({ required: true }) emissionNotes: string;

package/src/schemas/payment.schema.ts

@@ -1,113 +1,134 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
 import { HydratedDocument, Schema as MongooseSchema, Types, model as MongooseModel } from 'mongoose';
 import { Influencer } from './influencer.schema';
+import { Supplier } from './supplier.schema';
 import { Action } from './action.schema';
 import { Recruitment } from './recruitment.schema';
+import { Sale } from './sale.schema';
 
 export type PaymentDocument = HydratedDocument<Payment>;
-@Schema({ _id: false })
-export class Requester {
-  @Prop()
-  name: string;
-
-  @Prop()
-  email: string;
 
-  @Prop()
-  team: string;
+@Schema({ _id: false })
+class Requester {
+  @Prop() name: string;
+  @Prop() email: string;
+  @Prop() team: string;
 }
-
-export const RequesterSchema = SchemaFactory.createForClass(Requester);
+const RequesterSchema = SchemaFactory.createForClass(Requester);
 
 @Schema({ _id: false })
-export class PipefyCard {
-  @Prop()
-  id: string;
-
-  @Prop()
-  title: string;
+export class Review {
+  @Prop() emissionNotes: string;
+  @Prop() revisedDueDate: Date;
+  @Prop() revisedIssueDate: Date;
 }
-
-export const PipefyCardSchema = SchemaFactory.createForClass(PipefyCard);
+export const ReviewSchema = SchemaFactory.createForClass(Review);
 
 @Schema({ _id: false })
-export class PendingChanges {
-  @Prop()
-  dueDate: Date;
+export class Pending {
+  @Prop({ type: RequesterSchema, required: true })
+  requester: Requester;
 
-  @Prop({ type: String, enum: ['pending', 'approved', 'denied'] })
-  status: 'pending' | 'approved' | 'denied';
+  @Prop({ type: String, enum: ['influencer', 'advisor', 'supplier', 'employee', 'refund'] })
+  type: 'influencer' | 'advisor' | 'supplier' | 'employee' | 'refund';
 
-  @Prop()
-  reason: string;
-}
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Influencer'})
+  influencer?: Types.ObjectId | Influencer;
 
-export const PendingChangesSchema =
-  SchemaFactory.createForClass(PendingChanges);
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Supplier'})
+  supplier?: Types.ObjectId | Supplier;
 
-@Schema({ timestamps: true })
-export class Payment {
-  @Prop({ type: MongooseSchema.Types.ObjectId, auto: true, required: false })
-  _id?: Types.ObjectId;
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Recruitment' })
+  recruitment?: Types.ObjectId | Recruitment;
 
-  @Prop({ type: RequesterSchema, required: false })
-  requester?: Requester;
+  @Prop() value: number;
+  @Prop() description: string;
 
-  @Prop()
-  value: number;
+  @Prop() installmentNumber: number;
 
-  @Prop()
-  installmentNumber: number;
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Sale' })
+  sale: Types.ObjectId | Sale;
+
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Action' })
+  action: Types.ObjectId | Action;
+}
+export const PendingSchema = SchemaFactory.createForClass(Pending);
 
-  @Prop({ type: Date, default: null, required: false })
-  dueDate?: Date | null;
+@Schema({ _id: false })
+export class Approval {
+  @Prop() name: string;
+  @Prop() approvedAt: Date;
+}
+export const ApprovalSchema = SchemaFactory.createForClass(Approval);
 
-  @Prop({ type: Date, default: null, required: false })
-  invoiceIssueDate?: Date | null;
+@Schema({ _id: false })
+export class Requested { @Prop() date: Date; }
+export const RequestedSchema = SchemaFactory.createForClass(Requested);
 
-  @Prop({ type: Date, default: null, required: false })
-  invoiceDueDate?: Date | null;
+@Schema({ _id: false })
+export class Queued {
+  @Prop() issueDate: Date;
+  @Prop() dueDate: Date;
+  @Prop() code: string;
+}
+export const QueuedSchema = SchemaFactory.createForClass(Queued);
 
-  @Prop({ type: Date, default: null, required: false })
-  paymentDate?: Date | null;
+@Schema({ _id: false })
+export class Paid { @Prop() date: Date; }
+export const PaidSchema = SchemaFactory.createForClass(Paid);
 
-  @Prop({ type: PipefyCardSchema, required: false })
-  financialCard?: PipefyCard;
+@Schema({ _id: false })
+export class Canceled {
+  @Prop() reason: string;
+  @Prop() notes: string;
+}
+export const CanceledSchema = SchemaFactory.createForClass(Canceled);
 
-  @Prop({ type: PendingChangesSchema, required: false })
-  pendingChanges?: PendingChanges;
+@Schema({ _id: false })
+export class Note {
+  @Prop() text: string;
+  @Prop() owner: string;
+  @Prop() createdAt: Date;
+}
+export const NoteSchema = SchemaFactory.createForClass(Note);
 
-  @Prop({ required: false })
-  additionalComments?: string;
+@Schema({ timestamps: true })
+export class Payment {
+  @Prop({ type: MongooseSchema.Types.ObjectId, auto: true })
+  _id?: Types.ObjectId;
 
-  @Prop({ required: false })
-  googleSheetRow?: string;
+  @Prop() title: string;
 
   @Prop({
     type: String,
-    enum: ['pending', 'review', 'processing', 'failed', 'completed'],
+    enum: [ 'pending', 'review', 'approval', 'awaiting', 'requested', 'queued', 'paid', 'client', 'canceled'],
   })
-  status: 'pending' | 'review' | 'processing' | 'failed' | 'completed';
+  phase: 'pending' | 'review' | 'approval' | 'awaiting' | 'requested' | 'queued' | 'paid' | 'client' | 'canceled';
 
-  @Prop({ type: String, enum: ['influencer', 'advisor', 'provider'] })
-  type: 'influencer' | 'advisor' | 'provider';
+  @Prop({ type: PendingSchema, required: false })
+  pending?: Pending;
 
-  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Influencer' })
-  influencer: Types.ObjectId | Influencer;
+  @Prop({ type: ReviewSchema, required: false })
+  review?: Review;
 
-  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Action' })
-  action: Types.ObjectId | Action;
+  @Prop({ type: ApprovalSchema, required: false })
+  approval?: Approval;
 
-  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Recruitment' })
-  recruitment: Types.ObjectId | Recruitment;
+  @Prop({ type: RequestedSchema, required: false })
+  requested?: Requested;
+
+  @Prop({ type: QueuedSchema, required: false })
+  queued?: Queued;
 
-  @Prop({ default: Date.now, required: false })
-  createdAt?: Date;
+  @Prop({ type: PaidSchema, required: false })
+  paid?: Paid;
 
-  @Prop({ default: Date.now, required: false })
-  updatedAt?: Date;
+  @Prop({ type: CanceledSchema, required: false })
+  canceled?: Canceled;
+
+  @Prop({ type: [NoteSchema], default: [] })
+  notes?: Note[];
 }
 
 export const PaymentSchema = SchemaFactory.createForClass(Payment);
 export const PaymentModel = MongooseModel('Payment', PaymentSchema);
-

package/src/schemas/payment_new.schema.ts

@@ -1,134 +0,0 @@
-import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
-import { HydratedDocument, Schema as MongooseSchema, Types, model as MongooseModel } from 'mongoose';
-import { Influencer } from './influencer.schema';
-import { Supplier } from './supplier.schema';
-import { Action } from './action.schema';
-import { Recruitment } from './recruitment.schema';
-import { Sale } from './sale.schema';
-
-export type PaymentNewDocument = HydratedDocument<PaymentNew>;
-
-@Schema({ _id: false })
-class Requester {
-  @Prop() name: string;
-  @Prop() email: string;
-  @Prop() team: string;
-}
-const RequesterSchema = SchemaFactory.createForClass(Requester);
-
-@Schema({ _id: false })
-export class Processing {
-  @Prop() emissionNotes: string;
-  @Prop() revisedDueDate: Date;
-  @Prop() revisedIssueDate: Date;
-}
-export const ProcessingSchema = SchemaFactory.createForClass(Processing);
-
-@Schema({ _id: false })
-export class Pending {
-  @Prop({ type: RequesterSchema, required: true })
-  requester: Requester;
-
-  @Prop({ type: String, enum: ['influencer', 'advisor', 'supplier', 'employee', 'refund'] })
-  type: 'influencer' | 'advisor' | 'supplier' | 'employee' | 'refund';
-
-  @Prop({ type: MongooseSchema.Types.ObjectId })
-  influencer?: Types.ObjectId | Influencer;
-
-  @Prop({ type: MongooseSchema.Types.ObjectId })
-  supplier?: Types.ObjectId | Supplier;
-
-  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Recruitment' })
-  recruitment?: Types.ObjectId | Recruitment;
-
-  @Prop() value: number;
-  @Prop() description: string;
-
-  @Prop() installmentNumber: number;
-
-  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Sale' })
-  sale: Types.ObjectId | Sale;
-
-  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Action' })
-  action: Types.ObjectId | Action;
-}
-export const PendingSchema = SchemaFactory.createForClass(Pending);
-
-@Schema({ _id: false })
-export class Approval {
-  @Prop() name: string;
-  @Prop() approvedAt: Date;
-}
-export const ApprovalSchema = SchemaFactory.createForClass(Approval);
-
-@Schema({ _id: false })
-export class Requested { @Prop() date: Date; }
-export const RequestedSchema = SchemaFactory.createForClass(Requested);
-
-@Schema({ _id: false })
-export class Queued {
-  @Prop() issueDate: Date;
-  @Prop() dueDate: Date;
-  @Prop() code: string;
-}
-export const QueuedSchema = SchemaFactory.createForClass(Queued);
-
-@Schema({ _id: false })
-export class Paid { @Prop() date: Date; }
-export const PaidSchema = SchemaFactory.createForClass(Paid);
-
-@Schema({ _id: false })
-export class Canceled {
-  @Prop() reason: string;
-  @Prop() notes: string;
-}
-export const CanceledSchema = SchemaFactory.createForClass(Canceled);
-
-@Schema({ _id: false })
-export class Note {
-  @Prop() text: string;
-  @Prop() owner: string;
-  @Prop() createdAt: Date;
-}
-export const NoteSchema = SchemaFactory.createForClass(Note);
-
-@Schema({ timestamps: true })
-export class PaymentNew {
-  @Prop({ type: MongooseSchema.Types.ObjectId, auto: true })
-  _id?: Types.ObjectId;
-
-  @Prop() title: string;
-
-  @Prop({
-    type: String,
-    enum: [ 'pending', 'review', 'approval', 'awaiting', 'requested', 'queued', 'paid', 'client', 'canceled'],
-  })
-  phase: 'pending' | 'review' | 'approval' | 'awaiting' | 'requested' | 'queued' | 'paid' | 'client' | 'canceled';
-
-  @Prop({ type: PendingSchema, required: false })
-  pending?: Pending;
-
-  @Prop({ type: ProcessingSchema, required: false })
-  processing?: Processing;
-
-  @Prop({ type: ApprovalSchema, required: false })
-  approval?: Approval;
-
-  @Prop({ type: RequestedSchema, required: false })
-  requested?: Requested;
-
-  @Prop({ type: QueuedSchema, required: false })
-  queued?: Queued;
-
-  @Prop({ type: PaidSchema, required: false })
-  paid?: Paid;
-
-  @Prop({ type: CanceledSchema, required: false })
-  canceled?: Canceled;
-
-  @Prop({ type: [NoteSchema], default: [] })
-  notes?: Note[];
-}
-
-export const PaymentNewSchema = SchemaFactory.createForClass(PaymentNew);
-export const PaymentNewModel = MongooseModel('PaymentNew', PaymentNewSchema);