@merkaly/api 0.2.5-4 → 0.2.5-6

package/src/modules/sale/customers/customer.controller.ts

@@ -0,0 +1,41 @@
+import { Body, Controller, Delete, Get, HttpCode, HttpStatus, Inject, Param, Patch, Post, Query } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstracts/abstract.controller';
+import { FindValidator, IdMongoValidator, ReadValidator } from '../../../abstracts/abstract.validator';
+import { CustomerEntity } from './customer.entity';
+import { CustomerRepository } from './customer.repository';
+import { CreateCustomerValidator, UpdateCustomerValidator } from './customer.validator';
+
+@Controller()
+@ApiTags('sale')
+export class CustomerController extends AbstractController {
+  @Inject()
+  protected readonly $repository: CustomerRepository;
+
+  @Get('/')
+  public async find(@Query() validator: FindValidator<CustomerEntity>) {
+    return this.$repository.find(validator);
+  }
+
+  @Get('/:id')
+  public read(@Param() { id }: IdMongoValidator, @Query() validator?: ReadValidator) {
+    return this.$repository.read(id, validator);
+  }
+
+  @Post('/')
+  @HttpCode(HttpStatus.CREATED)
+  public async create(@Body() validator: CreateCustomerValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Patch('/:id')
+  public async update(@Param() { id }: IdMongoValidator, @Body() validator: UpdateCustomerValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Delete('/:id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  public delete(@Param() { id }: IdMongoValidator) {
+    return this.$repository.delete(id);
+  }
+}

package/src/modules/sale/customers/customer.entity.ts

@@ -0,0 +1,19 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import { $collection, AbstractEntity } from '../../../abstracts/abstract.entity';
+import { AddressValidator } from '../orders/validators/address.validator';
+
+@Collection($collection)
+export class CustomerEntity extends AbstractEntity {
+  @Prop({ type: Schema.Types.String, required: true })
+  public name: string;
+
+  @Prop({ type: Schema.Types.String, unique: true, required: true })
+  public email: string;
+
+  @Prop({ type: Schema.Types.String, default: null })
+  public phone: string;
+
+  @Prop({ type: Schema.Types.Array, default: [] })
+  public addresses: AddressValidator[] = [];
+}

package/src/modules/sale/customers/customer.module.ts

@@ -0,0 +1,18 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstracts/abstract.router';
+import { CustomerController } from './customer.controller';
+import { CustomerRepository } from './customer.repository';
+
+export const metadata: ModuleMetadata = {
+  controllers: [CustomerController],
+  exports: [CustomerRepository],
+  imports: [],
+  providers: [CustomerRepository],
+};
+
+@Module(metadata)
+export class CustomerModule extends AbstractRouter {
+  public static readonly path = '/customers';
+
+  public static readonly module = CustomerModule;
+}

package/src/modules/sale/customers/customer.repository.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstracts/abstarct.repository';
+import { CustomerEntity } from './customer.entity';
+import { CustomerSchema } from './customer.schema';
+import { CreateCustomerValidator, UpdateCustomerValidator } from './customer.validator';
+
+@Injectable()
+export class CustomerRepository extends AbstractRepository<CustomerEntity> {
+  @InjectModel(CustomerSchema.name)
+  public readonly $model: Model<CustomerEntity>;
+
+  public async create(validator: CreateCustomerValidator) {
+    const customer = new this.$model();
+
+    customer.name = validator.name;
+    customer.email = validator.email;
+    customer.phone = validator.phone;
+    customer.addresses = validator.addresses;
+
+    await customer.save();
+
+    return customer;
+  }
+
+  public async update(id: string, validator: UpdateCustomerValidator): Promise<CustomerEntity> {
+    return super.read(id);
+  }
+}

package/src/modules/sale/customers/customer.schema.ts

@@ -0,0 +1,8 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { CustomerEntity } from './customer.entity';
+
+export namespace CustomerSchema {
+  export const name = 'sale_customers';
+
+  export const schema = SchemaFactory.createForClass(CustomerEntity);
+}

package/src/modules/sale/customers/customer.validator.ts

@@ -0,0 +1,43 @@
+import { Transform, Type } from 'class-transformer';
+import { IsArray, IsEmail, IsOptional, IsPhoneNumber, IsString, ValidateNested } from 'class-validator';
+import { AbstractValidator } from '../../../abstracts/abstract.validator';
+import { AddressValidator } from '../orders/validators/address.validator';
+
+export class CreateCustomerValidator extends AbstractValidator {
+  @IsString()
+  public name: string;
+
+  @IsEmail()
+  @Transform(({ value }) => String(value).toLowerCase())
+  public email: string;
+
+  @IsString()
+  @IsOptional()
+  public phone?: string;
+
+  @IsArray()
+  @Type(() => AddressValidator)
+  @ValidateNested()
+  public addresses?: AddressValidator[] = [];
+}
+
+export class UpdateCustomerValidator {
+  @IsString()
+  @IsOptional()
+  public name?: string;
+
+  @IsEmail()
+  @Transform(({ value }) => String(value).toLowerCase())
+  @IsOptional()
+  public email?: string;
+
+  @IsPhoneNumber()
+  @IsOptional()
+  public phone?: string;
+
+  @IsArray()
+  @Type(() => AddressValidator)
+  @ValidateNested()
+  @IsOptional()
+  public addresses?: AddressValidator[];
+}

package/src/modules/sale/orders/documents/address.document.ts

@@ -0,0 +1,22 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+
+export class AddressDocument {
+  @Prop({ required: true, type: Schema.Types.String })
+  public line1: string;
+
+  @Prop({ type: Schema.Types.String })
+  public line2: string;
+
+  @Prop({ required: true, type: Schema.Types.String })
+  public state: string;
+
+  @Prop({ required: true, type: Schema.Types.String })
+  public city: string;
+
+  @Prop({ type: Schema.Types.String })
+  public country: string;
+
+  @Prop({ required: true, type: Schema.Types.String })
+  public code: string;
+}

package/src/modules/sale/orders/documents/status.document.ts

@@ -0,0 +1,17 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import { MaybeEntity } from '../../../../abstracts/abstract.entity';
+import { UserEntity } from '../../../auth/users/user.entity';
+import { UserSchema } from '../../../auth/users/user.schema';
+import { OrderStatus } from '../enums/order.status';
+
+export class StatusDocument {
+  @Prop({ default: OrderStatus.CREATED, enum: OrderStatus, required: true, type: Schema.Types.String })
+  public name: OrderStatus;
+
+  @Prop({ ref: UserSchema.name, required: true, type: Schema.Types.ObjectId })
+  public user: MaybeEntity<UserEntity>;
+
+  @Prop({ default: () => new Date(), type: Schema.Types.Date })
+  public date = new Date();
+}

package/src/modules/sale/orders/entities/item.entity.ts

@@ -0,0 +1,24 @@
+import { Prop, SchemaFactory } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+import type { MaybeEntity } from '../../../../abstracts/abstract.entity';
+import { $collection } from '../../../../abstracts/abstract.entity';
+import { ProductEntity } from '../../../inventory/products/product.entity';
+import { ProductSchema } from '../../../inventory/products/product.schema';
+
+@Collection($collection)
+export class ItemEntity {
+  @Prop({ ref: ProductSchema.name, type: Schema.Types.ObjectId })
+  public product: MaybeEntity<ProductEntity>;
+
+  @Prop({ default: 0, type: Schema.Types.Number })
+  public price?: number;
+
+  @Prop({ type: Schema.Types.Number })
+  public quantity: number;
+
+  @Prop({ type: Schema.Types.String })
+  public description: string;
+}
+
+export const ItemSchema = SchemaFactory.createForClass(ItemEntity);

package/src/modules/sale/orders/enums/order.status.ts

@@ -0,0 +1,6 @@
+export enum OrderStatus {
+  CREATED = 'CREATED',
+  ACCEPTED = 'ACCEPTED',
+  COMPLETED = 'COMPLETED',
+  CANCELED = 'CANCELED',
+}

package/src/modules/sale/orders/order.controller.ts

@@ -0,0 +1,65 @@
+import { Body, Controller, Delete, Get, Inject, Param, Patch, Post, Query } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstracts/abstract.controller';
+import { FindValidator, IdMongoValidator, ReadValidator } from '../../../abstracts/abstract.validator';
+import { GetUser } from '../../../decorators/user.decorator';
+import { UserRepository } from '../../auth/users/user.repository';
+import { OrderEntity } from './order.entity';
+import { OrderRepository } from './order.repository';
+import { CreateOrderValidator, UpdateOrderStatusValidator, UpdateOrderValidator } from './order.validator';
+
+@Controller('/')
+@ApiTags('sales')
+export class OrderController extends AbstractController {
+  @Inject()
+  protected readonly $repository: OrderRepository;
+
+  @Inject()
+  protected readonly $userRepository: UserRepository;
+
+  @Get('/')
+  public find(@Query() validator: FindValidator<OrderEntity>) {
+    return this.$repository.find(validator);
+  }
+
+  @Post('/')
+  public async create(@Body() validator: CreateOrderValidator, @GetUser('sub') sub: string) {
+    // const user = await this.$userRepository.readByAuth0(sub)
+    const user = undefined;
+
+    return this.$repository.create(validator, user);
+  }
+
+  @Get('/me')
+  public async byCurrentUser(@Query() validator: FindValidator<OrderEntity>, @GetUser('sub') sub: string) {
+    const user = await this.$userRepository.readByAuth0(sub);
+
+    return this.$repository.findByUser(validator, user);
+  }
+
+  @Get('/:id')
+  public read(@Param() { id }: IdMongoValidator, @Query() validator?: ReadValidator) {
+    return this.$repository.read(id, validator);
+  }
+
+  @Patch('/:id')
+  public update(@Param('id') id: string, @Body() validator: UpdateOrderValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Delete('/:id')
+  public delete(@Param() { id }: IdMongoValidator) {
+    return this.$repository.delete(id);
+  }
+
+  @Patch('/:id/status/:type')
+  public async updateStatus(
+    @Param() { id, type }: UpdateOrderStatusValidator,
+    @Body() validator: UpdateOrderValidator,
+    @GetUser('sub') sub: string,
+  ) {
+    const user = await this.$userRepository.readByAuth0(sub);
+
+    return this.$repository.updateStatus(id, type, user);
+  }
+}

package/src/modules/sale/orders/order.entity.ts

@@ -0,0 +1,46 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import type { MaybeEntity } from '../../../abstracts/abstract.entity';
+import { $collection, AbstractEntity } from '../../../abstracts/abstract.entity';
+import { UserEntity } from '../../auth/users/user.entity';
+import { UserSchema } from '../../auth/users/user.schema';
+import { CustomerEntity } from '../customers/customer.entity';
+import { CustomerSchema } from '../customers/customer.schema';
+import { PaymentEntity } from '../payments/payment.entity';
+import { PaymentSchema } from '../payments/payment.schema';
+import { AddressDocument } from './documents/address.document';
+import { StatusDocument } from './documents/status.document';
+import { ItemEntity, ItemSchema } from './entities/item.entity';
+
+@Collection($collection)
+export class OrderEntity extends AbstractEntity {
+  @Prop({ default: () => 1, type: Schema.Types.Number })
+  public number = 1;
+
+  @Prop({ default: () => [], type: [ItemSchema] })
+  public items: ItemEntity[] = [];
+
+  @Prop({ default: () => [], type: Schema.Types.Array })
+  public status: StatusDocument[] = [];
+
+  @Prop({ ref: PaymentSchema.name, required: true, type: Schema.Types.ObjectId })
+  public payment: MaybeEntity<PaymentEntity>;
+
+  @Prop({ ref: CustomerSchema.name, required: true, type: Schema.Types.ObjectId })
+  public customer: MaybeEntity<CustomerEntity>;
+
+  @Prop({ ref: UserSchema.name, required: true, type: Schema.Types.ObjectId })
+  public user: MaybeEntity<UserEntity>;
+
+  @Prop({ default: () => new AddressDocument(), required: true, type: Schema.Types.Mixed })
+  public address = new AddressDocument();
+
+  @Prop({ type: Schema.Types.String })
+  public description: string;
+
+  public readonly total: number;
+
+  public readonly fullNumber: string;
+
+  public readonly lastStatus: StatusDocument;
+}

package/src/modules/sale/orders/order.module.ts

@@ -0,0 +1,22 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { UserRepository } from '../../auth/users/user.repository';
+import { ProductRepository } from '../../inventory/products/product.repository';
+import { PaymentRepository } from '../payments/payment.repository';
+import { OrderController } from './order.controller';
+import { OrderRepository } from './order.repository';
+
+export const metadata: ModuleMetadata = {
+  controllers: [OrderController],
+  exports: [OrderRepository],
+  imports: [],
+  providers: [OrderRepository, ProductRepository, PaymentRepository, UserRepository],
+};
+
+@Module(metadata)
+export class OrderModule {
+  public static readonly path = '/orders';
+
+  public static readonly module = OrderModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/sale/orders/order.repository.ts

@@ -0,0 +1,122 @@
+import { Inject, Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstracts/abstarct.repository';
+import { FindValidator } from '../../../abstracts/abstract.validator';
+import { UserEntity } from '../../auth/users/user.entity';
+import { UserRepository } from '../../auth/users/user.repository';
+import { ProductRepository } from '../../inventory/products/product.repository';
+import { PaymentRepository } from '../payments/payment.repository';
+import { CreatePaymentValidator } from '../payments/payment.validator';
+import { StatusDocument } from './documents/status.document';
+import { ItemEntity } from './entities/item.entity';
+import { OrderStatus } from './enums/order.status';
+import { OrderEntity } from './order.entity';
+import { OrderSchema } from './order.schema';
+import { CreateOrderValidator, UpdateOrderValidator } from './order.validator';
+
+export let autoIncrement = 1;
+
+@Injectable()
+export class OrderRepository extends AbstractRepository<OrderEntity> implements OnModuleInit {
+  @InjectModel(OrderSchema.name)
+  protected readonly $model: Model<OrderEntity>;
+
+  @Inject()
+  protected readonly $products: ProductRepository;
+
+  @Inject()
+  protected readonly $payments: PaymentRepository;
+
+  @Inject()
+  protected readonly $users: UserRepository;
+
+  public async onModuleInit() {
+    const lastOne = await this.$model.findOne<OrderEntity>(undefined, undefined, {
+      sort: { number: 'descending' },
+    });
+
+    if (!lastOne) {
+      return;
+    }
+
+    return (autoIncrement = lastOne.number);
+  }
+
+  public findByUser(validator: FindValidator<OrderEntity>, user: UserEntity) {
+    validator.filters.user = user._id;
+
+    return super.find(validator);
+  }
+
+  public async create(validator: CreateOrderValidator, user?: UserEntity) {
+    const order = new this.$model();
+
+    order.number = ++autoIncrement;
+    order.user = user;
+    order.address = validator.shipping.address;
+    order.description = validator.description;
+
+    const status = new StatusDocument();
+    status.date = new Date();
+    status.name = OrderStatus.CREATED;
+    status.user = order.user._id as any;
+
+    order.status.push(status);
+
+    for await (const itemValidator of validator.items) {
+      const item = new ItemEntity();
+
+      try {
+        const product = await this.$products.read(itemValidator.product);
+
+        item.description = itemValidator.description;
+        item.quantity = itemValidator.quantity;
+        item.product = product._id as any;
+        item.price = product.price;
+      } catch (reason: unknown) {
+        Logger.warn(`When creating order occurs: [${reason}] `);
+        continue;
+      }
+
+      order.items.push(item);
+    }
+
+    const payment = new CreatePaymentValidator();
+
+    payment.order = order._id;
+    payment.total = order.total;
+    payment.type = validator.billing.type;
+    payment.user = user._id;
+    payment.payload = validator.billing.payload;
+
+    order.payment = await this.$payments.create(payment, order);
+
+    await order.save();
+
+    return order;
+  }
+
+  public async update(id: string, validator: UpdateOrderValidator) {
+    const order = await this.read(id);
+
+    await order.save();
+
+    return order;
+  }
+
+  public async updateStatus(id: string, type: OrderStatus, user: UserEntity) {
+    const order = await this.read(id);
+
+    const status = new StatusDocument();
+    status.date = new Date();
+    status.name = type;
+    status.user = user;
+
+    order.status.push(status);
+
+    await order.save();
+
+    return order;
+  }
+}

package/src/modules/sale/orders/order.schema.ts

@@ -0,0 +1,36 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { OrderEntity } from './order.entity';
+
+export namespace OrderSchema {
+  export const name = 'sale_orders';
+
+  export const schema = SchemaFactory.createForClass(OrderEntity);
+
+  schema.virtual('total').get(function () {
+    return this.items.reduce((amount, current) => {
+      const price = current.price || 0;
+      const quantity = current.quantity || 1;
+
+      return amount + price * quantity;
+    }, 0);
+  });
+
+  schema.virtual('fullNumber').get(function () {
+    const createdAt = new Date(this.createdAt);
+
+    const year = `Y${createdAt.getFullYear().toString().slice(2)}`;
+    const month = `M${(createdAt.getMonth() + 1).toString().padStart(2, '0')}`;
+    const day = `D${createdAt.getDate().toString().padStart(2, '0')}`;
+
+    const date = `${year}${month}${day}`;
+    const number = this.number.toString().padStart(4, '0');
+
+    return `${date}-${number}`.toUpperCase();
+  });
+
+  schema.virtual('lastStatus').get(function () {
+    const [first] = this.status.reverse();
+
+    return first;
+  });
+}

package/src/modules/sale/orders/order.validator.ts

@@ -0,0 +1,44 @@
+import { Type } from 'class-transformer';
+import {
+  ArrayNotEmpty,
+  IsArray,
+  IsEnum,
+  IsNotEmptyObject,
+  IsOptional,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
+import { IdMongoValidator } from '../../../abstracts/abstract.validator';
+import { OrderStatus } from './enums/order.status';
+import { BillingValidator } from './validators/billing.validator';
+import { CreateItemValidator } from './validators/item.validator';
+import { ShippingValidator } from './validators/shipping.validator';
+
+export class CreateOrderValidator {
+  @IsArray()
+  @ArrayNotEmpty()
+  @Type(() => CreateItemValidator)
+  @ValidateNested()
+  public items: CreateItemValidator[] = [];
+
+  @Type(() => BillingValidator)
+  @ValidateNested()
+  @IsNotEmptyObject()
+  public billing = new BillingValidator();
+
+  @Type(() => ShippingValidator)
+  @ValidateNested()
+  @IsNotEmptyObject()
+  public shipping = new ShippingValidator();
+
+  @IsString()
+  @IsOptional()
+  public description = String();
+}
+
+export class UpdateOrderValidator extends CreateOrderValidator {}
+
+export class UpdateOrderStatusValidator extends IdMongoValidator {
+  @IsEnum(OrderStatus)
+  public type: OrderStatus;
+}

package/src/modules/sale/orders/validators/address.validator.ts

@@ -0,0 +1,50 @@
+import { IsISO31661Alpha2, IsOptional, IsString, Matches } from 'class-validator';
+
+export class CreateAddressValidator {
+  @IsString()
+  public street: string;
+
+  @IsString()
+  @IsOptional()
+  public complement: string;
+
+  @IsString()
+  public city: string;
+
+  @IsString()
+  public state: string;
+
+  @IsString()
+  public number: string;
+
+  @IsString()
+  @IsOptional()
+  public neighborhood: string;
+
+  @IsString()
+  @Matches(/[a-zA-Z0-9_-]{8}/, { message: 'zipCode must be valid' })
+  public zipCode: string;
+}
+
+export class AddressValidator {
+  @IsString()
+  public line1: string;
+
+  @IsString()
+  @IsOptional()
+  public line2: string;
+
+  @IsString()
+  public city: string;
+
+  @IsString()
+  public state: string;
+
+  @IsString()
+  @IsISO31661Alpha2()
+  public country: string;
+
+  @IsString()
+  @Matches(/[a-zA-Z0-9_-]{8}/, { message: 'zipCode must be valid' })
+  public code: string;
+}

package/src/modules/sale/orders/validators/billing.validator.ts

@@ -0,0 +1,11 @@
+import { BillingType } from '../../payments/enums/billing.type';
+import { AddressValidator } from './address.validator';
+import { PaymentValidator } from './payment.validator';
+
+export class BillingValidator {
+  public type: BillingType;
+
+  public payload = new PaymentValidator();
+
+  public address = new AddressValidator();
+}

package/src/modules/sale/orders/validators/item.validator.ts

@@ -0,0 +1,14 @@
+import { IsInt, IsMongoId, IsOptional, IsPositive, IsString } from 'class-validator';
+
+export class CreateItemValidator {
+  @IsMongoId()
+  public product: string;
+
+  @IsPositive()
+  @IsInt()
+  public quantity: number;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+}