@merkaly/api 0.2.4-6 → 0.2.4-7

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;
+}

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

@@ -0,0 +1,21 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema, Types } from 'mongoose';
+import { AbstractEntity } from '../../../../abstract/abstract.entity';
+import { ProductEntity } from '../../../inventory/products/product.entity';
+
+@Collection({ timestamps: true, toJSON: { virtuals: true } })
+export class ItemEntity extends AbstractEntity {
+  @Prop({ type: Schema.Types.Number, default: 1 })
+  public quantity: number;
+
+  @Prop({ type: Schema.Types.Number, default: 0 })
+  public price: number;
+
+  @Prop({ type: Schema.Types.Number, default: 0 })
+  public refund: number;
+
+  @Prop({ type: Types.ObjectId, ref: ProductEntity.$index, required: true })
+  public product: ProductEntity;
+
+  public readonly total: number
+}

package/src/modules/sales/orders/item/item.schema.ts

@@ -0,0 +1,8 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { ItemEntity } from './item.entity';
+
+export const ItemSchema = SchemaFactory.createForClass(ItemEntity);
+
+ItemSchema.virtual('total').get<ItemEntity>(function () {
+  return this.price * this.quantity
+})

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

@@ -0,0 +1,10 @@
+import { IsMongoId, IsNotEmpty, IsNumber } from 'class-validator';
+
+export class CreateItemValidator {
+  @IsNumber()
+  @IsNotEmpty()
+  public quantity = 1;
+
+  @IsMongoId()
+  public product: string;
+}

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

@@ -0,0 +1,93 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Param,
+  ParseArrayPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstract/abstract.controller';
+import { FindValidator } from '../../../abstract/abstract.validator';
+import { GetUser } from '../../../decorators/user.decorator';
+import { OrderEntity } from './order.entity';
+import { OrderRepository } from './order.repository';
+import {
+  ChangeOrderStatusValidator,
+  CreateOrderValidator,
+  GetByStatus,
+  RefundOrderItemsValidator,
+  UpdateOrderValidator
+} from './order.validator';
+import { PopulateOptions } from "mongoose";
+
+@Controller()
+@ApiTags('orders')
+export class OrderController extends AbstractController<OrderEntity> {
+  @Inject()
+  protected readonly $repository: OrderRepository;
+
+  @Get('/')
+  public async find(@Query() validator: FindValidator<OrderEntity>) {
+    return this.$repository.find(validator);
+  }
+
+  @Get('/mine')
+  public async myOrders(@GetUser('sub') user: string, @Query() validator: FindValidator<OrderEntity>) {
+    return this.$repository.findByUser(user, validator);
+  }
+
+  @Get('/:id')
+  public async read(@Param('id') id: string, @Query() validator: FindValidator<OrderEntity>) {
+    return this.$repository.read(id, validator.join);
+  }
+
+  @Post('/')
+  @HttpCode(HttpStatus.CREATED)
+  public async create(@Body() validator: CreateOrderValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Patch('/:id')
+  public async update(@Param('id') id: string, @Body() validator: UpdateOrderValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Post('/:id/status')
+  public async changeStatus(@Param('id') id: string, @Body() validator: ChangeOrderStatusValidator) {
+    return this.$repository.changeStatus(id, validator);
+  }
+
+  @Delete('/:id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  public async delete(@Param('id') id: string) {
+    return this.$repository.delete(id);
+  }
+
+  @Post('/:id/refund')
+  public async refund(
+    @Param('id') id: string,
+    @Body(new ParseArrayPipe({ items: RefundOrderItemsValidator })) validator: RefundOrderItemsValidator[]) {
+
+    return this.$repository.refundItems(id, validator);
+  }
+
+  @Get('/status/:status')
+  public async status(
+    @Param() { status }: GetByStatus,
+    @Query() validator: FindValidator<OrderEntity>): Promise<OrderEntity[]> {
+
+    const query = this.$repository.$model
+      .find({ $expr: { $eq: [{ "$arrayElemAt": ["$status.name", -1] }, status] } })
+
+    validator.join && query.populate(validator.join as (PopulateOptions | string)[]);
+
+    return query.exec()
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import { AbstractEntity } from '../../../abstract/abstract.entity';
+import { BillingEntity } from './billing/billing.entity';
+import { ItemEntity } from './item/item.entity';
+import { ItemSchema } from './item/item.schema';
+import { ShippingEntity } from './shipping/shipping.entity';
+import { StatusEntity } from './status/status.entity';
+import { ClientEntity } from "../clients/client.entity";
+import { CustomerEntity } from "./customer/customer.entity";
+
+@Collection({ timestamps: true, toJSON: { virtuals: true } })
+export class OrderEntity extends AbstractEntity {
+  public static readonly $index = 'store_orders';
+
+  @Prop({ type: Schema.Types.Number, required: true, unique: true })
+  public number: number;
+
+  @Prop({ type: Schema.Types.Array, default: [] })
+  public status: StatusEntity[] = [];
+
+  @Prop({ type: [ItemSchema], default: [] })
+  public items: ItemEntity[] = [];
+
+  @Prop({ type: Schema.Types.ObjectId, ref: ClientEntity.$index })
+  public client?: ClientEntity;
+
+  @Prop({ type: Schema.Types.Map, ref: () => BillingEntity, default: new BillingEntity() })
+  public billing = new BillingEntity()
+
+  @Prop({ type: Schema.Types.Map, ref: () => ShippingEntity, default: new ShippingEntity() })
+  public shipping = new ShippingEntity();
+
+  @Prop({ type: Schema.Types.Map, ref: () => CustomerEntity, default: new CustomerEntity() })
+  public customer = new CustomerEntity();
+
+  @Prop({ type: Schema.Types.String, default: null })
+  public notes: string;
+
+  @Prop({ type: Schema.Types.String, required: true })
+  public createdBy: string;
+
+  public readonly fullNumber: string
+  public readonly total: number
+  public readonly subtotal: number
+  public readonly currentStatus: StatusEntity
+}

package/src/modules/sales/orders/order.listener.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { AbsctractListener } from '../../../abstract/absctract.listener';
+
+export enum OrderEvent {
+  PRE_CREATE = 'database.store.order.create.pre',
+  POST_CREATE = 'database.store.order.create.post',
+
+  PRE_UPDATE = 'database.store.order.update.pre',
+  POST_UPDATE = 'database.store.order.update.post',
+
+  PRE_STATUS_CHANGE = 'database.store.order.status_change.pre',
+  POST_STATUS_CHANGE = 'database.store.order.status_change.post',
+
+  PRE_DELETE = 'database.store.order.delete.pre',
+  POST_DELETE = 'database.store.order.delete.post',
+}
+
+@Injectable()
+export class OrderListener extends AbsctractListener {
+}

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

@@ -0,0 +1,19 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstract/abstract.router';
+import { OrderController } from './order.controller';
+import { OrderListener } from './order.listener';
+import { OrderRepository } from './order.repository';
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [OrderController],
+  providers: [OrderRepository, OrderListener],
+  exports: [OrderRepository],
+};
+
+@Module(metadata)
+export class OrderModule extends AbstractRouter {
+  public static readonly path = '/orders';
+
+  public static readonly module = OrderModule;
+}

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

@@ -0,0 +1,189 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, Types } from 'mongoose';
+import { AbstractRepository } from '../../../abstract/abstract.repository';
+import { FindValidator } from '../../../abstract/abstract.validator';
+import { AssetEntity } from '../../assets/asset.entity';
+import { ProductEntity } from '../../inventory/products/product.entity';
+import { ItemEntity } from './item/item.entity';
+import { OrderEntity } from './order.entity';
+import {
+  ChangeOrderStatusValidator,
+  CreateOrderValidator,
+  RefundOrderItemsValidator,
+  UpdateOrderValidator
+} from './order.validator';
+import { StatusType } from './status/status.validator';
+import { ClientEntity } from "../clients/client.entity";
+import { instanceToPlain } from "class-transformer";
+import { BillingStatus } from "./billing/billing.types";
+import { ShippingStatus } from "./shipping/shipping.types";
+
+@Injectable()
+export class OrderRepository extends AbstractRepository<OrderEntity> {
+  @InjectModel(OrderEntity.$index)
+  public readonly $model: Model<OrderEntity>;
+
+  @InjectModel(ProductEntity.$index)
+  public readonly $products: Model<ProductEntity>;
+
+  @InjectModel(AssetEntity.$index)
+  public readonly $assets: Model<AssetEntity>;
+
+  @InjectModel(ClientEntity.$index)
+  public readonly $clients: Model<ClientEntity>;
+
+  public async create(validator: CreateOrderValidator) {
+    const order = new this.$model();
+
+    const lastOrder = (await this.$model.find().sort({ _id: -1 }).limit(1).exec()).pop()
+
+    order.createdBy = super.$user?.sub
+    order.number = (lastOrder?.number || 0) + 1;
+
+    order.items = validator.items.map<any>((value) => ({ ...value, product: new Types.ObjectId(value.product) }));
+    order.notes = validator.notes;
+
+    // Client business
+    if (validator.client) {
+      order.client = new Types.ObjectId(validator.client) as any
+    }
+
+    // Customer business
+    if (validator.customer) {
+      order.customer.set('name', validator.customer.name)
+      order.customer.set('email', validator.customer.email)
+      order.customer.set('phone', validator.customer.phone)
+    }
+
+    // Billing business
+    order.billing.set('customer', {
+      name: validator.billing.customer.name,
+      email: validator.billing.customer.email,
+      phone: validator.billing.customer.phone,
+    })
+    order.billing.set('method', validator.billing.method)
+    order.billing.set('status', [{
+      user: super.$user?.sub,
+      name: BillingStatus.UNPAID,
+      date: new Date(),
+    }])
+
+    order.billing.set('address', {
+      city: validator.billing.address.city,
+      code: validator.billing.address.code,
+      complement: validator.billing.address.complement,
+      country: validator.billing.address.country,
+      number: validator.billing.address.number,
+      state: validator.billing.address.state,
+      street: validator.billing.address.street,
+    })
+
+    // Shipping business
+    order.shipping.set('method', validator.shipping.method)
+    order.shipping.set('price', validator.shipping.price)
+    order.shipping.set('status', [{
+      user: super.$user?.sub,
+      name: ShippingStatus.ORDERED,
+      date: new Date(),
+    }])
+    order.shipping.set('customer', {
+      name: validator.shipping.customer.name,
+      email: validator.shipping.customer.email,
+      phone: validator.shipping.customer.phone,
+    })
+    order.shipping.set('address', {
+      city: validator.shipping.address.city,
+      code: validator.shipping.address.code,
+      complement: validator.shipping.address.complement,
+      country: validator.shipping.address.country,
+      number: validator.shipping.address.number,
+      state: validator.shipping.address.state,
+      street: validator.shipping.address.street,
+    })
+
+    order.status = [{
+      user: super.$user?.sub,
+      name: StatusType.CREATED,
+      date: new Date(),
+    }];
+
+    await order.populate(['items.product']);
+
+    order.items = order.items.map(item => ({
+      ...item,
+      price: item.product.price.get('sale')
+    })) as ItemEntity[];
+
+    await order.depopulate(['items.product']);
+
+    return super.$create(order);
+  }
+
+  public async read(id: string, poulate: FindValidator<OrderEntity>['join'] = []) {
+    return this.$model.findById(id).populate(poulate);
+  }
+
+  public delete(id: string): Promise<void> {
+    return super.$delete(id);
+  }
+
+  public update(id: string, validator: UpdateOrderValidator): Promise<OrderEntity> {
+    return super.$update(id, {
+      $set: instanceToPlain(validator)
+    });
+  }
+
+  public changeStatus(id: string, validator: ChangeOrderStatusValidator) {
+    const query = {
+      $push: {
+        status: {
+          user: super.$user?.sub,
+          name: validator.status,
+          date: new Date(),
+        },
+      },
+    };
+
+    return super.$update(id, query);
+  }
+
+  public async findByUser(userId: string, validator: FindValidator<OrderEntity>) {
+    validator.filters = { ...validator.filters, createdBy: userId };
+
+    return this.$find(validator);
+  }
+
+  public async findOneByUser(fullNumber: string, user: string) {
+    const [orderNumber] = fullNumber.split('-').reverse()
+    const number = Number(orderNumber)
+
+    return this.$find({
+      filters: {
+        user: { $eq: user },
+        number: { $eq: number }
+      },
+      join: [{ 'path': 'items', populate: [{ path: 'product', populate: ['files'] }] }],
+      limit: 1
+    })
+      .then(res => res.items.pop());
+  }
+
+  public async refundItems(id: string, validators: RefundOrderItemsValidator[]) {
+    const order: OrderEntity = await this.read(id)
+
+    validators.map((refund) => {
+      const item = order.items.find(({ _id }) => _id.toString() === refund.item)
+
+      if (!item) {
+        return;
+      }
+
+      item.refund = refund.quantity || 0
+    })
+
+    await order.save()
+
+    return order
+  }
+}

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

@@ -0,0 +1,35 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { OrderEntity } from './order.entity';
+
+export const OrderSchema = SchemaFactory.createForClass(OrderEntity);
+
+OrderSchema.virtual('fullNumber').get<OrderEntity>(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();
+});
+
+OrderSchema.virtual('total').get<OrderEntity>(function () {
+  const subtotal = this.items
+    .reduce((previous, current) => (previous + (current.price * current.quantity)), 0)
+
+  return subtotal + this.shipping.get('price')
+});
+
+OrderSchema.virtual('subtotal').get<OrderEntity>(function () {
+  return this.items
+    .reduce((previous, current) => (previous + (current.price * current.quantity)), 0)
+});
+
+OrderSchema.virtual('currentStatus').get<OrderEntity>(function () {
+  const [first] = this.status.reverse()
+
+  return first
+})