codebase-models 1.0.0

package/src/models/ClientNote.ts

@@ -0,0 +1,61 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IClientNote extends Document {
+  organisationId?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  pageType?: mongoose.Schema.Types.ObjectId;
+  source: string;
+  whatYouSee?: string;
+  interpretation?: String;
+  evidence?: mongoose.Schema.Types.Mixed;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+}
+
+const ClientNoteSchema = new Schema<IClientNote>(
+  {
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    viewId: {
+      type: String,
+    },
+    pageType: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "pageelement",
+    },
+    source: {
+      type: String,
+      required: true,
+    },
+    whatYouSee: {
+      type: String,
+    },
+    interpretation: {
+      type: String,
+    },
+    evidence: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ClientNoteSchema.index({
+  client: 1,
+  viewId: 1,
+});
+
+const ClientNote = model<IClientNote>("clientnote", ClientNoteSchema);
+export default ClientNote;

package/src/models/ClientReportsTemp.ts

@@ -0,0 +1,64 @@
+import mongoose, { Schema, model } from "mongoose";
+
+export interface IClientReportsTemp extends Document {
+  organisationId?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  test?: mongoose.Schema.Types.ObjectId;
+  filters?: string;
+  metricsFilters?: string;
+  date?: Date;
+  report?: mongoose.Schema.Types.Mixed;
+  deactivated?: boolean;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+}
+
+const ClientReportsTempSchema = new Schema<IClientReportsTemp>(
+  {
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    viewId: {
+      type: String,
+    },
+    test: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "test",
+    },
+    filters: {
+      type: String,
+    },
+    metricsFilters: {
+      type: String,
+    },
+    date: {
+      type: Date,
+    },
+    report: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    deactivated: {
+      type: Boolean,
+      default: false,
+    },
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const ClientReportsTemp = model<IClientReportsTemp>(
+  "clientreportstemp",
+  ClientReportsTempSchema
+);
+
+export default ClientReportsTemp;

package/src/models/ClientRetention.ts

@@ -0,0 +1,76 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IClientRetention extends Document {
+  client?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  year: Number;
+  retentions?: {
+    year: Number;
+    month: Number;
+    monthName: String;
+    active: Boolean;
+    retainerValue: Number;
+    otherPayments: Number;
+  };
+}
+
+const ClientRetentionSchema = new Schema<IClientRetention>(
+  {
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+      required: true,
+    },
+    viewId: {
+      type: String,
+      ref: "client.gaproperties.viewId",
+    },
+    year: {
+      type: Number,
+      required: true,
+    },
+    retentions: {
+      type: [
+        {
+          _id: false,
+          year: {
+            type: Number,
+            required: true,
+          },
+          month: {
+            type: Number,
+            required: true,
+          },
+          monthName: {
+            type: String,
+            required: true,
+          },
+          active: {
+            type: Boolean,
+            default: true,
+            required: true,
+          },
+          retainerValue: {
+            type: Number,
+            required: true,
+          },
+          otherPayments: {
+            type: Number,
+            required: false,
+            default: 0,
+          },
+        },
+      ],
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const ClientRetention = model<IClientRetention>(
+  "ClientRetention",
+  ClientRetentionSchema
+);
+
+export default ClientRetention;

package/src/models/ClientStrategy.ts

@@ -0,0 +1,70 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IClientStrategy extends Document {
+  year: mongoose.Schema.Types.Mixed;
+  month: mongoose.Schema.Types.Mixed;
+  startDate?: Date;
+  endDate?: Date;
+  strategies?: mongoose.Schema.Types.Mixed;
+  organisationId?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  learningsoftime?: mongoose.Schema.Types.Mixed;
+  viewId?: string;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+}
+
+const ClientStrategySchema = new Schema<IClientStrategy>(
+  {
+    year: {
+      type: mongoose.Schema.Types.Mixed,
+      required: true,
+    },
+    month: {
+      type: mongoose.Schema.Types.Mixed,
+      required: true,
+    },
+    startDate: {
+      type: Date,
+    },
+    endDate: {
+      type: Date,
+    },
+    strategies: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    learningsoftime: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    viewId: {
+      type: String,
+    },
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ClientStrategySchema.index({
+  year: 1,
+  month: 1,
+  client: 1,
+  viewId: 1,
+});
+
+const ClientStrategy = model<IClientStrategy>(
+  "clientstrategy",
+  ClientStrategySchema
+);
+export default ClientStrategy;

package/src/models/ClientSurvay.ts

@@ -0,0 +1,36 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IClientSurvay extends Document {
+  responses: IResponce;
+  user?: mongoose.Schema.Types.ObjectId;
+}
+
+export interface IResponce extends Document {
+  question?: String;
+  answer?: String;
+}
+
+const ResponseSchema = new Schema<IResponce>({
+  question: {
+    type: String,
+  },
+  answer: {
+    type: String,
+  },
+});
+
+const ClientSurveySchema = new Schema<IClientSurvay>(
+  {
+    responses: [ResponseSchema],
+    user: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const ClientSurvey = model("clientsurvey", ClientSurveySchema);
+export default ClientSurvey;

package/src/models/Faqs.ts

@@ -0,0 +1,32 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IFaqs extends Document {
+  title?: string;
+  description?: string;
+  keywords?: mongoose.Schema.Types.Array;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const FaqSchema = new Schema<IFaqs>({
+  title: {
+    type: String,
+  },
+  description: {
+    type: String,
+  },
+  keywords: {
+    type: mongoose.Schema.Types.Array,
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const Faq = model<IFaqs>("faq", FaqSchema);
+export default Faq;

package/src/models/Feedback.ts

@@ -0,0 +1,46 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IFeedback extends Document {
+  title: string;
+  details?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  thread?: mongoose.Schema.Types.Mixed;
+  organisationId?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const FeedbackSchema = new Schema<IFeedback>({
+  title: {
+    type: String,
+    required: true,
+  },
+  details: {
+    type: String,
+    default: "",
+  },
+  client: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "client",
+  },
+  thread: {
+    type: mongoose.Schema.Types.Mixed,
+    default: [],
+  },
+  organisationId: {
+    type: String,
+    default: null,
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const Feedback = model<IFeedback>("feedback", FeedbackSchema);
+
+export default Feedback;

package/src/models/Goal.ts

@@ -0,0 +1,40 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IGoal extends Document {
+  name: string;
+  details?: string;
+  slug?: string;
+  organisationId?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const GoalSchema = new Schema<IGoal>({
+  name: {
+    type: String,
+    required: true,
+  },
+  details: {
+    type: String,
+    default: "",
+  },
+  slug: {
+    type: String,
+  },
+  organisationId: {
+    type: String,
+    default: null,
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const Goal = model<IGoal>("goal", GoalSchema);
+
+export default Goal;

package/src/models/Hypothesis.ts

@@ -0,0 +1,50 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IHypothesis extends Document {
+  hypothesisNumber?: string;
+  name: string;
+  action: string;
+  result: string;
+  expectation: string;
+  tagged?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const HypothesisSchema = new Schema<IHypothesis>({
+  hypothesisNumber: {
+    type: String,
+  },
+  name: {
+    type: String,
+    required: true,
+  },
+  action: {
+    type: String,
+    required: true,
+  },
+  result: {
+    type: String,
+    required: true,
+  },
+  expectation: {
+    type: String,
+    required: true,
+  },
+  tagged: {
+    type: String,
+    default: "General Purpose",
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const Hypothesis = model<IHypothesis>("hypos", HypothesisSchema);
+
+export default Hypothesis;

package/src/models/HypothesisSheet.ts

@@ -0,0 +1,114 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+import HypothesisSheetConstants from "../constant";
+
+export interface IHypothesisSheet extends Document {
+  organizationId?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  pageelement?: mongoose.Schema.Types.ObjectId;
+  trigger?: mongoose.Schema.Types.ObjectId;
+  hypothesis?: mongoose.Schema.Types.ObjectId;
+  test?: mongoose.Schema.Types.ObjectId;
+  changeMadeAboveTheFold?: Number;
+  discoveredByUserTesting?: Number;
+  supportedByQuantitativeData?: Number;
+  supportedByHeatMapsOrMouseTracking?: Number;
+  changeNoticableWithin5Seconds?: Number;
+  levelOfEffortForDev?: Number;
+  isItAddingOrRemovingSomething?: Number;
+  changeOnPageWithHighTraffic?: Number;
+  designedToIncreaseUserMotivation?: Number;
+  thoughtsOfTeam?: Number;
+  tested?: Boolean;
+}
+
+const HypothesisSheetSchema = new Schema<IHypothesisSheet>(
+  {
+    organizationId: {
+      type: String,
+      default: null,
+    },
+    client: {
+      type: Schema.Types.ObjectId,
+      ref: "client",
+    },
+    viewId: {
+      type: String,
+    },
+    pageelement: {
+      type: [Schema.Types.ObjectId],
+      ref: "pageelement",
+    },
+    trigger: {
+      type: [Schema.Types.ObjectId],
+      ref: "trigger",
+      default: [],
+    },
+    hypothesis: {
+      type: Schema.Types.ObjectId,
+      ref: "hypos",
+    },
+    test: {
+      type: Schema.Types.ObjectId,
+      ref: "test",
+    },
+    changeMadeAboveTheFold: {
+      type: Number,
+      enum: [HypothesisSheetConstants.YES, HypothesisSheetConstants.NO],
+    },
+    discoveredByUserTesting: {
+      type: Number,
+      enum: [HypothesisSheetConstants.YES, HypothesisSheetConstants.NO],
+    },
+    supportedByQuantitativeData: {
+      type: Number,
+      enum: [HypothesisSheetConstants.YES, HypothesisSheetConstants.NO],
+    },
+    supportedByHeatMapsOrMouseTracking: {
+      type: Number,
+      enum: [HypothesisSheetConstants.YES, HypothesisSheetConstants.NO],
+    },
+    changeNoticableWithin5Seconds: {
+      type: Number,
+      enum: [HypothesisSheetConstants.YES_2, HypothesisSheetConstants.NO],
+    },
+    levelOfEffortForDev: {
+      type: Number,
+      enum: [HypothesisSheetConstants.DAYS_2, HypothesisSheetConstants.MORE],
+    },
+    isItAddingOrRemovingSomething: {
+      type: Number,
+      enum: [HypothesisSheetConstants.YES_2, HypothesisSheetConstants.NO],
+    },
+    changeOnPageWithHighTraffic: {
+      type: Number,
+      enum: [HypothesisSheetConstants.YES, HypothesisSheetConstants.NO],
+    },
+    designedToIncreaseUserMotivation: {
+      type: Number,
+      enum: [HypothesisSheetConstants.YES, HypothesisSheetConstants.NO],
+    },
+    thoughtsOfTeam: {
+      type: Number,
+      enum: [
+        HypothesisSheetConstants.LOW,
+        HypothesisSheetConstants.MEDIUM,
+        HypothesisSheetConstants.GOOD,
+      ],
+    },
+    tested: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const HypothesisSheet = model<IHypothesisSheet>(
+  "hypothesisSheet",
+  HypothesisSheetSchema
+);
+
+export default HypothesisSheet;

package/src/models/LandingPages.ts

@@ -0,0 +1,46 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface ILandingPagesData extends Document {
+  conversionRate?: Number;
+}
+
+const LandingPageDataSchema = new Schema<ILandingPagesData>({
+  conversionRate: {
+    type: Number,
+  },
+});
+
+export interface ILandingPages extends Document {
+  title: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  screenshot?: string;
+  dataPoints?: ILandingPagesData;
+}
+
+const LandingPagesSchema = new Schema<ILandingPages>(
+  {
+    title: {
+      type: String,
+      required: true,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+      required: true,
+    },
+    screenshot: {
+      type: String,
+      default: null,
+    },
+    dataPoints: {
+      type: LandingPageDataSchema,
+      default: {},
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const LandingPages = model<ILandingPages>("LandingPages", LandingPagesSchema);
+export default LandingPages;

package/src/models/NewIdeas.ts

@@ -0,0 +1,63 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface INewIdeas extends Document {
+  organisationId?: string;
+  ideaName: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  hypothesis?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  pageType?: mongoose.Schema.Types.ObjectId;
+  priorityDetails?: mongoose.Schema.Types.Mixed;
+  totalPriority?: string;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+}
+
+const NewIdeasSchema = new Schema<INewIdeas>(
+  {
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    ideaName: {
+      type: String,
+      required: true,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    hypothesis: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "hypos",
+    },
+    viewId: {
+      type: String,
+    },
+    pageType: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "pageelement",
+    },
+    priorityDetails: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    totalPriority: {
+      type: String,
+      default: 0,
+    },
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+NewIdeasSchema.index({
+  client: 1,
+  viewId: 1,
+});
+
+const NewIdeas = model<INewIdeas>("Newideas", NewIdeasSchema);
+export default NewIdeas;