@grapadigital/shared-schemas 1.0.200 → 1.0.202

package/dist/schemas/sale.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.SaleModel = exports.SaleSchema = exports.Sale = exports.Inbox = exports.CommissionInfo = exports.CommissionParticipant = exports.TimelineEntry = exports.Activity = exports.Lost = exports.Formalization = exports.Negotiation = exports.Proposal = void 0;
+exports.SaleModel = exports.SaleSchema = exports.Sale = exports.SaleLinks = exports.SaleResponsables = exports.Inbox = exports.CommissionInfo = exports.CommissionParticipant = exports.TimelineEntry = exports.Activity = exports.Lost = exports.Formalization = exports.Negotiation = exports.Proposal = void 0;
 const mongoose_1 = require("@nestjs/mongoose");
 const mongoose_2 = require("mongoose");
 const note_schema_1 = require("./note.schema");
@@ -351,6 +351,54 @@ Inbox = __decorate([
     (0, mongoose_1.Schema)({ _id: false })
 ], Inbox);
 exports.Inbox = Inbox;
+let SaleResponsables = class SaleResponsables {
+};
+__decorate([
+    (0, mongoose_1.Prop)({
+        _id: false,
+        required: false,
+        type: {
+            team: String,
+            name: String,
+            email: String,
+        },
+    }),
+    __metadata("design:type", Object)
+], SaleResponsables.prototype, "curation", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({
+        _id: false,
+        required: false,
+        type: {
+            team: String,
+            name: String,
+            email: String,
+        },
+    }),
+    __metadata("design:type", Object)
+], SaleResponsables.prototype, "planning", void 0);
+SaleResponsables = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], SaleResponsables);
+exports.SaleResponsables = SaleResponsables;
+let SaleLinks = class SaleLinks {
+};
+__decorate([
+    (0, mongoose_1.Prop)({ required: false }),
+    __metadata("design:type", String)
+], SaleLinks.prototype, "contract", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ required: false }),
+    __metadata("design:type", String)
+], SaleLinks.prototype, "clientSheet", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ required: false }),
+    __metadata("design:type", String)
+], SaleLinks.prototype, "internalSheet", void 0);
+SaleLinks = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], SaleLinks);
+exports.SaleLinks = SaleLinks;
 let Sale = class Sale {
 };
 __decorate([
@@ -461,6 +509,14 @@ __decorate([
     (0, mongoose_1.Prop)({ type: String, required: false }),
     __metadata("design:type", String)
 ], Sale.prototype, "omieId", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: SaleResponsables, required: false }),
+    __metadata("design:type", SaleResponsables)
+], Sale.prototype, "responsables", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: SaleLinks, required: false }),
+    __metadata("design:type", SaleLinks)
+], Sale.prototype, "links", void 0);
 Sale = __decorate([
     (0, mongoose_1.Schema)({ timestamps: true })
 ], Sale);

package/package.json

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

package/src/index.ts

@@ -31,3 +31,5 @@ export { Note, NoteSchema, NoteMention, NoteMentionSchema } from './schemas/note
 export * from './schemas/content-capture-process.schema';
 export * from './schemas/content-draft.schema';
 export * from './schemas/export-comments-job.schema';
+export * from './schemas/profile-followers-snapshot.schema';
+export * from './schemas/lead.schema';

package/src/schemas/client.schema.ts

@@ -133,6 +133,9 @@ export class Client extends Party {
 
   @Prop({ type: ResponsableSchema, required: false })
   reportResponsable?: Responsable;
+
+  @Prop({ type: String, required: false })
+  brandResponsable?: string;
 }
 
 export const ClientSchema = SchemaFactory.createForClass(Client);

package/src/schemas/commission.schema.ts

@@ -78,6 +78,9 @@ export class Commission {
   @Prop({ type: String, required: false })
   description?: string;
 
+  @Prop({ type: String, required: false })
+  reason?: string;
+
   @Prop({ type: Date, default: Date.now, required: false })
   createdAt?: Date;
 

package/src/schemas/lead.schema.ts

@@ -0,0 +1,354 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument, Types, model as MongooseModel } from 'mongoose';
+
+// Lead = briefing de campanha preenchido pelo cliente numa página pública (GD-616).
+// O acesso público é sempre pelo accessToken, nunca pelo _id.
+
+export const LEAD_STATUS_VALUES = ['draft', 'submitted'] as const;
+export type LeadStatus = (typeof LEAD_STATUS_VALUES)[number];
+
+export const LEAD_PRESENTATION_FORMAT_VALUES = ['online', 'in_person', 'email_only'] as const;
+export type LeadPresentationFormat = (typeof LEAD_PRESENTATION_FORMAT_VALUES)[number];
+
+export const LEAD_PAYMENT_TERM_VALUES = [30, 60, 90, 120] as const;
+export type LeadPaymentTerm = (typeof LEAD_PAYMENT_TERM_VALUES)[number];
+
+export const LEAD_DELIVERABLE_VALUES = [
+  'content_strategy',
+  'ppt_presentation',
+  'curation_sheet',
+  'production_sheet',
+] as const;
+export type LeadDeliverable = (typeof LEAD_DELIVERABLE_VALUES)[number];
+
+export const LEAD_GOAL_VALUES = ['awareness', 'consideration', 'intent'] as const;
+export type LeadGoal = (typeof LEAD_GOAL_VALUES)[number];
+
+export const LEAD_CHANNEL_VALUES = ['online', 'offline'] as const;
+export type LeadChannel = (typeof LEAD_CHANNEL_VALUES)[number];
+
+export const LEAD_RIGHT_VALUES = [
+  'influencer_collab',
+  'brand_collab',
+  'client_boost',
+  'influencer_boost',
+  'segment_exclusivity',
+  'image_rights',
+  'dark_post',
+  'offline',
+] as const;
+export type LeadRight = (typeof LEAD_RIGHT_VALUES)[number];
+
+export const LEAD_FOLLOWER_TIER_VALUES = ['heroes', 'macros', 'medios', 'micros', 'nanos', 'nda'] as const;
+export type LeadFollowerTier = (typeof LEAD_FOLLOWER_TIER_VALUES)[number];
+
+export const LEAD_SECTION_KEYS = [
+  'general',
+  'confidentiality',
+  'budget',
+  'competition',
+  'deliverables',
+  'strategicContext',
+  'objectives',
+  'deliveryScope',
+  'audience',
+  'curation',
+  'logistics',
+  'contentGuidelines',
+] as const;
+export type LeadSectionKey = (typeof LEAD_SECTION_KEYS)[number];
+
+@Schema({ _id: false })
+export class LeadGeneral {
+  @Prop({ trim: true })
+  advertiser?: string;
+
+  @Prop({ trim: true })
+  brand?: string;
+
+  @Prop()
+  socialProfiles?: string;
+
+  @Prop({ trim: true })
+  campaignName?: string;
+
+  @Prop()
+  language?: string;
+
+  @Prop()
+  materialsUrl?: string;
+
+  @Prop()
+  presentationDate?: Date;
+
+  @Prop()
+  schedule?: string;
+
+  @Prop({ type: String, enum: LEAD_PRESENTATION_FORMAT_VALUES })
+  presentationFormat?: LeadPresentationFormat;
+
+  @Prop({ trim: true })
+  contactName?: string;
+
+  @Prop({ trim: true, lowercase: true })
+  contactEmail?: string;
+}
+export const LeadGeneralSchema = SchemaFactory.createForClass(LeadGeneral);
+
+@Schema({ _id: false })
+export class LeadConfidentiality {
+  @Prop()
+  hasRestriction?: boolean;
+
+  @Prop()
+  restrictionDetails?: string;
+}
+export const LeadConfidentialitySchema = SchemaFactory.createForClass(LeadConfidentiality);
+
+@Schema({ _id: false })
+export class LeadBudget {
+  @Prop()
+  totalBudget?: number;
+
+  @Prop()
+  creatorsBudget?: number;
+
+  @Prop({ type: Number, enum: LEAD_PAYMENT_TERM_VALUES })
+  paymentTerm?: LeadPaymentTerm;
+
+  @Prop()
+  campaignDurationMonths?: number;
+}
+export const LeadBudgetSchema = SchemaFactory.createForClass(LeadBudget);
+
+@Schema({ _id: false })
+export class LeadCompetition {
+  @Prop()
+  isCompetitive?: boolean;
+
+  @Prop()
+  involveAreaLeaders?: boolean;
+}
+export const LeadCompetitionSchema = SchemaFactory.createForClass(LeadCompetition);
+
+@Schema({ _id: false })
+export class LeadDeliverables {
+  @Prop({ type: [String], enum: LEAD_DELIVERABLE_VALUES, default: undefined })
+  types?: LeadDeliverable[];
+}
+export const LeadDeliverablesSchema = SchemaFactory.createForClass(LeadDeliverables);
+
+@Schema({ _id: false })
+export class LeadStrategicContext {
+  @Prop()
+  brandScenario?: string;
+
+  @Prop()
+  productInfo?: string;
+
+  @Prop()
+  parentCampaign?: string;
+
+  @Prop()
+  message?: string;
+
+  @Prop()
+  callToAction?: string;
+
+  @Prop()
+  highlights?: string;
+
+  @Prop()
+  centralChallenge?: string;
+
+  @Prop()
+  tone?: string;
+}
+export const LeadStrategicContextSchema = SchemaFactory.createForClass(LeadStrategicContext);
+
+@Schema({ _id: false })
+export class LeadObjectives {
+  @Prop({ type: [String], enum: LEAD_GOAL_VALUES, default: undefined })
+  goals?: LeadGoal[];
+
+  @Prop({ type: String, enum: LEAD_GOAL_VALUES })
+  primaryGoal?: LeadGoal;
+}
+export const LeadObjectivesSchema = SchemaFactory.createForClass(LeadObjectives);
+
+@Schema({ _id: false })
+export class LeadDeliveryScope {
+  @Prop({ type: [String], enum: LEAD_CHANNEL_VALUES, default: undefined })
+  channels?: LeadChannel[];
+
+  @Prop()
+  primaryNetworks?: string;
+
+  @Prop()
+  secondaryNetworks?: string;
+
+  @Prop()
+  contentPerNetwork?: string;
+
+  @Prop({ type: [String], enum: LEAD_RIGHT_VALUES, default: undefined })
+  rights?: LeadRight[];
+
+  @Prop()
+  imageRightsMonths?: number;
+
+  @Prop()
+  offlineFormats?: string;
+}
+export const LeadDeliveryScopeSchema = SchemaFactory.createForClass(LeadDeliveryScope);
+
+@Schema({ _id: false })
+export class LeadAudience {
+  @Prop()
+  ageRange?: string;
+
+  @Prop()
+  gender?: string;
+
+  @Prop()
+  region?: string;
+
+  @Prop()
+  attitudinalProfile?: string;
+}
+export const LeadAudienceSchema = SchemaFactory.createForClass(LeadAudience);
+
+@Schema({ _id: false })
+export class LeadCuration {
+  @Prop()
+  influencerProfile?: string;
+
+  @Prop()
+  referenceNames?: string;
+
+  @Prop()
+  namesToAvoid?: string;
+
+  @Prop()
+  approveCount?: number;
+
+  @Prop()
+  analyzeCount?: number;
+
+  @Prop({ type: [String], enum: LEAD_FOLLOWER_TIER_VALUES, default: undefined })
+  followerTiers?: LeadFollowerTier[];
+
+  @Prop()
+  competitorBrands?: string;
+
+  @Prop()
+  competitorCheckPeriod?: string;
+
+  @Prop()
+  requirements?: string;
+}
+export const LeadCurationSchema = SchemaFactory.createForClass(LeadCuration);
+
+@Schema({ _id: false })
+export class LeadLogistics {
+  @Prop()
+  productShipping?: string;
+
+  @Prop()
+  eventPresence?: string;
+
+  @Prop()
+  otherLogistics?: string;
+}
+export const LeadLogisticsSchema = SchemaFactory.createForClass(LeadLogistics);
+
+@Schema({ _id: false })
+export class LeadContentGuidelines {
+  @Prop()
+  productionRequirements?: string;
+
+  @Prop()
+  dos?: string;
+
+  @Prop()
+  donts?: string;
+
+  @Prop()
+  mandatoryWords?: string;
+
+  @Prop()
+  forbiddenTopics?: string;
+
+  @Prop()
+  forbiddenWords?: string;
+
+  @Prop()
+  creatorMessage?: string;
+
+  @Prop()
+  additionalDirections?: string;
+}
+export const LeadContentGuidelinesSchema = SchemaFactory.createForClass(LeadContentGuidelines);
+
+export type LeadDocument = HydratedDocument<Lead>;
+
+@Schema({ timestamps: true, collection: 'leads' })
+export class Lead {
+  // select: false para o token nunca sair numa consulta sem pedir explicitamente.
+  @Prop({ required: true, unique: true, select: false })
+  accessToken: string;
+
+  @Prop({ type: String, enum: LEAD_STATUS_VALUES, default: 'draft', index: true })
+  status: LeadStatus;
+
+  @Prop({ type: Types.ObjectId, ref: 'Organization', required: true })
+  organization: Types.ObjectId;
+
+  @Prop()
+  submittedAt?: Date;
+
+  @Prop({ index: true })
+  lastEditedAt?: Date;
+
+  @Prop({ type: LeadGeneralSchema, default: {} })
+  general: LeadGeneral;
+
+  @Prop({ type: LeadConfidentialitySchema, default: {} })
+  confidentiality: LeadConfidentiality;
+
+  @Prop({ type: LeadBudgetSchema, default: {} })
+  budget: LeadBudget;
+
+  @Prop({ type: LeadCompetitionSchema, default: {} })
+  competition: LeadCompetition;
+
+  @Prop({ type: LeadDeliverablesSchema, default: {} })
+  deliverables: LeadDeliverables;
+
+  @Prop({ type: LeadStrategicContextSchema, default: {} })
+  strategicContext: LeadStrategicContext;
+
+  @Prop({ type: LeadObjectivesSchema, default: {} })
+  objectives: LeadObjectives;
+
+  @Prop({ type: LeadDeliveryScopeSchema, default: {} })
+  deliveryScope: LeadDeliveryScope;
+
+  @Prop({ type: LeadAudienceSchema, default: {} })
+  audience: LeadAudience;
+
+  @Prop({ type: LeadCurationSchema, default: {} })
+  curation: LeadCuration;
+
+  @Prop({ type: LeadLogisticsSchema, default: {} })
+  logistics: LeadLogistics;
+
+  @Prop({ type: LeadContentGuidelinesSchema, default: {} })
+  contentGuidelines: LeadContentGuidelines;
+
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export const LeadSchema = SchemaFactory.createForClass(Lead);
+
+export const LeadModel = MongooseModel('Lead', LeadSchema);

package/src/schemas/profile-followers-snapshot.schema.ts

@@ -0,0 +1,55 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import {
+  HydratedDocument,
+  Schema as MongooseSchema,
+  Types,
+  model as MongooseModel,
+} from 'mongoose';
+import { Profile } from './profile.schema';
+
+export type ProfileFollowersSnapshotDocument = HydratedDocument<ProfileFollowersSnapshot>;
+
+/**
+ * Histórico diário de seguidores por perfil, gravado pelo profile-sync-worker
+ * a partir do `audience_size` que a Primetag devolve na captura. Um doc por
+ * perfil por dia (`date` truncado em UTC): o trigger roda várias vezes ao dia
+ * e cada rodada só sobrescreve o valor do dia.
+ */
+@Schema({ collection: 'profile-followers-snapshots', timestamps: true })
+export class ProfileFollowersSnapshot {
+  @Prop({ type: MongooseSchema.Types.ObjectId, auto: true, required: false })
+  _id?: Types.ObjectId;
+
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Profile', required: true })
+  profile: Types.ObjectId | Profile;
+
+  @Prop({ type: String, required: false })
+  socialnetwork?: string;
+
+  @Prop({ type: Number, required: true })
+  followers: number;
+
+  @Prop({ type: Date, required: true })
+  date: Date;
+
+  @Prop({ type: Date, required: true })
+  capturedAt: Date;
+
+  @Prop({ type: String, enum: ['primetag'], required: true, default: 'primetag' })
+  source: 'primetag';
+
+  @Prop({ default: Date.now, required: false })
+  createdAt?: Date;
+
+  @Prop({ default: Date.now, required: false })
+  updatedAt?: Date;
+}
+
+export const ProfileFollowersSnapshotSchema = SchemaFactory.createForClass(ProfileFollowersSnapshot);
+
+ProfileFollowersSnapshotSchema.index({ profile: 1, date: 1 }, { unique: true });
+
+export const ProfileFollowersSnapshotModel = MongooseModel(
+  'ProfileFollowersSnapshot',
+  ProfileFollowersSnapshotSchema,
+);

package/src/schemas/profile.schema.ts

@@ -15,9 +15,19 @@ export class Profile {
   @Prop()
   followers: number;
 
+  // Atualizado pelo profile-sync-worker a partir do social_profile da Primetag.
+  @Prop({ type: Date, required: false })
+  followersUpdatedAt?: Date;
+
   @Prop()
   picture: string;
 
+  @Prop({ type: Date, required: false })
+  pictureUpdatedAt?: Date;
+
+  @Prop({ type: Number, required: false })
+  primetagSocialProfileId?: number;
+
   @Prop()
   socialnetwork: string;
 

package/src/schemas/sale.schema.ts

@@ -168,6 +168,51 @@ export class Inbox {
   @Prop({ required: true }) receivedAt: Date;
 }
 
+@Schema({ _id: false })
+export class SaleResponsables {
+  @Prop({
+    _id: false,
+    required: false,
+    type: {
+      team: String,
+      name: String,
+      email: String,
+    },
+  })
+  curation?: {
+    team: string;
+    name: string;
+    email: string;
+  };
+
+  @Prop({
+    _id: false,
+    required: false,
+    type: {
+      team: String,
+      name: String,
+      email: String,
+    },
+  })
+  planning?: {
+    team: string;
+    name: string;
+    email: string;
+  };
+}
+
+@Schema({ _id: false })
+export class SaleLinks {
+  @Prop({ required: false })
+  contract?: string;
+
+  @Prop({ required: false })
+  clientSheet?: string;
+
+  @Prop({ required: false })
+  internalSheet?: string;
+}
+
 @Schema({ timestamps: true })
 export class Sale {
   @Prop({ type: MongooseSchema.Types.ObjectId, auto: true, required: false })
@@ -260,6 +305,12 @@ export class Sale {
 
   @Prop({ type: String, required: false })
   omieId?: string;
+
+  @Prop({ type: SaleResponsables, required: false })
+  responsables?: SaleResponsables;
+
+  @Prop({ type: SaleLinks, required: false })
+  links?: SaleLinks;
 }
 
 export const SaleSchema = SchemaFactory.createForClass(Sale);