c2-desafiox 1.0.106

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * c2-climbing-x — Modelagem Escalada X
+ * Times, campeonatos, fases, rodadas, confrontos, desafios e rodadas do desafio.
+ */
+export * from "./types";
+export * from "./models";
+export * from "./utils";

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * c2-climbing-x — Modelagem Escalada X
+ * Times, campeonatos, fases, rodadas, confrontos, desafios e rodadas do desafio.
+ */
+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("./types"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./utils"), exports);

package/dist/models/Access.d.ts

@@ -0,0 +1,55 @@
+import { Schema, Types } from "mongoose";
+import { IAccount } from "./Account";
+export interface IAccess {
+    account: Types.ObjectId | IAccount;
+    token: string;
+    addressIP: string;
+    userAgent: string;
+    notes: string;
+    latitude: number;
+    longitude: number;
+    tokenFCM: string;
+    active: boolean;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AccessSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {} & {
+    active: boolean;
+    account: Types.ObjectId;
+    token: string;
+    addressIP: string;
+    userAgent: string;
+    latitude: number;
+    longitude: number;
+    notes?: string | null | undefined;
+    tokenFCM?: string | null | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
+    active: boolean;
+    account: Types.ObjectId;
+    token: string;
+    addressIP: string;
+    userAgent: string;
+    latitude: number;
+    longitude: number;
+    notes?: string | null | undefined;
+    tokenFCM?: string | null | undefined;
+}>, {}> & import("mongoose").FlatRecord<{} & {
+    active: boolean;
+    account: Types.ObjectId;
+    token: string;
+    addressIP: string;
+    userAgent: string;
+    latitude: number;
+    longitude: number;
+    notes?: string | null | undefined;
+    tokenFCM?: string | null | undefined;
+}> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/dist/models/Access.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.AccessSchema = new mongoose_1.Schema({
+    account: { type: mongoose_1.Schema.Types.ObjectId, ref: "account", required: true },
+    token: { type: String, required: true },
+    addressIP: { type: String, required: true },
+    userAgent: { type: String, required: true },
+    notes: { type: String, required: false },
+    latitude: { type: Number, required: true, default: 0 },
+    longitude: { type: Number, required: true, default: 0 },
+    tokenFCM: { type: String },
+    active: { type: Boolean, required: true }
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});
+exports.AccessSchema.index({ account: 1, token: 1 }, { unique: true });

package/dist/models/Account.d.ts

@@ -0,0 +1,29 @@
+import { Schema, Types } from "mongoose";
+import { IFile } from "./File";
+export interface IAccount {
+    _id: Types.ObjectId;
+    name: string;
+    nickName: string;
+    socialId: string;
+    emailAccess: string;
+    passwordAccess: string;
+    salt: string;
+    phones: {
+        label: string;
+        value: string;
+    }[];
+    active: boolean;
+    pixKey?: string;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    image?: IFile;
+}
+export declare const AccountSchema: Schema<IAccount, import("mongoose").Model<IAccount, any, any, any, import("mongoose").Document<unknown, any, IAccount, any> & IAccount & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IAccount, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IAccount>, {}> & import("mongoose").FlatRecord<IAccount> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/Account.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountSchema = void 0;
+const mongoose_1 = require("mongoose");
+const File_1 = require("./File");
+exports.AccountSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    nickName: { type: String, required: true },
+    socialId: { type: String, required: true },
+    emailAccess: { type: String, required: true },
+    passwordAccess: { type: String, required: true },
+    salt: { type: String, required: true },
+    phones: { type: [{ label: String, value: String }], required: true },
+    image: { type: File_1.FileSchema, required: false },
+    active: { type: Boolean, required: true, default: true },
+    pixKey: { type: String, required: false }
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.AccountSchema.index({ name: 1 }, { unique: false });
+exports.AccountSchema.index({ nickName: 1 }, { unique: true });
+exports.AccountSchema.index({ socialId: 1 }, { unique: false });
+exports.AccountSchema.index({ emailAccess: 1 }, { unique: true });
+exports.AccountSchema.index({ phones: 1 }, { unique: false });
+exports.AccountSchema.index({ active: 1 }, { unique: false });

package/dist/models/AccountDeletionRequest.d.ts

@@ -0,0 +1,31 @@
+import { Schema, Types } from "mongoose";
+import { IAccount } from "./Account";
+export declare enum AccountDeletionRequestStatus {
+    PENDING = "PENDING",
+    PROCESSING = "PROCESSING",
+    DONE = "DONE",
+    ERROR = "ERROR"
+}
+export interface IAccountDeletionRequest {
+    _id: Types.ObjectId;
+    emailAccess: string;
+    nickName?: string;
+    reason?: string;
+    account?: Types.ObjectId | IAccount;
+    status: AccountDeletionRequestStatus;
+    processedAtDateTime?: Date;
+    errorMessage?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AccountDeletionRequestSchema: Schema<IAccountDeletionRequest, import("mongoose").Model<IAccountDeletionRequest, any, any, any, import("mongoose").Document<unknown, any, IAccountDeletionRequest, any> & IAccountDeletionRequest & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IAccountDeletionRequest, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IAccountDeletionRequest>, {}> & import("mongoose").FlatRecord<IAccountDeletionRequest> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/AccountDeletionRequest.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountDeletionRequestSchema = exports.AccountDeletionRequestStatus = void 0;
+const mongoose_1 = require("mongoose");
+var AccountDeletionRequestStatus;
+(function (AccountDeletionRequestStatus) {
+    AccountDeletionRequestStatus["PENDING"] = "PENDING";
+    AccountDeletionRequestStatus["PROCESSING"] = "PROCESSING";
+    AccountDeletionRequestStatus["DONE"] = "DONE";
+    AccountDeletionRequestStatus["ERROR"] = "ERROR";
+})(AccountDeletionRequestStatus || (exports.AccountDeletionRequestStatus = AccountDeletionRequestStatus = {}));
+exports.AccountDeletionRequestSchema = new mongoose_1.Schema({
+    emailAccess: { type: String, required: true },
+    nickName: { type: String, required: false },
+    reason: { type: String, required: false },
+    account: { type: mongoose_1.Schema.Types.ObjectId, ref: "account", required: false },
+    status: {
+        type: String,
+        enum: AccountDeletionRequestStatus,
+        required: true,
+        default: AccountDeletionRequestStatus.PENDING,
+    },
+    processedAtDateTime: { type: Date, required: false },
+    errorMessage: { type: String, required: false },
+    ipAddress: { type: String, required: false },
+    userAgent: { type: String, required: false },
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime",
+    },
+});
+exports.AccountDeletionRequestSchema.index({ emailAccess: 1 }, { unique: false });
+exports.AccountDeletionRequestSchema.index({ status: 1 }, { unique: false });
+exports.AccountDeletionRequestSchema.index({ createdAtDateTime: -1 }, { unique: false });

package/dist/models/AccountNotification.d.ts

@@ -0,0 +1,110 @@
+import { Schema, Types } from "mongoose";
+import { IAccount } from "./Account";
+import { IAdminNotification } from "./AdminNotification";
+export declare enum AccountNotificationStatus {
+    CREATED = "CREATED",
+    SENT = "SENT",
+    DELIVERED = "DELIVERED",
+    READ = "READ"
+}
+export interface IAccountNotification {
+    account: Types.ObjectId | IAccount;
+    adminNotification: Types.ObjectId | IAdminNotification;
+    status: AccountNotificationStatus;
+    push: boolean;
+    title: string;
+    message: string;
+    redirect: string;
+    metadata: Map<string, string>;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AccountNotificationSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {
+    push: boolean;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    message: string;
+    account: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    status: string;
+    title: string;
+    adminNotification: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    redirect?: string | undefined;
+    metadata?: Map<string, string> | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    push: boolean;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    message: string;
+    account: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    status: string;
+    title: string;
+    adminNotification: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    redirect?: string | undefined;
+    metadata?: Map<string, string> | undefined;
+}>> & import("mongoose").FlatRecord<{
+    push: boolean;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    message: string;
+    account: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    status: string;
+    title: string;
+    adminNotification: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    redirect?: string | undefined;
+    metadata?: Map<string, string> | undefined;
+}> & {
+    _id: Types.ObjectId;
+}>;

package/dist/models/AccountNotification.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountNotificationSchema = exports.AccountNotificationStatus = void 0;
+const mongoose_1 = require("mongoose");
+var AccountNotificationStatus;
+(function (AccountNotificationStatus) {
+    AccountNotificationStatus["CREATED"] = "CREATED";
+    AccountNotificationStatus["SENT"] = "SENT";
+    AccountNotificationStatus["DELIVERED"] = "DELIVERED";
+    AccountNotificationStatus["READ"] = "READ";
+})(AccountNotificationStatus || (exports.AccountNotificationStatus = AccountNotificationStatus = {}));
+exports.AccountNotificationSchema = new mongoose_1.Schema({
+    account: { type: mongoose_1.Types.ObjectId, ref: "account", required: true },
+    adminNotification: { type: mongoose_1.Types.ObjectId, ref: "admin-notification", required: true },
+    status: { type: String, enum: AccountNotificationStatus, required: true, default: AccountNotificationStatus.CREATED },
+    push: { type: Boolean, required: true, default: false },
+    title: { type: String, required: true },
+    message: { type: String, required: true },
+    redirect: { type: String, required: false },
+    metadata: { type: Map, of: String, required: false },
+    createdAtDateTime: { type: Date, required: true },
+    updatedAtDateTime: { type: Date, required: true }
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});

package/dist/models/AdminComunication.d.ts

@@ -0,0 +1,102 @@
+import { Schema, Types } from "mongoose";
+import { IAdminTemplatePush } from "./AdminTemplatePush";
+import { IAdminTemplateEmail } from "./AdminTemplateEmail";
+export declare enum AdminComunicationStatus {
+    DRAFT = "DRAFT",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export interface IAdminComunication {
+    _id: Types.ObjectId;
+    key: string;
+    name: string;
+    description?: string;
+    templateEmail?: Types.ObjectId | IAdminTemplateEmail;
+    templatePush?: Types.ObjectId | IAdminTemplatePush;
+    status: AdminComunicationStatus;
+    requiredVariables?: string[];
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AdminComunicationSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {} & {
+    name: string;
+    status: string;
+    key: string;
+    description?: string | null | undefined;
+    templateEmail?: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    } | null | undefined;
+    templatePush?: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    } | null | undefined;
+    requiredVariables?: string[] | null | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
+    name: string;
+    status: string;
+    key: string;
+    description?: string | null | undefined;
+    templateEmail?: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    } | null | undefined;
+    templatePush?: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    } | null | undefined;
+    requiredVariables?: string[] | null | undefined;
+}>, {}> & import("mongoose").FlatRecord<{} & {
+    name: string;
+    status: string;
+    key: string;
+    description?: string | null | undefined;
+    templateEmail?: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    } | null | undefined;
+    templatePush?: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    } | null | undefined;
+    requiredVariables?: string[] | null | undefined;
+}> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/dist/models/AdminComunication.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminComunicationSchema = exports.AdminComunicationStatus = void 0;
+const mongoose_1 = require("mongoose");
+var AdminComunicationStatus;
+(function (AdminComunicationStatus) {
+    AdminComunicationStatus["DRAFT"] = "DRAFT";
+    AdminComunicationStatus["ACTIVE"] = "ACTIVE";
+    AdminComunicationStatus["INACTIVE"] = "INACTIVE";
+})(AdminComunicationStatus || (exports.AdminComunicationStatus = AdminComunicationStatus = {}));
+exports.AdminComunicationSchema = new mongoose_1.Schema({
+    key: { type: String, required: true },
+    name: { type: String, required: true },
+    description: { type: String, required: false },
+    templateEmail: { type: mongoose_1.Types.ObjectId, ref: "admin-template-email", required: false },
+    templatePush: { type: mongoose_1.Types.ObjectId, ref: "admin-template-push", required: false },
+    status: { type: String, enum: AdminComunicationStatus, required: true, default: AdminComunicationStatus.DRAFT },
+    requiredVariables: { type: [String], required: false },
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});
+exports.AdminComunicationSchema.index({ name: 1 }, { unique: true });
+exports.AdminComunicationSchema.index({ key: 1 }, { unique: true });