@merkaly/api 0.2.4-5 → 0.2.4-7

package/src/modules/inventory/products/validators/dimension.validator.ts

@@ -0,0 +1,19 @@
+import { IsNumber, IsOptional } from 'class-validator';
+
+export class ProductDimensionValidator {
+  @IsNumber()
+  @IsOptional()
+  public weight? = 0;
+
+  @IsNumber()
+  @IsOptional()
+  public height? = 0;
+
+  @IsNumber()
+  @IsOptional()
+  public width? = 0;
+
+  @IsNumber()
+  @IsOptional()
+  public depth? = 0;
+}

package/src/modules/inventory/products/validators/price.validator.ts

@@ -0,0 +1,10 @@
+import { IsNumber, IsOptional } from 'class-validator';
+
+export class ProductPriceValidator {
+  @IsNumber()
+  public sale = 0;
+
+  @IsNumber()
+  @IsOptional()
+  public purchase? = 0;
+}

package/src/modules/inventory/products/validators/seo.validator.ts

@@ -0,0 +1,15 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class ProductSeoValidator {
+  @IsString()
+  @IsOptional()
+  public title? = String();
+
+  @IsString()
+  @IsOptional()
+  public slug? = String();
+
+  @IsString()
+  @IsOptional()
+  public description? = String();
+}

package/src/modules/inventory/properties/property.controller.ts

@@ -0,0 +1,56 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UseFilters,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstract/abstract.controller';
+import { FindValidator } from '../../../abstract/abstract.validator';
+import { PropertyEntity } from './property.entity';
+import { PropertyException } from './property.exception';
+import { PropertyRepository } from './property.repository';
+import { CreatePropertyValidator, UpdatePropertyValidator } from './property.validator';
+
+@Controller()
+@UseFilters(PropertyException)
+@ApiTags('inventory')
+export class PropertyController extends AbstractController<PropertyEntity> {
+  @Inject()
+  protected readonly $repository: PropertyRepository;
+
+  @Get('/')
+  public async find(@Query() validator: FindValidator<PropertyEntity>) {
+    return super.find(validator);
+  }
+
+  @Post('/')
+  @HttpCode(HttpStatus.CREATED)
+  public async create(@Body() validator: CreatePropertyValidator) {
+    return super.create(validator);
+  }
+
+  @Get('/:id')
+  public async read(@Param('id') id: string) {
+    return super.read(id);
+  }
+
+  @Patch('/:id')
+  public async update(@Param('id') id: string, @Body() validator: UpdatePropertyValidator) {
+    return super.update(id, validator);
+  }
+
+  @Delete('/:id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  public async delete(@Param('id') id: string) {
+    return super.delete(id);
+  }
+}

package/src/modules/inventory/properties/property.entity.ts

@@ -0,0 +1,18 @@
+import { Prop, Schema } from '@nestjs/mongoose';
+import { Schema as MongoSchema } from 'mongoose';
+import { AbstractEntity } from '../../../abstract/abstract.entity';
+import { PropertyType } from './property.validator';
+
+@Schema({ timestamps: true })
+export class PropertyEntity extends AbstractEntity {
+  public static readonly $index = 'inventory_properties';
+
+  @Prop({ type: MongoSchema.Types.String, required: true, unique: true, length: 32 })
+  public name: string;
+
+  @Prop({ type: MongoSchema.Types.String, required: true, length: 64 })
+  public title: string;
+
+  @Prop({ type: MongoSchema.Types.String, default: PropertyType.STRING })
+  public type: string;
+}

package/src/modules/inventory/properties/property.exception.ts

@@ -0,0 +1,9 @@
+import { Catch, HttpException } from '@nestjs/common';
+import { AbstractException } from '../../../abstract/abstract.exception';
+
+@Catch()
+export class PropertyException extends AbstractException {
+  public handleError(exception: HttpException) {
+    return exception;
+  }
+}

package/src/modules/inventory/properties/property.listener.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { AbsctractListener } from '../../../abstract/absctract.listener';
+
+export enum PropertyEvent {
+  ALL_EVENTS = 'database.inventory.property.**',
+
+  PRE_CREATE = 'database.inventory.property.create.pre',
+  POST_CREATE = 'database.inventory.property.create.post',
+
+  PRE_UPDATE = 'database.inventory.property.update.pre',
+  POST_UPDATE = 'database.inventory.property.update.post',
+
+  PRE_DELETE = 'database.inventory.property.delete.pre',
+  POST_DELETE = 'database.inventory.property.delete.post',
+}
+
+@Injectable()
+export class PropertyListener extends AbsctractListener {
+
+}

package/src/modules/inventory/properties/property.module.ts

@@ -0,0 +1,21 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstract/abstract.router';
+import { PropertyController } from './property.controller';
+import { PropertyListener } from './property.listener';
+import { PropertyRepository } from './property.repository';
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [PropertyController],
+  providers: [PropertyRepository, PropertyListener],
+  exports: [PropertyRepository],
+};
+
+@Module(metadata)
+export class PropertyModule extends AbstractRouter {
+  public static readonly path = '/properties';
+
+  public static readonly module = PropertyModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/inventory/properties/property.repository.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstract/abstract.repository';
+import { PropertyEntity } from './property.entity';
+
+@Injectable()
+export class PropertyRepository extends AbstractRepository<PropertyEntity> {
+  @InjectModel(PropertyEntity.$index)
+  public readonly $model: Model<PropertyEntity>;
+
+  public create(params: any): Promise<PropertyEntity> {
+    return Promise.resolve(undefined);
+  }
+
+  public delete(id: string): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+
+  public update(id: string, params: unknown): Promise<PropertyEntity> {
+    return Promise.resolve(undefined);
+  }
+}

package/src/modules/inventory/properties/property.schema.ts

@@ -0,0 +1,4 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { PropertyEntity } from './property.entity';
+
+export const PropertySchema = SchemaFactory.createForClass(PropertyEntity);

package/src/modules/inventory/properties/property.validator.ts

@@ -0,0 +1,27 @@
+import { IsOptional, IsString } from 'class-validator';
+import { AbstractValidator } from "../../../abstract/abstract.validator";
+
+export enum PropertyType {
+  STRING = 'STRING',
+}
+
+export class CreatePropertyValidator extends AbstractValidator {
+  @IsString()
+  public name: string;
+
+  @IsString()
+  public title: string;
+
+  @IsString()
+  public type: string;
+}
+
+export class UpdatePropertyValidator extends AbstractValidator {
+  @IsString()
+  @IsOptional()
+  public name?: string;
+
+  @IsString()
+  @IsOptional()
+  public title?: string;
+}

package/src/modules/sales/clients/client.controller.ts

@@ -0,0 +1,60 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UseFilters,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstract/abstract.controller';
+import { FindValidator } from '../../../abstract/abstract.validator';
+import { Auth0Service } from '../../../services/auth0.service';
+import { ClientEntity } from './client.entity';
+import { ClientException } from './client.exception';
+import { ClientRepository } from './client.repository';
+import { CreateClientValidator, UpdateClientValidator } from './client.validator';
+
+@Controller()
+@UseFilters(ClientException)
+@ApiTags('orders')
+export class ClientController extends AbstractController<ClientEntity> {
+  @Inject()
+  protected readonly $repository: ClientRepository;
+
+  @Inject()
+  protected readonly $auth0: Auth0Service;
+
+  @Get('/')
+  public async find(@Query() validator: FindValidator<ClientEntity>) {
+    return this.$repository.find(validator);
+  }
+
+  @Get('/:id')
+  public async read(@Param('id') id: string) {
+    return this.$repository.read(id);
+  }
+
+  @Post('/')
+  @HttpCode(HttpStatus.CREATED)
+  public async create(@Body() validator: CreateClientValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Patch('/:id')
+  public async update(@Param('id') id: string, @Body() validator: UpdateClientValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Delete('/:id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  public async delete(@Param('id') id: string) {
+    return this.$repository.delete(id);
+  }
+}

package/src/modules/sales/clients/client.entity.ts

@@ -0,0 +1,25 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { User } from 'auth0';
+import { Schema } from 'mongoose';
+import { AbstractEntity } from '../../../abstract/abstract.entity';
+import { MetaAddress } from "../../../types";
+
+@Collection({ timestamps: true })
+export class ClientEntity extends AbstractEntity implements User {
+  public static readonly $index = 'store_clients';
+
+  @Prop({ type: Schema.Types.String, required: true })
+  public readonly name: string;
+
+  @Prop({ type: Schema.Types.String, unique: true, required: true })
+  public readonly email: string;
+
+  @Prop({ type: Schema.Types.String, default: null })
+  public readonly phone?: string;
+
+  @Prop({ type: Schema.Types.String, unique: true })
+  public readonly identificationNumber: string;
+
+  @Prop({ type: Schema.Types.Array, default: [] })
+  public readonly addresses: MetaAddress[] = [];
+}

package/src/modules/sales/clients/client.exception.ts

@@ -0,0 +1,9 @@
+import { Catch, HttpException } from '@nestjs/common';
+import { AbstractException } from '../../../abstract/abstract.exception';
+
+@Catch()
+export class ClientException extends AbstractException {
+  public handleError(exception: HttpException) {
+    return exception;
+  }
+}

package/src/modules/sales/clients/client.listener.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { AbsctractListener } from '../../../abstract/absctract.listener';
+
+export enum ClientEvent {
+  ALL_EVENTS = 'database.store.client.**',
+
+  PRE_CREATE = 'database.store.client.create.pre',
+  POST_CREATE = 'database.store.client.create.post',
+
+  PRE_UPDATE = 'database.store.client.update.pre',
+  POST_UPDATE = 'database.store.client.update.post',
+
+  PRE_DELETE = 'database.store.client.delete.pre',
+  POST_DELETE = 'database.store.client.delete.post',
+}
+
+@Injectable()
+export class ClientListener extends AbsctractListener {
+
+}

package/src/modules/sales/clients/client.module.ts

@@ -0,0 +1,19 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstract/abstract.router';
+import { ClientController } from './client.controller';
+import { ClientListener } from './client.listener';
+import { ClientRepository } from './client.repository';
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [ClientController],
+  providers: [ClientRepository, ClientListener],
+  exports: [ClientRepository],
+};
+
+@Module(metadata)
+export class ClientModule extends AbstractRouter {
+  public static readonly path = '/clients';
+
+  public static readonly module = ClientModule;
+}

package/src/modules/sales/clients/client.repository.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, UpdateQuery } from 'mongoose';
+import { Mutable } from 'type-fest';
+import { AbstractRepository } from '../../../abstract/abstract.repository';
+import { ClientEntity } from './client.entity';
+import { CreateClientValidator, UpdateClientValidator } from './client.validator';
+
+@Injectable()
+export class ClientRepository extends AbstractRepository<ClientEntity> {
+  @InjectModel(ClientEntity.$index)
+  public readonly $model: Model<ClientEntity>;
+
+  public async create(validator: CreateClientValidator) {
+    const client: Mutable<ClientEntity> = new this.$model();
+
+    client.name = validator.name;
+    client.email = validator.email;
+    client.phone = validator.phone;
+    client.identificationNumber = validator.identificationNumber;
+    client.addresses = validator.addresses;
+
+    return super.$create(client);
+  }
+
+  public async update(id: string, validator: UpdateClientValidator): Promise<ClientEntity> {
+    const query: UpdateQuery<ClientEntity> = {
+      $set: {},
+    };
+
+    return super.$update(id, query);
+  }
+
+  public delete(id: string): Promise<void> {
+    return super.$delete(id);
+  }
+}

package/src/modules/sales/clients/client.schema.ts

@@ -0,0 +1,4 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { ClientEntity } from './client.entity';
+
+export const ClientSchema = SchemaFactory.createForClass(ClientEntity);

package/src/modules/sales/clients/client.validator.ts

@@ -0,0 +1,43 @@
+import { Transform } from 'class-transformer';
+import { IsArray, IsEmail, IsOptional, IsPhoneNumber, IsString } from 'class-validator';
+import { MetaAddress } from "../../../types";
+import { AbstractValidator } from "../../../abstract/abstract.validator";
+
+export class CreateClientValidator extends AbstractValidator {
+  @IsString()
+  public name: string;
+
+  @IsEmail()
+  @Transform(({ value }) => String(value).toLowerCase())
+  public email: string;
+
+  @IsString()
+  @IsOptional()
+  public phone?: string;
+
+  @IsString()
+  public identificationNumber: string;
+
+  @IsArray()
+  public addresses: MetaAddress[];
+}
+
+export class UpdateClientValidator extends CreateClientValidator {
+  @IsString()
+  @IsOptional()
+  public name: string;
+
+  @IsEmail()
+  @Transform(({ value }) => String(value).toLowerCase())
+  @IsOptional()
+  public email: string;
+
+  @IsPhoneNumber()
+  @IsOptional()
+  public phone: string;
+
+  @IsString()
+  @IsOptional()
+  public identificationNumber: string;
+}
+

package/src/modules/sales/orders/billing/billing.entity.ts

@@ -0,0 +1,22 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+import { BillingMethod } from "./billing.types";
+import { BillingStatusEntity } from "./entities/status.entity";
+import { BillingAddressEntity } from "./entities/address.entity";
+import { BillingCustomerEntity } from "./entities/customer.entity";
+
+@Collection({})
+export class BillingEntity extends Map {
+  @Prop({ type: Schema.Types.Map, ref: () => BillingAddressEntity, default: new BillingAddressEntity() })
+  public address = new BillingAddressEntity();
+
+  @Prop({ type: Schema.Types.Map, ref: () => BillingCustomerEntity, default: new BillingCustomerEntity() })
+  public customer = new BillingCustomerEntity();
+
+  @Prop({ type: Schema.Types.String, enum: BillingMethod, required: true })
+  public method: BillingMethod;
+
+  @Prop({ type: Schema.Types.Array, default: [] })
+  public status: BillingStatusEntity[] = [];
+}

package/src/modules/sales/orders/billing/billing.types.ts

@@ -0,0 +1,10 @@
+export enum BillingMethod {
+  CASH = 'CASH',
+  CARD = 'CARD',
+  TRANSFER = 'TRANSFER',
+}
+
+export enum BillingStatus {
+  UNPAID = 'UNPAID',
+  PAID = 'PAID',
+}

package/src/modules/sales/orders/billing/billing.validator.ts

@@ -0,0 +1,21 @@
+import { Type } from 'class-transformer';
+import { IsEnum, IsNotEmptyObject, ValidateNested } from 'class-validator';
+import 'reflect-metadata';
+import { BillingMethod } from "./billing.types";
+import { BillingCustomerValidator } from "./validators/customer.validator";
+import { BillingAddressValidator } from "./validators/address.validator";
+
+export class CreateBillingValidator {
+  @ValidateNested()
+  @Type(() => BillingCustomerValidator)
+  @IsNotEmptyObject()
+  public customer = new BillingCustomerValidator();
+
+  @ValidateNested()
+  @Type(() => BillingAddressValidator)
+  @IsNotEmptyObject()
+  public address = new BillingAddressValidator();
+
+  @IsEnum(BillingMethod)
+  public method: BillingMethod;
+}

package/src/modules/sales/orders/billing/entities/address.entity.ts

@@ -0,0 +1,27 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import { MetaAddress } from "../../../../../types";
+
+@Collection()
+export class BillingAddressEntity extends Map implements MetaAddress {
+  @Prop({ type: Schema.Types.String, required: true })
+  public country: string;
+
+  @Prop({ type: Schema.Types.String, required: true })
+  public code: string;
+
+  @Prop({ type: Schema.Types.String, required: true })
+  public street: string;
+
+  @Prop({ type: Schema.Types.String })
+  public number: string;
+
+  @Prop({ type: Schema.Types.String })
+  public complement: string;
+
+  @Prop({ type: Schema.Types.String, required: true })
+  public city: string;
+
+  @Prop({ type: Schema.Types.String, required: true })
+  public state: string;
+}

package/src/modules/sales/orders/billing/entities/customer.entity.ts

@@ -0,0 +1,14 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+
+@Collection({})
+export class BillingCustomerEntity extends Map {
+  @Prop({ type: Schema.Types.String, required: true })
+  public name: string;
+
+  @Prop({ type: Schema.Types.String })
+  public email: string;
+
+  @Prop({ type: Schema.Types.String })
+  public phone: string;
+}

package/src/modules/sales/orders/billing/entities/status.entity.ts

@@ -0,0 +1,16 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+import { BillingStatus } from "../billing.types";
+
+@Collection({ timestamps: true })
+export class BillingStatusEntity {
+  @Prop({ type: Schema.Types.String, enum: BillingStatus, required: true })
+  public name: BillingStatus;
+
+  @Prop({ type: Schema.Types.String })
+  public user: string;
+
+  @Prop({ type: Schema.Types.Date })
+  public date;
+}

package/src/modules/sales/orders/billing/validators/address.validator.ts

@@ -0,0 +1,28 @@
+import { IsISO31661Alpha2, IsOptional, IsString } from 'class-validator';
+import { MetaAddress } from "../../../../../types";
+
+export class BillingAddressValidator implements MetaAddress {
+  @IsISO31661Alpha2()
+  public country = String();
+
+  @IsString()
+  public code = String();
+
+  @IsString()
+  public street = String();
+
+  @IsString()
+  @IsOptional()
+  public number = String();
+
+  @IsString()
+  @IsOptional()
+  public complement?: string = undefined;
+
+  @IsString()
+  public city = String();
+
+  @IsString()
+  public state = String();
+}
+

package/src/modules/sales/orders/billing/validators/customer.validator.ts

@@ -0,0 +1,14 @@
+import { IsEmail, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class BillingCustomerValidator {
+  @IsString()
+  @IsNotEmpty()
+  public name = String();
+
+  @IsEmail()
+  public email = String();
+
+  @IsString()
+  @IsOptional()
+  public phone?: string = undefined;
+}

package/src/modules/sales/orders/customer/customer.entity.ts

@@ -0,0 +1,14 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+
+@Collection()
+export class CustomerEntity extends Map {
+  @Prop({ type: Schema.Types.String, required: true })
+  public name: string;
+
+  @Prop({ type: Schema.Types.String })
+  public email: string;
+
+  @Prop({ type: Schema.Types.String })
+  public phone: string;
+}

package/src/modules/sales/orders/customer/customer.validator.ts

@@ -0,0 +1,14 @@
+import { IsEmail, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class CustomerValidator {
+  @IsString()
+  @IsNotEmpty()
+  public name = String();
+
+  @IsEmail()
+  public email = String();
+
+  @IsString()
+  @IsOptional()
+  public phone?: string = undefined;
+}