@rowengine/common 1.1.2 → 1.1.3

package/build/interfaces/weeds.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeedsStatus = exports.WeedsDetectionType = void 0;
+var WeedsDetectionType;
+(function (WeedsDetectionType) {
+    WeedsDetectionType["GEOMETRIC"] = "Geom";
+    WeedsDetectionType["ZONES"] = "Zones";
+    WeedsDetectionType["GLOBAL"] = "Global";
+    WeedsDetectionType["LOCAL"] = "Local";
+})(WeedsDetectionType || (exports.WeedsDetectionType = WeedsDetectionType = {}));
+var WeedsStatus;
+(function (WeedsStatus) {
+    /** Running IndexWeed on every field. */
+    WeedsStatus["DETECTING"] = "DETECTING";
+    /** IndexWeed finished successfully. */
+    WeedsStatus["DETECTED"] = "DETECTED";
+    /** User running MergeClas to edit filters. */
+    WeedsStatus["PROCESSING"] = "PROCESSING";
+    /** User processed using MergeClas (generated lines and png) */
+    WeedsStatus["MERGECLAS_PROCESSED"] = "MERGECLAS_PROCESSED";
+    /** User generated polygons using MergeClas, and now can edit them. */
+    WeedsStatus["POLYGONS_GENERATED"] = "POLYGONS_GENERATED";
+    /** User edited, confirmed and generated the weed polygons. */
+    WeedsStatus["READY"] = "READY";
+    /** Error on the process. */
+    WeedsStatus["FAILED"] = "FAILED";
+})(WeedsStatus || (exports.WeedsStatus = WeedsStatus = {}));

package/build/models/activity.model.d.ts

@@ -0,0 +1,25 @@
+import mongoose from 'mongoose';
+import { Activity, ActivityFinalStatus, Center, Field, ServiceProvided } from '../interfaces';
+interface ActivityAttrs {
+    user: mongoose.Types.ObjectId;
+    company: mongoose.Types.ObjectId;
+    project: {
+        id: string;
+        name: string;
+        grade?: number;
+        fields?: Field[];
+        area?: number;
+        center?: Center;
+        timeElapsed?: number;
+        timeOnQueue?: number;
+        finalStatus?: ActivityFinalStatus;
+    };
+    serviceProvided?: ServiceProvided;
+    createdAt: Date;
+}
+type ActivityDoc = mongoose.Document & Activity;
+interface ActivityModel extends mongoose.Model<ActivityDoc> {
+    build(attrs: ActivityAttrs): ActivityDoc;
+}
+declare const ActivityModel: ActivityModel;
+export { ActivityModel, ActivityDoc };

package/build/models/activity.model.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityModel = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const interfaces_1 = require("../interfaces");
+const activitySchema = new mongoose_1.default.Schema({
+    user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'User',
+    },
+    company: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Company',
+    },
+    project: {
+        id: {
+            type: mongoose_1.default.Schema.Types.ObjectId,
+            required: true,
+        },
+        name: {
+            type: String,
+            required: true,
+        },
+        grade: {
+            type: Number,
+            required: false,
+        },
+        fields: {
+            type: [Object],
+            required: false,
+        },
+        area: {
+            type: Number,
+            required: false,
+        },
+        center: {
+            type: Object,
+            required: false,
+        },
+        timeElapsed: {
+            type: Number,
+            required: false,
+        },
+        timeOnQueue: {
+            type: Number,
+            required: false,
+        },
+        finalStatus: {
+            type: String,
+            enum: Object.values(interfaces_1.ActivityFinalStatus),
+            default: interfaces_1.ActivityFinalStatus.PROCESSING,
+        },
+    },
+    serviceProvided: {
+        type: Object,
+        required: false,
+    },
+    createdAt: {
+        type: Date,
+        required: true,
+    },
+}, {
+    toJSON: {
+        transform(_, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+        },
+    },
+});
+const autoPopulate = function (next) {
+    //@ts-ignore
+    this.populate('user').populate('company');
+    next();
+};
+activitySchema.pre('findOne', autoPopulate).pre('find', autoPopulate);
+activitySchema.statics.build = (attrs) => {
+    return new ActivityModel(attrs);
+};
+const ActivityModel = mongoose_1.default.model('Activity', activitySchema);
+exports.ActivityModel = ActivityModel;

package/build/models/company.model.d.ts

@@ -0,0 +1,15 @@
+import mongoose from 'mongoose';
+import { Company, CompanyEditMode } from '../interfaces';
+interface CompanyAttrs {
+    name: string;
+    blocked: boolean;
+    createdAt: Date;
+    createdBy: string;
+    editMode: CompanyEditMode;
+}
+type CompanyDoc = Company & mongoose.Document;
+interface CompanyModel extends mongoose.Model<CompanyDoc> {
+    build(attrs: CompanyAttrs): CompanyDoc;
+}
+declare const CompanyModel: CompanyModel;
+export { CompanyModel, CompanyDoc };

package/build/models/company.model.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompanyModel = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const companySchema = new mongoose_1.default.Schema({
+    name: {
+        type: String,
+        required: true,
+    },
+    blocked: {
+        type: Boolean,
+        required: true,
+    },
+    createdAt: {
+        type: Date,
+        required: true,
+    },
+    createdBy: {
+        type: String,
+        required: true,
+    },
+    editMode: {
+        type: {
+            canDownloadNP2: { type: Boolean, default: false },
+            canUseTools: { type: Boolean, default: false },
+        },
+        required: true,
+    },
+}, {
+    toJSON: {
+        transform: (_, ret) => {
+            ret.id = ret._id;
+            delete ret._id;
+        },
+    },
+});
+companySchema.statics.build = (attrs) => {
+    return new CompanyModel(attrs);
+};
+const CompanyModel = mongoose_1.default.model('Company', companySchema);
+exports.CompanyModel = CompanyModel;

package/build/models/index.d.ts

@@ -0,0 +1,8 @@
+export * from './activity.model';
+export * from './company.model';
+export * from './pixviewer-link.model';
+export * from './project.model';
+export * from './refund.model';
+export * from './reload.model';
+export * from './user.model';
+export * from './transaction.model';

package/build/models/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./activity.model"), exports);
+__exportStar(require("./company.model"), exports);
+__exportStar(require("./pixviewer-link.model"), exports);
+__exportStar(require("./project.model"), exports);
+__exportStar(require("./refund.model"), exports);
+__exportStar(require("./reload.model"), exports);
+__exportStar(require("./user.model"), exports);
+__exportStar(require("./transaction.model"), exports);

package/build/models/pixviewer-link.model.d.ts

@@ -0,0 +1,14 @@
+import mongoose from 'mongoose';
+import { PixViewerLink } from '../interfaces';
+import { UserDoc } from './user.model';
+interface PixViewerLinkAttrs {
+    user: UserDoc;
+    token: string;
+    createdAt: Date;
+}
+type PixViewerLinkDoc = PixViewerLink & mongoose.Document;
+interface PixViewerLinkModel extends mongoose.Model<PixViewerLinkDoc> {
+    build(attrs: PixViewerLinkAttrs): PixViewerLinkDoc;
+}
+declare const PixViewerLinkModel: PixViewerLinkModel;
+export { PixViewerLinkModel, PixViewerLinkDoc };

package/build/models/pixviewer-link.model.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixViewerLinkModel = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const pixViewerLinkSchema = new mongoose_1.default.Schema({
+    user: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+    },
+    token: {
+        type: String,
+        required: true,
+    },
+    createdAt: {
+        type: Date,
+        required: true,
+    },
+}, {
+    toJSON: {
+        transform(_, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+        },
+    },
+});
+pixViewerLinkSchema.statics.build = (attrs) => {
+    return new PixViewerLinkModel(attrs);
+};
+const PixViewerLinkModel = mongoose_1.default.model('PixViewerLink', pixViewerLinkSchema);
+exports.PixViewerLinkModel = PixViewerLinkModel;

package/build/models/project.model.d.ts

@@ -0,0 +1,26 @@
+import mongoose from 'mongoose';
+import { GapsOptions, HighlightType, PixViewerStatus, Project, ProjectBonusExportables, ProjectStatus, Weeds } from '../interfaces';
+import { UserDoc } from './user.model';
+import { CompanyDoc } from './company.model';
+interface ProjectAttrs {
+    user: UserDoc;
+    company: CompanyDoc;
+    name: string;
+    spacement: number;
+    gapsOptions: GapsOptions;
+    status: ProjectStatus;
+    createdAt: Date;
+    locale: 'pt-BR' | 'en' | 'es';
+    isDoubleRow?: boolean;
+    estimatedTimeInSeconds?: number;
+    highlightType?: HighlightType;
+    bonusExportables?: ProjectBonusExportables;
+    pixViewerStatus?: PixViewerStatus;
+    weeds?: Weeds;
+}
+type ProjectDoc = mongoose.Document & Project;
+interface ProjectModel extends mongoose.Model<ProjectDoc> {
+    build(attrs: ProjectAttrs): ProjectDoc;
+}
+declare const ProjectModel: ProjectModel;
+export { ProjectModel, ProjectDoc };

package/build/models/project.model.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectModel = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const interfaces_1 = require("../interfaces");
+const projectSchema = new mongoose_1.default.Schema({
+    user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'User',
+    },
+    company: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Company',
+    },
+    name: {
+        type: String,
+        required: true,
+    },
+    spacement: {
+        type: Number,
+        required: true,
+    },
+    gapsOptions: {
+        type: Object,
+        required: true,
+        default: {
+            minSize: 0,
+            minActSize: 0,
+            lengthNoGapEdge: 0,
+        },
+    },
+    status: {
+        type: String,
+        enum: Object.values(interfaces_1.ProjectStatus),
+        default: interfaces_1.ProjectStatus.READY,
+    },
+    sizeInMbs: {
+        type: Number,
+        required: false,
+        default: 0,
+    },
+    createdAt: {
+        type: Date,
+        required: true,
+    },
+    locale: {
+        type: String,
+        enum: ['pt-BR', 'en', 'es'],
+        required: true,
+    },
+    // Non required below.
+    isDoubleRow: {
+        type: Boolean,
+        required: false,
+    },
+    timeElapsedInSeconds: {
+        type: Number,
+        required: false,
+    },
+    estimatedTimeInSeconds: {
+        type: Number,
+        required: false,
+    },
+    center: {
+        type: Object,
+        required: false,
+    },
+    area: {
+        type: Number,
+        required: false,
+    },
+    fields: {
+        type: Array,
+        required: false,
+    },
+    tilesBBox: {
+        type: Object,
+        required: false,
+    },
+    goodPointsPercentage: {
+        type: Number,
+        required: false,
+    },
+    bonusExportables: {
+        type: Object,
+        required: false,
+    },
+    pixViewerStatus: {
+        type: String,
+        enum: Object.values(interfaces_1.PixViewerStatus),
+        required: false,
+    },
+    serviceProvided: {
+        type: Object,
+        required: false,
+    },
+    highlightType: {
+        type: String,
+        enum: Object.values(interfaces_1.HighlightType),
+        required: false,
+    },
+    grade: {
+        type: Number,
+        required: false,
+    },
+    weeds: {
+        type: Object,
+        required: false,
+    },
+}, {
+    toJSON: {
+        transform(_, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+        },
+    },
+});
+const autoPopulateOne = function (next) {
+    //@ts-ignore
+    this.populate('company').populate('user');
+    next();
+};
+const autoPopulateAll = function (next) {
+    //@ts-ignore
+    this.populate('user');
+    next();
+};
+projectSchema.pre('findOne', autoPopulateOne);
+projectSchema.pre('find', autoPopulateAll);
+// Pass the ts interface.
+projectSchema.statics.build = (attrs) => {
+    return new ProjectModel(attrs);
+};
+const ProjectModel = mongoose_1.default.model('Project', projectSchema);
+exports.ProjectModel = ProjectModel;

package/build/models/refund.model.d.ts

@@ -0,0 +1,18 @@
+import mongoose from 'mongoose';
+import { Refund } from '../interfaces';
+import { CompanyDoc } from './company.model';
+import { ReloadDoc } from './reload.model';
+import { ActivityDoc } from './activity.model';
+interface RefundAttrs {
+    company: CompanyDoc;
+    value: number;
+    fromActivity: ActivityDoc;
+    reloadsInvolved: ReloadDoc[];
+    createdAt: Date;
+}
+type RefundDoc = mongoose.Document & Refund;
+interface RefundModel extends mongoose.Model<RefundDoc> {
+    build(attrs: RefundAttrs): RefundDoc;
+}
+declare const RefundModel: RefundModel;
+export { RefundModel };

package/build/models/refund.model.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefundModel = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const refundSchema = new mongoose_1.default.Schema({
+    company: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Company',
+        required: true,
+    },
+    value: { type: Number, required: true },
+    createdAt: { type: Date, required: true },
+    fromActivity: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Activity',
+        required: true,
+    },
+    reloadsInvolved: [
+        {
+            type: mongoose_1.default.Schema.Types.ObjectId,
+            ref: 'Reload',
+            required: true,
+        },
+    ],
+}, {
+    toJSON: {
+        transform(_, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+        },
+    },
+});
+refundSchema.statics.build = (attrs) => {
+    return new RefundModel(attrs);
+};
+const autoPopulate = function (next) {
+    // @ts-ignore
+    this.populate('company').populate('fromActivity');
+    next();
+};
+refundSchema.pre('findOne', autoPopulate).pre('find', autoPopulate);
+const RefundModel = mongoose_1.default.model('Refund', refundSchema);
+exports.RefundModel = RefundModel;

package/build/models/reload.model.d.ts

@@ -0,0 +1,16 @@
+import mongoose from 'mongoose';
+import { Reload } from '../interfaces';
+import { CompanyDoc } from './company.model';
+interface ReloadAttrs {
+    company: CompanyDoc;
+    value: number;
+    availableValue: number;
+    createdAt: Date;
+    validUntil: Date;
+}
+type ReloadDoc = mongoose.Document & Reload;
+interface ReloadModel extends mongoose.Model<ReloadDoc> {
+    build(attrs: ReloadAttrs): ReloadDoc;
+}
+declare const ReloadModel: ReloadModel;
+export { ReloadModel, ReloadDoc };

package/build/models/reload.model.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReloadModel = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const reloadSchema = new mongoose_1.default.Schema({
+    company: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: 'Company',
+    },
+    value: {
+        type: Number,
+        required: true,
+    },
+    availableValue: {
+        type: Number,
+        required: true,
+    },
+    createdAt: {
+        type: Date,
+        required: true,
+    },
+    validUntil: {
+        type: Date,
+        required: true,
+    },
+}, {
+    timestamps: true,
+    toJSON: {
+        transform(_, ret) {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+        },
+    },
+});
+reloadSchema.statics.build = (attrs) => {
+    return new ReloadModel(attrs);
+};
+const autoPopulate = function (next) {
+    // @ts-ignore
+    this.populate('company');
+    next();
+};
+reloadSchema.pre('find', autoPopulate).pre('findOne', autoPopulate);
+const ReloadModel = mongoose_1.default.model('Reload', reloadSchema);
+exports.ReloadModel = ReloadModel;

package/build/models/transaction.model.d.ts

@@ -0,0 +1,18 @@
+import mongoose from 'mongoose';
+import { CompanyDoc } from './company.model';
+import { Transaction, TransactionProject, TransactionType } from '../interfaces';
+interface TransactionAttrs {
+    company: CompanyDoc;
+    userEmail: string;
+    currentBalance: number;
+    value: number;
+    type: TransactionType;
+    project?: TransactionProject;
+    createdAt: Date;
+}
+type TransactionDoc = mongoose.Document & Transaction;
+interface TransactionModel extends mongoose.Model<TransactionDoc> {
+    build(attrs: TransactionAttrs): TransactionDoc;
+}
+declare const TransactionModel: TransactionModel;
+export { TransactionModel, TransactionDoc };