sowell-models 1.0.0

package/src/models/Spot/index.ts

@@ -0,0 +1,49 @@
+import { SPAreaItem, IArea } from "../AreaItem/index"
+import { Model, Attr, BelongsTo } from "spraypaint"
+import { orderBy } from "lodash"
+import { PouchCollection, PouchORM } from "pouchorm"
+import { IModel } from "pouchorm"
+import { IPlace, SPPlaceItem } from "../Place"
+import { ICompany, SPCompany } from "../Company"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { ApplicationRecord } from "../ApplicationRecord"
+
+export interface ISpot extends IModel {
+  name: string
+  placeId?: string
+  place?: IPlace
+  area?: IArea
+  company?: ICompany
+}
+
+export class SpotCollection
+  extends PouchCollection<ISpot>
+  implements IClearable {
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("spots")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<ISpot> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["name"], ["asc"])
+  }
+}
+
+@Model()
+export class SPSpotItem extends ApplicationRecord implements ISpot {
+  static jsonapiType = "spots"
+  @Attr() name!: string
+  @BelongsTo() place!: SPPlaceItem
+  @BelongsTo() area!: SPAreaItem
+  @BelongsTo() company!: SPCompany
+  get _id(): string | undefined {
+    return this.id
+  }
+}

package/src/models/UnseenIssue/index.ts

@@ -0,0 +1,17 @@
+import { BelongsTo, Model } from "spraypaint"
+import { ApplicationRecord } from "../ApplicationRecord"
+import { IUser, SPUserItem } from "../User"
+import { IIssueReport, SPIssueReportItem } from "../IssueReport"
+import { IModel } from "pouchorm"
+
+export interface IUnseenIssue extends IModel {
+  user?: IUser
+  issueReport?: IIssueReport
+}
+
+@Model()
+export class SPUnseenIssue extends ApplicationRecord implements IUnseenIssue {
+  static jsonapiType = "unseen_issues"
+  @BelongsTo() user!: SPUserItem
+  @BelongsTo() issueReport!: SPIssueReportItem
+}

package/src/models/User/index.ts

@@ -0,0 +1,62 @@
+import { Attr, BelongsTo, HasMany, Model } from "spraypaint"
+import { ICompany, SPCompany } from "../Company"
+
+import { ApplicationRecord } from "../ApplicationRecord"
+import { IModel, PouchCollection, PouchORM } from "pouchorm"
+import { IAssignation, SPAssignation } from "../Assignation"
+import arrayDiffBy from "../../utils/arrayDiffBy"
+import { SPUnseenIssue } from "../UnseenIssue"
+
+export type PhoneNumber = {
+  msisdn: string
+}
+
+export interface IUser extends IModel {
+  id?: string
+  fname?: string
+  lname?: string
+  fullName?: string
+  email?: string
+  company?: ICompany
+  img?: string
+  password?: string
+  assignationsCount?: number | null
+  status?: string
+  recipients?: PhoneNumber[]
+  assignations?: IAssignation[]
+  canUpdateIssueReports?: boolean
+}
+
+export class UserCollection extends PouchCollection<IUser> {
+  async beforeInit(): Promise<void> {
+    await this.addIndex(["id"])
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("users")
+  }
+
+  async bulkUpsertIfNotExists(items: IUser[]): Promise<IUser[]> {
+    const existingItems = await super.find({})
+    const diff = arrayDiffBy(existingItems, items, "id")
+    const upsertedIssueReport = await super.bulkUpsert(diff.missingLeft)
+    return upsertedIssueReport
+  }
+}
+
+@Model()
+export class SPUserItem extends ApplicationRecord implements IUser {
+  static jsonapiType = "users"
+  @Attr() fname!: string
+  @Attr() lname!: string
+  @Attr() email!: string
+  @Attr() fullName!: string
+  @Attr() password!: string
+  @Attr() status!: string
+  @Attr() recipients?: PhoneNumber[]
+  @Attr() assignationsCount!: number | null
+  @Attr() canUpdateIssueReports!: boolean
+  @BelongsTo() company!: SPCompany
+  @HasMany() assignations!: SPAssignation[]
+  @HasMany() unseenIssues!: SPUnseenIssue[]
+}

package/src/models/VisitProp/index.ts

@@ -0,0 +1,38 @@
+import { Model, Attr, BelongsTo } from "spraypaint"
+import { IModel } from "pouchorm"
+
+import { ApplicationRecord } from "../ApplicationRecord"
+import { IPlace, SPPlaceItem } from "../Place"
+import { ICheckpoint, SPCheckpointItem } from "../Checkpoint"
+import { IResidence, SPResidenceItem } from "../Residence"
+import { ISpot, SPSpotItem } from "../Spot"
+
+export type CleanerType = "reporter" | "tenant" | "provider" | "others"
+export interface IVisitProp extends IModel {
+  _id?: string
+  status?: "pending" | "missing"
+  place?: IPlace
+  placeId?: number
+  checkpoint?: ICheckpoint
+  checkpointId?: number
+  residence?: IResidence
+  residenceId?: number
+  spot?: ISpot
+  spotId?: number
+  cleaner?: CleanerType
+}
+
+@Model()
+export class SPVisitPropItem extends ApplicationRecord implements IVisitProp {
+  static jsonapiType = "visit_props"
+  @Attr() status!: "pending" | "missing"
+  @Attr() cleaner!: CleanerType
+  @Attr() placeId!: number
+  @Attr() checkpointId!: number
+  @Attr() residenceId!: number
+  @Attr() spotId!: number
+  @BelongsTo() place!: SPPlaceItem
+  @BelongsTo() checkpoint!: SPCheckpointItem
+  @BelongsTo() residence!: SPResidenceItem
+  @BelongsTo() spot!: SPSpotItem
+}

package/src/models/VisitReport/index.ts

@@ -0,0 +1,127 @@
+import { Model, Attr, BelongsTo, HasMany } from "spraypaint"
+import { IModel } from "pouchorm"
+
+import { IUser, SPUserItem } from "../User"
+import { IIssueReport, SPIssueReportItem } from "../IssueReport"
+import { ApplicationRecord } from "../ApplicationRecord"
+import { IVisitSchedule, SPVisitSchedule } from "../VisitSchedule"
+import { ICheckpoint } from "../Checkpoint"
+import * as yup from "yup"
+import { IChecklist, SPChecklistItem } from "../Checklist"
+import { IPlace, SPPlaceItem } from "../Place"
+import { IResidence, SPResidenceItem } from "../Residence"
+import { ISpot, SPSpotItem } from "../Spot"
+
+export enum CheckpointStatus {
+  NONE = "NONE",
+  OK = "OK",
+  KO = "KO",
+  MISSING = "MISSING",
+  PENDING = "PENDING"
+}
+
+export interface VisitReportPayload {
+  visitSchedule?: string
+  checkpoints: CheckpointProps[]
+  residence?: string
+  place?: string
+  spot?: string
+  checklist?: string
+  isContradictory?: boolean
+  assistedBy?: {
+    id: string
+    fullName: string
+  }
+  comment?: string
+  validate?: (payload: VisitReportPayload) => string
+}
+
+export interface CheckpointProps {
+  _id?: string
+  id?: string
+  label?: string
+  status: CheckpointStatus
+  issue?: {
+    description: string
+    priority: string
+    imgs?: {
+      base64: string[]
+    }
+  }
+  category?: number
+  comment?: string
+  cleaner?: "tenant" | "provider" | "reporter" | "others"
+  coefficient?: number
+}
+
+export interface IVisitReport extends IModel {
+  id?: string
+  createdAt?: Date
+  checkpoints: ICheckpoint[] | CheckpointProps[]
+  visitSchedule?: IVisitSchedule
+  checklist?: IChecklist
+  residence?: IResidence
+  place?: IPlace
+  spot?: ISpot
+  author?: IUser
+  issueReports?: IIssueReport[]
+  isContradictory?: boolean
+  assistedBy?: {
+    id: string
+    full_name: string
+  }
+  score?: number
+  validate?: (payload: VisitReportPayload) => string
+}
+
+@Model()
+export class SPVisitReport extends ApplicationRecord implements IVisitReport {
+  static jsonapiType = "visit_reports"
+  @Attr() checkpoints!: CheckpointProps[]
+  @Attr() createdAt!: Date
+  @Attr() score!: number
+  @Attr() isContradictory!: boolean
+  @Attr() assistedBy!: {
+    id: string
+    full_name: string
+  }
+  @Attr() comment!: string
+  @BelongsTo() author!: SPUserItem
+  @BelongsTo() visitSchedule!: SPVisitSchedule
+  @BelongsTo() checklist!: SPChecklistItem
+  @BelongsTo() residence!: SPResidenceItem
+  @BelongsTo() place!: SPPlaceItem
+  @BelongsTo() spot!: SPSpotItem
+  @HasMany() issueReports!: SPIssueReportItem[]
+
+  static async validate(payload: VisitReportPayload) {
+    const schema = yup
+      .object()
+      .required()
+      .shape({
+        checkpoints: yup.array().of(
+          yup.object().shape({
+            id: yup.string().required(),
+            status: yup.string().required()
+          })
+        ),
+        visitSchedule: yup.string(),
+        checklist: yup.string(),
+        residence: yup.string(),
+        place: yup.string(),
+        spot: yup.string(),
+        comment: yup.string()
+      })
+
+    const isValid = await schema.isValid(payload)
+
+    if (!isValid) {
+      try {
+        await schema.validate(payload)
+      } catch (error: any) {
+        return error.message
+      }
+    }
+    return "VALID"
+  }
+}

package/src/models/VisitSchedule/index.ts

@@ -0,0 +1,58 @@
+import { Model, Attr, BelongsTo } from "spraypaint"
+import { IModel, PouchCollection, PouchORM } from "pouchorm"
+import { orderBy } from "lodash"
+
+import { ApplicationRecord } from "../ApplicationRecord"
+import { IPlace, SPPlaceItem } from "../Place"
+import { IChecklist, SPChecklistItem } from "../Checklist"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { IResidence, SPResidenceItem } from "../Residence"
+import { ISpot, SPSpotItem } from "../Spot"
+
+export interface IVisitSchedule extends IModel {
+  _id?: string
+  dueAt: Date
+  checklistId?: string
+  residence?: IResidence
+  place?: IPlace
+  spot?: ISpot
+  checklist?: IChecklist
+}
+
+export class VisitSchedulesCollection
+  extends PouchCollection<IVisitSchedule>
+  implements IClearable
+{
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("visit_schedules")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<IVisitSchedule> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["dueAt"], ["asc"])
+  }
+}
+
+@Model()
+export class SPVisitSchedule
+  extends ApplicationRecord
+  implements IVisitSchedule
+{
+  static jsonapiType = "visit_schedules"
+  @Attr() dueAt!: Date
+  @Attr() checklistId!: string
+  @BelongsTo() residence!: SPResidenceItem
+  @BelongsTo() place!: SPPlaceItem
+  @BelongsTo() spot!: SPSpotItem
+  @BelongsTo() checklist!: SPChecklistItem
+  get _id(): string | undefined {
+    return this.id
+  }
+}

package/src/models/category/index.ts

@@ -0,0 +1,54 @@
+import { Model, Attr, BelongsTo, HasMany } from "spraypaint"
+import { IModel, PouchCollection, PouchORM } from "pouchorm"
+import { orderBy } from "lodash"
+
+import { ApplicationRecord } from "../ApplicationRecord"
+import { ICompany, SPCompany } from "../Company"
+import { IArea, SPAreaItem } from "../AreaItem"
+import { SPCheckpointItem } from "../Checkpoint"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { IReason, SPReasonItem } from "../Reason"
+
+export interface ICategory extends IModel {
+  _id?: string
+  name: string
+  iconUrl?: string
+  company?: ICompany
+  areaId?: string
+  area?: IArea
+  reasons?: IReason[]
+}
+
+export class CategoryCollection
+  extends PouchCollection<ICategory>
+  implements IClearable {
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("categories")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<ICategory> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["name"], ["asc"])
+  }
+}
+
+@Model()
+export class SPCategoryItem extends ApplicationRecord implements ICategory {
+  static jsonapiType = "categories"
+  @Attr() name!: string
+  @Attr() iconUrl!: string
+  @BelongsTo() company!: SPCompany
+  @BelongsTo() area!: SPAreaItem
+  get _id(): string | undefined {
+    return this.id
+  }
+  @HasMany() checkpoints!: SPCheckpointItem[]
+  @HasMany() reasons!: SPReasonItem[]
+}

package/src/models/interfaces.ts

@@ -0,0 +1,8 @@
+export interface IClearable {
+  clear(): Promise<void>
+}
+
+export interface CollectionFindOptions {
+  sort?: string[] | undefined
+  limit?: number | undefined
+}

package/src/models/types.ts

@@ -0,0 +1,10 @@
+import { intersectionBy, differenceBy, ValueIteratee } from "lodash"
+
+export default function arrayDiffBy<T> (array1: T[], array2: T[], iteratee: ValueIteratee<T>) {
+	const result = {
+		matched: intersectionBy(array1, array2, iteratee),
+		missingRight: differenceBy(array1, array2, iteratee),
+		missingLeft: differenceBy(array2, array1, iteratee)
+	}
+	return result
+}

package/src/utils/arrayDiffBy.ts

@@ -0,0 +1,14 @@
+import { intersectionBy, differenceBy, ValueIteratee } from "lodash"
+
+export default function arrayDiffBy<T>(
+  array1: T[],
+  array2: T[],
+  iteratee: ValueIteratee<T>
+) {
+  const result = {
+    matched: intersectionBy(array1, array2, iteratee),
+    missingRight: differenceBy(array1, array2, iteratee),
+    missingLeft: differenceBy(array2, array1, iteratee)
+  }
+  return result
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "allowJs": true,
+    "target": "es6",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "types": ["node"]
+  }
+}

package/tsconfig.release.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "sourceMap": false,
+    "removeComments": true
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.ts", "**/*.spec.ts"]
+}