@tomei/product
Version:
NestJS package for product module
462 lines • 21.1 kB
JavaScript
;
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProductJewellery = void 0;
const product_with_inventory_base_1 = require("../../base/product-with-inventory/product-with-inventory.base");
const general_1 = require("@tomei/general");
const jewellery_product_repository_1 = require("./jewellery-product.repository");
const product_with_inventory_entity_1 = require("../../entities/product-with-inventory.entity");
const product_entity_1 = require("../../entities/product.entity");
const cuid_1 = require("../../helpers/cuid");
const stock_1 = require("@tomei/stock");
const sequelize_1 = require("sequelize");
const activity_history_1 = require("@tomei/activity-history");
const settings_category_entity_1 = require("../../entities/settings-category.entity");
const settings_collection_entity_1 = require("../../entities/settings-collection.entity");
const settings_group_entity_1 = require("../../entities/settings-group.entity");
const product_certificate_entity_1 = require("../../entities/product-certificate.entity");
const product_tag_entity_1 = require("../../entities/product-tag.entity");
const product_brand_entity_1 = require("../../entities/product-brand.entity");
const product_customize_option_entity_1 = require("../../entities/product-customize-option.entity");
const product_material_entity_1 = require("../../entities/product-material.entity");
const variant_product_with_inventory_1 = require("../variant-product-with-inventory/variant-product-with-inventory");
const product_variant_enum_1 = require("../../enum/product-variant.enum");
class ProductJewellery extends product_with_inventory_base_1.ProductWithInventoryBase {
get ProductId() {
return super.ProductId;
}
set ProductId(productId) {
super.ProductId = productId;
}
get ProfileId() {
return this._ProfileId;
}
set ProfileId(id) {
this._ProfileId = id;
}
get Surface() {
return this._Surface;
}
set Surface(surface) {
this._Surface = surface;
}
get Uniqueness() {
return this._Uniqueness;
}
set Uniqueness(uniqueness) {
this._Uniqueness = uniqueness;
}
get HasCertificateYN() {
return this._HasCertificateYN;
}
set HasCertificateYN(hasCertificateYN) {
this._HasCertificateYN = hasCertificateYN;
}
get UOM() {
return super.UOM;
}
get TotalUnits() {
return super.TotalUnits;
}
get TotalUnitsAvailable() {
return super.TotalUnitsAvailable;
}
get TotalUnitsInCurrentOrder() {
return super.TotalUnitsInCurrentOrder;
}
get TotalUnitsSold() {
return super.TotalUnitsSold;
}
get TotalUnitsReserved() {
return super.TotalUnitsReserved;
}
get TotalUnitsOnConsignment() {
return super.TotalUnitsOnConsignment;
}
get TotalUnitsUnderMaintenance() {
return super.TotalUnitsUnderMaintenance;
}
get TotalUnitsVoid() {
return super.TotalUnitsVoid;
}
get TotalUnitsInTransit() {
return super.TotalUnitsInTransit;
}
get TotalUnitsBackOrdered() {
return super.TotalUnitsBackOrdered;
}
get TotalUnitsPreOrdered() {
return super.TotalUnitsPreOrdered;
}
get StockLowAlertLevel() {
return super.StockLowAlertLevel;
}
get StockReorderLevel() {
return super.StockReorderLevel;
}
get BufferStockLevel() {
return super.BufferStockLevel;
}
constructor(productJewelleryAttr) {
super(productJewelleryAttr);
this.ObjectType = 'ProductJewellery';
this._HasCertificateYN = 'N';
this._ProfileId = productJewelleryAttr.ProfileId;
this._Surface = productJewelleryAttr.Surface;
this._Uniqueness = productJewelleryAttr.Uniqueness;
this._HasCertificateYN = productJewelleryAttr.HasCertificateYN;
}
static async init(options) {
try {
const { productId, productInfo } = options;
if (productId) {
const product = await ProductJewellery._ProductJewelleryRepository.findOne({
where: {
ProductId: productId,
},
include: [
{
model: product_with_inventory_entity_1.ProductWithInventoryModel,
include: [
{
model: product_entity_1.ProductModel,
},
],
},
],
});
const productAttr = {
ProductId: product.ProductId,
Name: product.ProductWithInventory.Product.Name,
Description: product.ProductWithInventory.Product.Description,
SKU: product.ProductWithInventory.Product.SKU,
Type: product.ProductWithInventory.Product.Type,
Remark: product.ProductWithInventory.Product.Remark,
IsTaxableYN: product.ProductWithInventory.Product.IsTaxableYN,
TaxCode: product.ProductWithInventory.Product.TaxCode,
IsPriceInclusiveTaxYN: product.ProductWithInventory.Product.IsPriceInclusiveTaxYN,
Status: product.ProductWithInventory.Product.Status,
VerifiedYN: product.ProductWithInventory.Product.VerifiedYN,
VerifiedById: product.ProductWithInventory.Product.VerifiedById,
VerifiedAt: product.ProductWithInventory.Product.VerifiedAt,
VariantLevels: product.ProductWithInventory.Product.VariantLevels,
VariantTypeLevel1: product.ProductWithInventory.Product.VariantTypeLevel1,
VariantTypeLevel2: product.ProductWithInventory.Product.VariantTypeLevel2,
VariantTypeLevel3: product.ProductWithInventory.Product.VariantTypeLevel3,
CreatedById: product.ProductWithInventory.Product.CreatedById,
CreatedAt: product.ProductWithInventory.Product.CreatedAt,
UpdatedById: product.ProductWithInventory.Product.UpdatedById,
UpdatedAt: product.ProductWithInventory.Product.UpdatedAt,
UpdatedSSYN: product.ProductWithInventory.Product.UpdatedSSYN,
UOM: product.ProductWithInventory.UOM,
TotalUnits: product.ProductWithInventory.TotalUnits,
TotalUnitsAvailable: product.ProductWithInventory.TotalUnitsAvailable,
TotalUnitsInCurrentOrder: product.ProductWithInventory.TotalUnitsInCurrentOrder,
TotalUnitsSold: product.ProductWithInventory.TotalUnitsSold,
TotalUnitsReserved: product.ProductWithInventory.TotalUnitsReserved,
TotalUnitsOnConsignment: product.ProductWithInventory.TotalUnitsOnConsignment,
TotalUnitsUnderMaintenance: product.ProductWithInventory.TotalUnitsUnderMaintenance,
TotalUnitsVoid: product.ProductWithInventory.TotalUnitsVoid,
TotalUnitsInTransit: product.ProductWithInventory.TotalUnitsInTransit,
TotalUnitsBackOrdered: product.ProductWithInventory.TotalUnitsBackOrdered,
TotalUnitsPreOrdered: product.ProductWithInventory.TotalUnitsPreOrdered,
StockLowAlertLevel: product.ProductWithInventory.StockLowAlertLevel,
StockReorderLevel: product.ProductWithInventory.StockReorderLevel,
BufferStockLevel: product.ProductWithInventory.BufferStockLevel,
ProfileId: product.ProfileId,
Surface: product.Surface,
Uniqueness: product.Uniqueness,
HasCertificateYN: product.HasCertificateYN,
};
if (productAttr) {
const productJewellery = new ProductJewellery(productAttr);
return productJewellery;
}
else {
throw Error('ProductId not found.');
}
}
else {
if (!productInfo) {
throw Error('Product info is required.');
}
return new ProductJewellery(productInfo);
}
}
catch (err) {
throw Error('Failed to instantiate ProductJewellery.');
}
}
async create(loginUser, dbTransaction, profileId) {
try {
if (!profileId) {
throw new Error('ProfileId is required.');
}
let stockProfile;
try {
stockProfile = await stock_1.StockProfile.init(profileId);
}
catch (error) {
if (error.message && error.message === 'ProfileId not found') {
throw new general_1.RecordNotFoundError('ProductJewelleryErrMsg01', 'Stock Profile not found. Please create Stock Profile first.');
}
else {
throw error;
}
}
this.ProfileId = stockProfile.ProfileId;
const parentData = await super.create(loginUser, dbTransaction);
const data = await ProductJewellery._ProductJewelleryRepository.create({
ProfileId: this._ProfileId,
ProductId: parentData.ProductId,
Surface: this._Surface,
Uniqueness: this._Uniqueness,
HasCertificateYN: this._HasCertificateYN,
}, {
transaction: dbTransaction,
});
const entityValueAfter = data.get({ plain: true });
const activity = new activity_history_1.Activity();
activity.ActivityId = (0, cuid_1.default)();
activity.Action = activity_history_1.ActionEnum.CREATE;
activity.Description = 'Add new product with inventory';
activity.EntityType = 'ProductWithInventory';
activity.EntityId = data.ProductId;
activity.EntityValueBefore = JSON.stringify({});
activity.EntityValueAfter = JSON.stringify(entityValueAfter);
await activity.create(loginUser.ObjectId, dbTransaction);
}
catch (error) {
throw error;
}
}
static async findAll(loginUser, dbTransaction, searchOptions) {
try {
await super.findAll(loginUser);
if (searchOptions.page && searchOptions.rows) {
const offset = searchOptions.rows * (searchOptions.page - 1);
let searchObj;
try {
searchObj = searchOptions.search
? JSON.parse(searchOptions.search)
: {};
}
catch (err) {
throw new Error('Bad value for search.');
}
const { StoreId, CategoryCode, CollectionCode, CertificateId, GroupCode, Brand, TagId, CustomizeOptionId, MaterialId } = searchObj, prodFilter = __rest(searchObj, ["StoreId", "CategoryCode", "CollectionCode", "CertificateId", "GroupCode", "Brand", "TagId", "CustomizeOptionId", "MaterialId"]);
const productQueryObj = {};
Object.entries(prodFilter).forEach(([key, value]) => {
productQueryObj[key] = {
[sequelize_1.Op.substring]: value,
};
});
return await ProductJewellery._ProductJewelleryRepository.findAllWithPagination({
productQuery: {
whereProduct: productQueryObj,
StoreId,
CategoryCode,
CollectionCode,
CertificateId,
GroupCode,
Brand,
TagId,
CustomizeOptionId,
MaterialId,
},
rows: searchOptions.rows,
offset,
transaction: dbTransaction,
});
}
else {
return await ProductJewellery._ProductJewelleryRepository.findAll(dbTransaction);
}
}
catch (error) {
throw error;
}
}
async update(loginUser, productInfo, dbTransaction) {
try {
const updatedInfo = await super.update(loginUser, productInfo, dbTransaction);
return updatedInfo;
}
catch (error) {
throw error;
}
}
async deactivate(loginUser, dbTransaction) {
super.deactivate(loginUser, dbTransaction);
}
async verify(loginUser, dbTransaction) {
try {
await super.verify(loginUser, dbTransaction);
}
catch (error) {
throw error;
}
}
async delete(loginUser, dbTransaction) {
try {
await super.delete(loginUser, dbTransaction);
}
catch (error) {
throw error;
}
}
async activate(loginUser, dbTransaction) {
try {
await super.activate(loginUser, dbTransaction);
}
catch (error) {
throw error;
}
}
static async findOne(options, dbTransaction) {
try {
const dbOptions = typeof options !== 'string'
? options
: {
where: {
ProductId: options,
},
include: [
{
model: product_with_inventory_entity_1.ProductWithInventoryModel,
include: [
{
model: product_entity_1.ProductModel,
include: [
{
model: settings_category_entity_1.SettingsCategoryModel,
attributes: ['Code', 'Name', 'Description', 'Status'],
},
{
model: settings_collection_entity_1.SettingsCollectionModel,
attributes: ['Code', 'Name', 'Description', 'Status'],
},
{
model: settings_group_entity_1.SettingsGroupModel,
attributes: ['Code', 'Name', 'Description', 'Status'],
},
{ model: product_certificate_entity_1.ProductCertificateModel },
{ model: product_tag_entity_1.ProductTagModel },
{ model: product_brand_entity_1.ProductBrandModel },
{ model: product_customize_option_entity_1.ProductCustomizeOptionModel },
{ model: product_material_entity_1.ProductMaterialModel },
{
model: settings_group_entity_1.SettingsGroupModel,
},
],
},
],
},
{
model: stock_1.StockProfileModel,
},
],
};
return await ProductJewellery._ProductJewelleryRepository.findOne(Object.assign(Object.assign({}, dbOptions), { transaction: dbTransaction }));
}
catch (error) {
throw error;
}
}
async addVariant(addVariantInfo, loginUser, dbTransaction) {
try {
const product = await ProductJewellery._Repository.findOne({
where: {
SKU: addVariantInfo.SKU,
},
transaction: dbTransaction,
});
if (product) {
throw new general_1.ClassError('ProductVariant', 'ProductVariantErrMsg03', 'SKU must be unique.');
}
const variant = await variant_product_with_inventory_1.ProductVariantWithInventory.init();
variant.ProductId = this.ProductId;
variant.Name = addVariantInfo.Name;
variant.Description = addVariantInfo.Description;
variant.Type = addVariantInfo.Type;
variant.Level = addVariantInfo.Level;
variant.StockLowAlertLevel = addVariantInfo.StockLowAlertLevel;
variant.StockReorderLevel = addVariantInfo.StockReorderLevel;
variant.BufferStockLevel = addVariantInfo.BufferStockLevel;
await variant.setSKU(addVariantInfo.SKU);
await variant.setParentId(addVariantInfo.ParentId);
await variant.setColour(addVariantInfo.Colour);
await variant.setSize(addVariantInfo.Size);
switch (variant.Type) {
case product_variant_enum_1.ProductVariantType.HEIGHT:
await variant.setMinMax(variant.Type, addVariantInfo.MinHeight, addVariantInfo.MaxHeight);
break;
case product_variant_enum_1.ProductVariantType.LENGTH:
await variant.setMinMax(variant.Type, addVariantInfo.MinLength, addVariantInfo.MaxLength);
break;
case product_variant_enum_1.ProductVariantType.WIDTH:
await variant.setMinMax(variant.Type, addVariantInfo.MinWidth, addVariantInfo.MaxWidth);
break;
case product_variant_enum_1.ProductVariantType.WEIGHT:
await variant.setMinMax(variant.Type, addVariantInfo.MinWeight, addVariantInfo.MaxWeight);
break;
default:
break;
}
await variant.create(loginUser, dbTransaction);
return {
VariantId: variant.VariantId,
ProductId: variant.ProductId,
Name: variant.Name,
Description: variant.Description,
SKU: variant.SKU,
Size: variant.Size,
Colour: variant.Colour,
Type: variant.Type,
Level: variant.Level,
ParentId: variant.ParentId,
MinWeight: variant.MinWeight,
MaxWeight: variant.MaxWeight,
MinWidth: variant.MinWidth,
MaxWidth: variant.MaxWidth,
MinHeight: variant.MinHeight,
MaxHeight: variant.MaxHeight,
MinLength: variant.MinLength,
MaxLength: variant.MaxLength,
Status: variant.Status,
CreatedById: variant.CreatedById,
CreatedAt: variant.CreatedAt,
UpdatedById: variant.UpdatedById,
UpdatedAt: variant.UpdatedAt,
UpdatedSSYN: variant.UpdatedSSYN,
TotalUnitsAvailable: variant.TotalUnitsAvailable,
TotalUnitsInCurrentOrder: variant.TotalUnitsInCurrentOrder,
TotalUnitsSold: variant.TotalUnitsSold,
TotalUnitsReserved: variant.TotalUnitsReserved,
TotalUnitsInTransit: variant.TotalUnitsInTransit,
TotalUnitsOnConsignment: variant.TotalUnitsOnConsignment,
TotalUnitsBackOrdered: variant.TotalUnitsBackOrdered,
TotalUnitsPreOrdered: variant.TotalUnitsPreOrdered,
StockLowAlertLevel: variant.StockLowAlertLevel,
StockReorderLevel: variant.StockReorderLevel,
BufferStockLevel: variant.BufferStockLevel,
};
}
catch (error) {
throw error;
}
}
}
exports.ProductJewellery = ProductJewellery;
ProductJewellery._ProductJewelleryRepository = new jewellery_product_repository_1.ProductJewelleryRepository();
//# sourceMappingURL=jewellery-product.js.map