sowell-models 1.0.0

package/src/models/Checkpoint/index.ts

@@ -0,0 +1,57 @@
+import { Model, Attr, BelongsTo, HasMany } from "spraypaint"
+import { IModel, PouchCollection, PouchORM } from "pouchorm"
+import { orderBy } from "lodash"
+
+import { ICategory, SPCategoryItem } from "../category"
+import { ApplicationRecord } from "../ApplicationRecord"
+import { IChecklist, SPChecklistItem } from "../Checklist"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { IVisitProp, SPVisitPropItem } from "../VisitProp"
+import { ILocation, SPLocationItem } from "../Location"
+
+export interface ICheckpoint extends IModel {
+  _id?: string
+  question?: string
+  description?: string
+  checklist?: IChecklist
+  categoryId?: number
+  category?: number | ICategory
+  visitProps?: IVisitProp[]
+  locationId?: number
+  location?: ILocation
+  coefficient?: number
+}
+
+export class CheckpointCollection
+  extends PouchCollection<ICheckpoint>
+  implements IClearable {
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("checkpoints")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<ICheckpoint> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["question"], ["asc"])
+  }
+}
+
+@Model()
+export class SPCheckpointItem extends ApplicationRecord implements ICheckpoint {
+  static jsonapiType = "checkpoints"
+  @Attr() question!: string
+  @Attr() description!: string
+  @Attr() categoryId!: number
+  @Attr() locationId!: number
+  @Attr() coefficient!: number
+  @BelongsTo() category!: SPCategoryItem
+  @BelongsTo() checklist!: SPChecklistItem
+  @BelongsTo() location?: SPLocationItem | undefined
+  @HasMany() visitProps?: SPVisitPropItem[] | undefined
+}

package/src/models/Company/index.ts

@@ -0,0 +1,26 @@
+import { Model, Attr, HasMany } from "spraypaint"
+import { IModel } from "pouchorm"
+
+import { ApplicationRecord } from "../ApplicationRecord"
+import { SPAreaItem } from "../AreaItem"
+import { SPAgencyItem } from "../Agency"
+import { SPResidenceItem } from "../Residence"
+import { SPPlaceItem } from "../Place"
+
+export interface ICompany extends IModel {
+  id?: string
+  _id?: string
+  name?: string
+  config?: string[]
+}
+
+@Model()
+export class SPCompany extends ApplicationRecord implements ICompany {
+  static jsonapiType = "companies"
+  @Attr() name!: string
+  @Attr() config!: string[]
+  @HasMany("areas") spAreaItems!: SPAreaItem[]
+  @HasMany("agencies") spAgencyItems!: SPAgencyItem[]
+  @HasMany("residences") spResidenceItems!: SPResidenceItem[]
+  @HasMany("places") spPlaceItems!: SPPlaceItem[]
+}

package/src/models/Export/index.ts

@@ -0,0 +1,27 @@
+import { Model, Attr } from "spraypaint"
+
+import { ApplicationRecord } from "../ApplicationRecord"
+
+export enum ExportStatus {
+  ONGOING = "ongoing",
+  PENDING = "pending",
+  DONE = "done",
+  FAILED = "failed"
+}
+
+export interface IExport {
+  id?: string
+  name?: string
+  status?: ExportStatus
+  params?: string
+  url?: string
+}
+
+@Model()
+export class SPExport extends ApplicationRecord implements IExport {
+  static jsonapiType = "exports"
+  @Attr() name!: string
+  @Attr() status!: ExportStatus
+  @Attr() url!: string
+  @Attr() params!: string
+}

package/src/models/Family/index.ts

@@ -0,0 +1,41 @@
+import { Model, Attr } from "spraypaint"
+import { ApplicationRecord } from "../ApplicationRecord"
+import { PouchCollection, PouchORM } from "pouchorm"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { orderBy } from "lodash"
+
+export interface IFamily {
+  _id?: string
+  name?: string
+  iconUrl?: string
+}
+@Model()
+export class SPFamily extends ApplicationRecord implements IFamily {
+  static jsonapiType = "families"
+  @Attr() name!: string
+  @Attr() iconUrl!: string
+  get _id(): string | undefined {
+    return this.id
+  }
+}
+
+export class FamilyCollection
+  extends PouchCollection<IFamily>
+  implements IClearable
+{
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("places")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<IFamily> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["name"], ["asc"])
+  }
+}

package/src/models/IssueReport/index.ts

@@ -0,0 +1,169 @@
+import { Model, Attr, BelongsTo, HasMany } from "spraypaint"
+import { IModel, PouchCollection, PouchORM } from "pouchorm"
+import { orderBy } from "lodash"
+import * as yup from "yup"
+
+import { ICompany, SPCompany } from "../Company"
+import { ICategory, SPCategoryItem } from "../category"
+import { IPlace, SPPlaceItem } from "../Place"
+import { ApplicationRecord } from "../ApplicationRecord"
+import { IUser, SPUserItem } from "../User"
+import { ICheckpoint, SPCheckpointItem } from "../Checkpoint"
+import { SPVisitReport } from "../VisitReport"
+import { IResidence } from "../Residence"
+import { IArea } from "../AreaItem"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { ISpot, SPSpotItem } from "./../Spot"
+import arrayDiffBy from "../types"
+import { IReason, SPReasonItem } from "../Reason"
+import { IOrigin, SPOriginItem } from "../Origin"
+import { SPUnseenIssue } from "../UnseenIssue"
+export interface IssueReportPayload {
+  category?: string
+  agency?: string
+  residence?: string
+  place?: string
+  checkpoint?: string
+  description: string
+  priority: number
+  visitReport?: string
+  imgs?: File[]
+  spot?: string
+  areaNature?: "housing" | "other_spots" | "common_areas" | "zone"
+  isTenantRequest?: boolean
+  reason?: string
+  origin?: string
+}
+
+export type Tab = "mySector" | "others"
+export interface TalkPayload {
+  id: string
+  issueReportId: string
+  message: string
+  tab: Tab
+}
+
+export interface ITalk {
+  id: string
+  author: {
+    id: string
+    name: string
+  }
+  message: string
+  files: string[]
+  created_at?: Date
+}
+
+export interface IIssueReport extends IModel {
+  _id?: string
+  remoteId?: string
+  priority: string
+  message: string
+  status: string
+  checkpointId?: number
+  createdAt?: Date
+  updatedAt?: Date
+  place?: IPlace
+  category?: ICategory
+  checkpoint?: ICheckpoint
+  author?: IUser
+  company?: ICompany
+  residence?: IResidence
+  area?: IArea
+  talks?: ITalk[]
+  spot?: ISpot | ISpot[]
+  imgs?: string[]
+  isTenantRequest?:boolean
+  reason?: IReason
+  origin?: IOrigin
+  seen?: boolean
+  validate?: () => string
+}
+
+export class IssueCollection
+  extends PouchCollection<IIssueReport>
+  implements IClearable {
+  async beforeInit(): Promise<void> {
+    await this.addIndex(["_id", "remoteId"])
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("issueReports")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<IIssueReport> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["name"], ["asc"])
+  }
+  async bulkUpsertIfNotExists(items: IIssueReport[]): Promise<IIssueReport[]> {
+    const existingItems = await super.find({})
+    const diff = arrayDiffBy(existingItems, items, "remoteId")
+    const upsertedIssueReport = await super.bulkUpsert(diff.missingLeft)
+    return upsertedIssueReport
+  }
+}
+
+@Model()
+export class SPIssueReportItem
+  extends ApplicationRecord
+  implements Partial<IIssueReport> {
+  static jsonapiType = "issue_reports"
+  @Attr() isTenantRequest!: boolean
+  @Attr() message!: string
+  @Attr() talks!: ITalk[]
+  @Attr() imgs!: string[]
+  @Attr() priority!: string
+  @Attr() status!: string
+  @Attr() checkpointId!: number
+  @Attr({ persist: false }) createdAt!: Date
+  @Attr({ persist: false }) updatedAt!: Date
+  @Attr() pendingIimestamp!: Date
+  @Attr() ongoingTimestamp!: Date
+  @Attr() doneTimestamp!: Date
+  @Attr() canceledTimestamp!: Date
+  @Attr() rejectedTimestamp!: Date
+  @Attr() seen!: boolean
+  @BelongsTo() author!: SPUserItem
+  @BelongsTo() category!: SPCategoryItem
+  @BelongsTo() residence!: IResidence
+  @BelongsTo() place!: SPPlaceItem
+  @BelongsTo() spot!: SPSpotItem
+  @BelongsTo() company!: SPCompany
+  @BelongsTo() visitReport!: SPVisitReport
+  @BelongsTo() checkpoint!: SPCheckpointItem
+  @BelongsTo() reason!: SPReasonItem
+  @BelongsTo() origin?: SPOriginItem | undefined
+  @HasMany() unseenIssues!: SPUnseenIssue[]
+
+  static async validate(payload: IssueReportPayload) {
+    const schema = yup
+      .object()
+      .required()
+      .shape({
+        category: yup.string(),
+        agency: yup.string(),
+        residence: yup.string().nullable().notRequired(),
+        place: yup.string().nullable().notRequired(),
+        spot: yup.string().nullable().notRequired(),
+        checkpoint: yup.string(),
+        description: yup.string().required(),
+        priority: yup.number().required(),
+        visitReport: yup.string(),
+        isTenantRequest: yup.boolean()
+      })
+
+    const isValid = await schema.isValid(payload)
+
+    if (!isValid) {
+      try {
+        await schema.validate(payload)
+      } catch (error: any) {
+        return error.message
+      }
+    }
+    return "VALID"
+  }
+}

package/src/models/Location/index.ts

@@ -0,0 +1,23 @@
+import { Attr, BelongsTo, HasMany, Model } from "spraypaint"
+import { IModel } from "pouchorm"
+
+import { IAreaType, SPAreaType } from "../AreaItem"
+import { ApplicationRecord } from "../ApplicationRecord"
+import { ICheckpoint, SPCheckpointItem } from "../Checkpoint"
+
+export interface ILocation extends IModel {
+  _id?: string
+  name?: string
+  areaType?: IAreaType
+  areaTypeId?: number
+  checkpoints?: ICheckpoint[]
+}
+
+@Model()
+export class SPLocationItem extends ApplicationRecord implements ILocation {
+  static jsonapiType = "locations"
+  @Attr() name!: string
+  @Attr() areaTypeId!: number
+  @BelongsTo() areaType!: SPAreaType
+  @HasMany() checkpoints?: SPCheckpointItem[] | undefined
+}

package/src/models/Origin/index.ts

@@ -0,0 +1,44 @@
+import { Model, Attr, HasMany } from "spraypaint"
+import { ApplicationRecord } from "../ApplicationRecord"
+import { IModel, PouchCollection, PouchORM } from "pouchorm"
+import { IIssueReport, SPIssueReportItem } from "../IssueReport"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { orderBy } from "lodash"
+
+export interface IOrigin extends IModel {
+  _id?: string
+  name?: string
+  iconUrl?: string
+  issueReports?: IIssueReport[]
+}
+
+export class OriginCollection
+  extends PouchCollection<IOrigin>
+  implements IClearable {
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("origins")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<IOrigin> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["name"], ["asc"])
+  }
+}
+
+@Model()
+export class SPOriginItem extends ApplicationRecord implements IOrigin {
+  static jsonapiType = "origins"
+  @Attr() name!: string
+  @Attr() iconUrl!: string
+  @HasMany() issueReports!: SPIssueReportItem[]
+  get _id(): string | undefined {
+    return this.id
+  }
+}

package/src/models/Place/index.ts

@@ -0,0 +1,75 @@
+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 { IResidence, SPResidenceItem } from "../Residence"
+import { IVisitSchedule, SPVisitSchedule } from "../VisitSchedule"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { ISpot, SPSpotItem } from "../Spot"
+
+export interface IPlace extends IModel {
+  _id?: string
+  name: string
+  zip?: string
+  city?: string
+  country?: string
+  street_number?: string
+  street_name?: string
+  sectorIds?: string[]
+  residenceId?: string
+  agencyId?: string
+  visitScheduleIds?: string[]
+  updatedAt?: Date
+  hasScheduledVisit?: boolean
+  residence?: IResidence
+  company?: ICompany
+  spots?: ISpot[]
+  visitSchedules?: IVisitSchedule[]
+}
+
+export class PlaceCollection
+  extends PouchCollection<IPlace>
+  implements IClearable
+{
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("places")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<IPlace> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["name"], ["asc"])
+  }
+}
+
+@Model()
+export class SPPlaceItem extends ApplicationRecord implements IPlace {
+  constructor(attrs?: Record<string, any>) {
+    super(attrs)
+    this.sectorIds = attrs?.sectorIds || []
+  }
+  static jsonapiType = "places"
+  @Attr() name!: string
+  @Attr() zip!: string
+  @Attr() city!: string
+  @Attr() country!: string
+  @Attr() street_number!: string
+  @Attr() street_name!: string
+  @Attr() sectorIds!: string[]
+  @Attr({ persist: false }) updatedAt!: Date
+  @BelongsTo() residence!: SPResidenceItem
+  @BelongsTo() company!: SPCompany
+  @HasMany() visitSchedules!: SPVisitSchedule[]
+  @HasMany() spots!: SPSpotItem[]
+  get _id(): string | undefined {
+    return this.id
+  }
+}

package/src/models/Provider/index.ts

@@ -0,0 +1,44 @@
+import { Model, Attr } from "spraypaint"
+import { orderBy } from "lodash"
+import { PouchCollection, PouchORM } from "pouchorm"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { ApplicationRecord } from "../ApplicationRecord"
+
+export interface Provider {
+  _id?: string
+  fname: string
+  lname: string
+  email?: string
+}
+
+export class ProviderCollection
+  extends PouchCollection<Provider>
+  implements IClearable
+{
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("providers")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<Provider> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["fname"], ["asc"])
+  }
+}
+
+@Model()
+export class SPProvider extends ApplicationRecord implements Provider {
+  static jsonapiType = "providers"
+  @Attr() fname!: string
+  @Attr() lname!: string
+  @Attr() email!: string
+  get _id(): string | undefined {
+    return this.id
+  }
+}

package/src/models/Reason/index.ts

@@ -0,0 +1,41 @@
+import { Model, Attr, BelongsTo } from "spraypaint"
+import { IModel, PouchCollection, PouchORM } from "pouchorm"
+import { orderBy } from "lodash"
+
+import { ApplicationRecord } from "../ApplicationRecord"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { SPCategoryItem } from "../category"
+
+export interface IReason extends IModel {
+  _id?: string
+  name: string
+}
+
+export class ReasonCollection
+  extends PouchCollection<IReason>
+  implements IClearable {
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("reasons")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<IReason> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["name"], ["asc"])
+  }
+}
+
+@Model()
+export class SPReasonItem
+  extends ApplicationRecord
+  implements IReason {
+  static jsonapiType = "reasons"
+  @Attr() name!: string
+  @BelongsTo() category!: SPCategoryItem
+}

package/src/models/Residence/index.ts

@@ -0,0 +1,50 @@
+import { Model, Attr, BelongsTo, HasMany } from "spraypaint"
+import { IModel, PouchCollection, PouchORM } from "pouchorm"
+import { orderBy } from "lodash"
+
+import { ApplicationRecord } from "../ApplicationRecord"
+import { IAgency, SPAgencyItem } from "../Agency"
+import { ICompany, SPCompany } from "../Company"
+import { SPPlaceItem, IPlace } from "../Place"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+
+export interface IResidence extends IModel {
+  _id?: string
+  name: string
+  agencyId?: string
+  agency?: IAgency
+  hasScheduledVisit?: boolean
+  places?: IPlace[]
+  company?: ICompany
+}
+
+export class ResidenceCollection
+  extends PouchCollection<IResidence>
+  implements IClearable
+{
+  async beforeInit(): Promise<void> {
+    // NOTE: none
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("residences")
+  }
+
+  async find(selector?: Record<string, any> | Partial<IResidence> | undefined, opts?: CollectionFindOptions) {
+    const result = await super.find(selector, opts)
+    return orderBy(result, ["name"], ["asc"])
+  }
+}
+
+@Model()
+export class SPResidenceItem extends ApplicationRecord implements IResidence {
+  static jsonapiType = "residences"
+  @Attr() name!: string
+  @Attr() hasScheduledVisit!: boolean
+  @BelongsTo() agency!: SPAgencyItem
+  @BelongsTo() company!: SPCompany
+  @HasMany() places!: SPPlaceItem[]
+  get _id(): string | undefined {
+    return this.id
+  }
+}

package/src/models/Sector/index.ts

@@ -0,0 +1,56 @@
+import { Attr, BelongsTo, HasMany, Model } from "spraypaint"
+import { CollectionFindOptions, IClearable } from "../interfaces"
+import { ICompany, SPCompany } from "../Company"
+import { IModel, PouchCollection, PouchORM } from "pouchorm"
+import { IAssignation, SPAssignation } from "../Assignation"
+
+import { ApplicationRecord } from "../ApplicationRecord"
+
+export interface ISector extends IModel {
+  id?: string
+  name: string
+  code: string
+  updatedAt?: Date
+  company?: ICompany
+  assignations?: IAssignation[]
+  reporterId?: string
+  placesCount?: number
+}
+
+export class SectorCollection
+  extends PouchCollection<ISector>
+  implements IClearable
+{
+  async beforeInit(): Promise<void> {
+    // NOTE: clear
+  }
+
+  async clear(): Promise<void> {
+    await PouchORM.clearDatabase("sectors")
+  }
+
+  async find(
+    selector?: Record<string, any> | Partial<ISector> | undefined,
+    opts?: CollectionFindOptions
+  ) {
+    return super.find(selector, opts)
+  }
+}
+@Model()
+export class SPSectorItem extends ApplicationRecord implements ISector {
+  constructor(attrs?: Record<string, any>) {
+    super(attrs)
+    this.placesCount = attrs?.placesCount || 0
+  }
+  static jsonapiType = "sectors"
+  @Attr() name!: string
+  @Attr() code!: string
+  @Attr() reporterId!: string
+  @Attr({ persist: false }) placesCount?: number | undefined
+  @Attr({ persist: false }) updatedAt!: Date
+  @BelongsTo() company!: SPCompany
+  @HasMany() assignations!: SPAssignation[]
+  get _id(): string | undefined {
+    return this.id
+  }
+}