@merkaly/api 0.2.4-6 → 0.2.4-7

package/src/modules/inventory/brands/brand.repository.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, UpdateQuery } from 'mongoose';
+import { AbstractRepository } from '../../../abstract/abstract.repository';
+import { BrandEntity } from './brand.entity';
+import { CreateBrandValidator, UpdateBrandValidator } from './brand.validator';
+import { CategoryEntity } from "../categories/category.entity";
+
+@Injectable()
+export class BrandRepository extends AbstractRepository<BrandEntity> {
+  @InjectModel(BrandEntity.$index)
+  public readonly $model: Model<BrandEntity>;
+
+  public async create(validator: CreateBrandValidator) {
+    const brand = new this.$model();
+
+    brand.name = validator.name;
+    brand.description = validator.description;
+
+    return super.$create(brand);
+  }
+
+  public async update(id: string, validator: UpdateBrandValidator) {
+    const category: CategoryEntity = await this.$model.findById(id);
+
+    const query: UpdateQuery<BrandEntity> = {
+      $set: {
+        name: validator.name || category.name,
+        description: validator.description || category.description,
+      },
+    };
+
+    return super.$update(id, query);
+  }
+
+  public async delete(id: string): Promise<void> {
+    return super.$delete(id);
+  }
+}

package/src/modules/inventory/brands/brand.schema.ts

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

package/src/modules/inventory/brands/brand.validator.ts

@@ -0,0 +1,23 @@
+import { IsOptional, IsString, Length } from 'class-validator';
+import { AbstractValidator } from "../../../abstract/abstract.validator";
+
+export class CreateBrandValidator extends AbstractValidator {
+  @IsString()
+  @Length(2, 32)
+  public name: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+}
+
+export class UpdateBrandValidator extends AbstractValidator {
+  @IsString()
+  @Length(2, 32)
+  @IsOptional()
+  public name?: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+}

package/src/modules/inventory/categories/category.controller.ts

@@ -0,0 +1,59 @@
+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 { CategoryEntity } from './category.entity';
+import { CategoryException } from './category.exception';
+import { CategoryRepository } from './category.repository';
+import { CreateCategoryValidator, UpdateCategoryValidator } from './category.validator';
+import { Public } from "../../../decorators/public.decorator";
+
+@Controller()
+@UseFilters(CategoryException)
+@ApiTags('inventory')
+export class CategoryController extends AbstractController<CategoryEntity> {
+  @Inject()
+  protected readonly $repository: CategoryRepository;
+
+  @Get('/')
+  @Public()
+  public async find(@Query() validator: FindValidator<CategoryEntity>) {
+    return super.find(validator);
+  }
+
+  @Get('/:id')
+  @Public()
+  public async read(@Param('id') id: string) {
+    return this.$repository.read(id);
+  }
+
+  @Post('/')
+  @HttpCode(HttpStatus.CREATED)
+  public async create(@Body() validator: CreateCategoryValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Patch('/:id')
+  public async update(@Param('id') id: string, @Body() validator: UpdateCategoryValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Delete('/:id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  public async delete(@Param('id') id: string): Promise<void> {
+    return this.$repository.delete(id);
+  }
+}

package/src/modules/inventory/categories/category.entity.ts

@@ -0,0 +1,21 @@
+import { Prop, Schema } from '@nestjs/mongoose';
+import { Schema as MongoSchema, Types } from 'mongoose';
+import { AbstractEntity } from '../../../abstract/abstract.entity';
+import { PropertyEntity } from '../properties/property.entity';
+
+@Schema({ timestamps: true })
+export class CategoryEntity extends AbstractEntity {
+  public static readonly $index = 'inventory_categories';
+
+  @Prop({ type: MongoSchema.Types.String, length: 32, unique: true, required: true })
+  public name: string;
+
+  @Prop({ type: MongoSchema.Types.String })
+  public description: string;
+
+  @Prop({ type: MongoSchema.Types.String, length: 32, default: 'tag' })
+  public icon: string;
+
+  @Prop({ type: [{ type: Types.ObjectId, ref: PropertyEntity.$index }] })
+  public properties: PropertyEntity[] = [];
+}

package/src/modules/inventory/categories/category.exception.ts

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

package/src/modules/inventory/categories/category.fixture.ts

@@ -0,0 +1,18 @@
+import { AbstractFixture } from '../../../abstract/abstract.fixture';
+import { CategoryEntity } from "./category.entity";
+
+export class CategoryFixture extends AbstractFixture {
+
+  public normal() {
+    const category = new CategoryEntity({
+      _id: this.$faker.datatype.uuid(),
+      createdAt: this.$faker.date.past(1),
+      updatedAt: this.$faker.date.past(1),
+    });
+
+    category.name = this.$faker.vehicle.manufacturer();
+    category.description = this.$faker.lorem.sentence();
+
+    return category;
+  }
+}

package/src/modules/inventory/categories/category.listener.ts

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

package/src/modules/inventory/categories/category.module.ts

@@ -0,0 +1,19 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstract/abstract.router';
+import { CategoryController } from './category.controller';
+import { CategoryListener } from './category.listener';
+import { CategoryRepository } from './category.repository';
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [CategoryController],
+  providers: [CategoryRepository, CategoryListener],
+  exports: [CategoryRepository],
+};
+
+@Module(metadata)
+export class CategoryModule extends AbstractRouter {
+  public static readonly path = '/categories';
+
+  public static readonly module = CategoryModule;
+}

package/src/modules/inventory/categories/category.repository.ts

@@ -0,0 +1,40 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, UpdateQuery } from 'mongoose';
+import { AbstractRepository } from '../../../abstract/abstract.repository';
+import { CategoryEntity } from './category.entity';
+import { CreateCategoryValidator, UpdateCategoryValidator } from './category.validator';
+
+@Injectable()
+export class CategoryRepository extends AbstractRepository<CategoryEntity> {
+  @InjectModel(CategoryEntity.$index)
+  public readonly $model: Model<CategoryEntity>;
+
+  public async create(validator: CreateCategoryValidator) {
+    const category = new this.$model();
+
+    category.name = validator.name;
+    category.description = validator.description;
+    category.icon = validator.icon;
+
+    return super.$create(category);
+  }
+
+  public async update(id: string, validator: UpdateCategoryValidator) {
+    const category = await this.$model.findById(id);
+
+    const query: UpdateQuery<CategoryEntity> = {
+      $set: {
+        name: validator.name || category.name,
+        icon: validator.icon,
+        description: validator.description || category.description,
+      },
+    };
+
+    return super.$update(id, query);
+  }
+
+  public async delete(id: string): Promise<void> {
+    return super.$delete(id);
+  }
+}

package/src/modules/inventory/categories/category.schema.ts

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

package/src/modules/inventory/categories/category.validator.ts

@@ -0,0 +1,30 @@
+import { IsOptional, IsString, Length } from 'class-validator';
+import { AbstractValidator } from "../../../abstract/abstract.validator";
+
+export class CreateCategoryValidator extends AbstractValidator {
+  @IsString()
+  @Length(5, 32)
+  public name: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+
+  @IsString()
+  @IsOptional()
+  public icon = 'tag';
+}
+
+export class UpdateCategoryValidator extends AbstractValidator {
+  @IsString()
+  @IsOptional()
+  public name: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+
+  @IsString()
+  @IsOptional()
+  public icon = 'tag';
+}

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

@@ -0,0 +1,22 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../abstract/abstract.router';
+import { BrandModule } from './brands/brand.module';
+import { CategoryModule } from './categories/category.module';
+import { ProductModule } from './products/product.module';
+import { PropertyModule } from './properties/property.module';
+
+export const metadata: ModuleMetadata = {
+  imports: [BrandModule, CategoryModule, ProductModule, PropertyModule],
+  controllers: [],
+  providers: [],
+  exports: [BrandModule, CategoryModule, ProductModule, PropertyModule],
+};
+
+@Module(metadata)
+export class InventoryModule extends AbstractRouter {
+  public static readonly path = '/inventory';
+
+  public static readonly module = InventoryModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/inventory/products/entities/code.entity.ts

@@ -0,0 +1,15 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+
+@Collection()
+export class CodeEntity extends Map {
+  @Prop({ type: Schema.Types.String })
+  public sku: string;
+
+  @Prop({ type: Schema.Types.String })
+  public gtin: string;
+
+  @Prop({ type: Schema.Types.String })
+  public mpn: string;
+}

package/src/modules/inventory/products/entities/dimension.entity.ts

@@ -0,0 +1,18 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+
+@Collection()
+export class DimensionEntity extends Map {
+  @Prop({ type: Schema.Types.Number })
+  public weight: number;
+
+  @Prop({ type: Schema.Types.Number })
+  public height: number;
+
+  @Prop({ type: Schema.Types.Number })
+  public width: number;
+
+  @Prop({ type: Schema.Types.Number })
+  public depth: number;
+}

package/src/modules/inventory/products/entities/price.entity.ts

@@ -0,0 +1,12 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+
+@Collection()
+export class PriceEntity extends Map {
+  @Prop({ type: Schema.Types.Number, required: true })
+  public sale: number;
+
+  @Prop({ type: Schema.Types.Number })
+  public purchase: number;
+}

package/src/modules/inventory/products/entities/seo.entity.ts

@@ -0,0 +1,15 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+
+@Collection()
+export class SeoEntity extends Map {
+  @Prop({ type: Schema.Types.String })
+  public title: string;
+
+  @Prop({ type: Schema.Types.String })
+  public slug: string;
+
+  @Prop({ type: Schema.Types.String })
+  public description: string;
+}

package/src/modules/inventory/products/product.controller.ts

@@ -0,0 +1,59 @@
+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 { ProductEntity } from './product.entity';
+import { ProductException } from './product.exception';
+import { ProductRepository } from './product.repository';
+import { CreateProductValidator, UpdateProductValidator } from './product.validator';
+import { Public } from "../../../decorators/public.decorator";
+
+@Controller()
+@UseFilters(ProductException)
+@ApiTags('inventory')
+export class ProductController extends AbstractController<ProductEntity> {
+  @Inject()
+  protected readonly $repository: ProductRepository;
+
+  @Get('/')
+  @Public()
+  public async find(@Query() validator: FindValidator<ProductEntity>) {
+    return super.find(validator);
+  }
+
+  @Post('/')
+  @HttpCode(HttpStatus.CREATED)
+  public async create(@Body() validator: CreateProductValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Get('/:id')
+  @Public()
+  public async read(@Param('id') id: string, @Query() validator: FindValidator<ProductEntity>) {
+    return this.$repository.read(id, validator);
+  }
+
+  @Patch('/:id')
+  public async update(@Param('id') id: string, @Body() validator: UpdateProductValidator) {
+    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/inventory/products/product.entity.ts

@@ -0,0 +1,53 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import { AbstractEntity } from '../../../abstract/abstract.entity';
+import { AssetEntity } from '../../assets/asset.entity';
+import { BrandEntity } from '../brands/brand.entity';
+import { CategoryEntity } from '../categories/category.entity';
+import { CodeEntity } from './entities/code.entity';
+import { DimensionEntity } from './entities/dimension.entity';
+import { PriceEntity } from './entities/price.entity';
+import { SeoEntity } from './entities/seo.entity';
+
+@Collection({ timestamps: true, toJSON: { virtuals: true } })
+export class ProductEntity extends AbstractEntity {
+  public static readonly $index = 'inventory_products';
+
+  @Prop({ type: Schema.Types.String, required: true, length: 64 })
+  public name: string;
+
+  @Prop({ type: Schema.Types.String, length: 256 })
+  public measurement: string;
+
+  @Prop({ type: Schema.Types.Boolean, default: true })
+  public active = true;
+
+  @Prop({ type: Schema.Types.String, nullable: true })
+  public description: string;
+
+  @Prop({ type: Schema.Types.Array, default: [] })
+  public hashtags: string[] = [];
+
+  @Prop({ type: Schema.Types.ObjectId, ref: CategoryEntity.$index })
+  public category?: CategoryEntity;
+
+  @Prop({ type: Schema.Types.ObjectId, ref: BrandEntity.$index })
+  public brand?: BrandEntity;
+
+  @Prop({ type: [{ type: Schema.Types.ObjectId, ref: AssetEntity.$index }] })
+  public files: AssetEntity[] = [];
+
+  @Prop({ type: Schema.Types.Map, ref: () => PriceEntity, default: new Map() })
+  public price: PriceEntity;
+
+  @Prop({ type: Schema.Types.Map, ref: () => CodeEntity, default: new Map() })
+  public code: CodeEntity;
+
+  @Prop({ type: Schema.Types.Map, ref: () => DimensionEntity, default: new Map() })
+  public dimension: DimensionEntity;
+
+  @Prop({ type: Schema.Types.Map, ref: () => SeoEntity, default: new Map() })
+  public seo: SeoEntity;
+
+  public readonly picture: string
+}

package/src/modules/inventory/products/product.exception.ts

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

package/src/modules/inventory/products/product.fixture.ts

@@ -0,0 +1,19 @@
+import { AbstractFixture } from '../../../abstract/abstract.fixture';
+import { ProductEntity } from "./product.entity";
+
+export class ProductFixture extends AbstractFixture {
+
+  public normal() {
+    const product = new ProductEntity({
+      _id: this.$faker.datatype.uuid(),
+      createdAt: this.$faker.date.past(1),
+      updatedAt: this.$faker.date.past(1),
+    });
+
+    product.name = this.$faker.vehicle.vehicle();
+    product.description = this.$faker.commerce.productDescription();
+    product.price.sale = Number(this.$faker.commerce.price(1000, 10000, 2));
+
+    return product;
+  }
+}

package/src/modules/inventory/products/product.listener.ts

@@ -0,0 +1,27 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { AbsctractListener } from '../../../abstract/absctract.listener';
+import { AssetService } from '../../assets/asset.service';
+import { ProductEntity } from './product.entity';
+
+export enum ProductEvent {
+  LINK_FILES = 'database.inventory.product.link-files',
+}
+
+@Injectable()
+export class ProductListener extends AbsctractListener {
+
+  @Inject()
+  protected $assets: AssetService;
+
+  @OnEvent(ProductEvent.LINK_FILES)
+  protected async linkAssets(product: ProductEntity) {
+    await product.populate('files');
+
+    const { _id, db: { name } } = product;
+
+    await this.$assets.removeAssetsWeakness(product.files, `${name}/products/${_id}`);
+
+    return product;
+  }
+}

package/src/modules/inventory/products/product.module.ts

@@ -0,0 +1,20 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstract/abstract.router';
+import { AssetService } from '../../assets/asset.service';
+import { ProductController } from './product.controller';
+import { ProductListener } from './product.listener';
+import { ProductRepository } from './product.repository';
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [ProductController],
+  providers: [ProductRepository, ProductListener, AssetService],
+  exports: [ProductRepository],
+};
+
+@Module(metadata)
+export class ProductModule extends AbstractRouter {
+  public static readonly path = '/products';
+
+  public static readonly module = ProductModule;
+}