@ashutoshvohra136/tenant-db-contract 1.0.11 → 1.0.12

package/dist/entities/Brands.d.ts

@@ -10,6 +10,7 @@ import { BeatPlanVisits } from './BeatPlanVisits';
 import { MerchandiserBrandsMappings } from './MerchandiserBrandsMappings';
 import { BrandPromotionSchemes } from './BrandPromotionSchemes';
 import { NotificationBrandMapping } from './NotificationBrandMapping';
+import { Target } from './target';
 export declare class Brands extends BaseEntity {
     id: string;
     name: string | null;
@@ -28,4 +29,5 @@ export declare class Brands extends BaseEntity {
     merchandiserBrandsMappings?: MerchandiserBrandsMappings[];
     brandPromotionscheme: BrandPromotionSchemes[];
     notificationBrandMappings?: NotificationBrandMapping[];
+    targets: Target[];
 }

package/dist/entities/Brands.js

@@ -22,6 +22,7 @@ const BeatPlanVisits_1 = require("./BeatPlanVisits");
 const MerchandiserBrandsMappings_1 = require("./MerchandiserBrandsMappings");
 const BrandPromotionSchemes_1 = require("./BrandPromotionSchemes");
 const NotificationBrandMapping_1 = require("./NotificationBrandMapping");
+const target_1 = require("./target");
 let Brands = class Brands extends typeorm_1.BaseEntity {
 };
 exports.Brands = Brands;
@@ -98,6 +99,10 @@ __decorate([
     (0, typeorm_1.OneToMany)(() => NotificationBrandMapping_1.NotificationBrandMapping, (mapping) => mapping.brand),
     __metadata("design:type", Array)
 ], Brands.prototype, "notificationBrandMappings", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => target_1.Target, (target) => target.brand),
+    __metadata("design:type", Array)
+], Brands.prototype, "targets", void 0);
 exports.Brands = Brands = __decorate([
     (0, typeorm_1.Index)('code', ['code'], { unique: true })
     // @Index("IDX_1687d82f42d8b3f8162a29e7df", ["code"], { unique: true })

package/dist/entities/Category.d.ts

@@ -1,6 +1,7 @@
 import { BaseEntity } from 'typeorm';
 import { Product } from './Products';
 import { BrandWiseCategory } from './BrandWiseCategory';
+import { Target } from './target';
 export declare class Catagory extends BaseEntity {
     id: number;
     name: string;
@@ -12,6 +13,8 @@ export declare class Catagory extends BaseEntity {
     products: Product[];
     subCategoryProducts: Product[];
     brandCategory: BrandWiseCategory[];
+    categoryTargets: Target[];
+    subCategoryTargets: Target[];
     created_at: Date;
     updated_at: Date;
 }

package/dist/entities/Category.js

@@ -13,6 +13,7 @@ exports.Catagory = void 0;
 const typeorm_1 = require("typeorm");
 const Products_1 = require("./Products");
 const BrandWiseCategory_1 = require("./BrandWiseCategory");
+const target_1 = require("./target");
 // import {SalesProduct} from './SalesProducts'
 let Catagory = class Catagory extends typeorm_1.BaseEntity {
 };
@@ -57,6 +58,14 @@ __decorate([
     (0, typeorm_1.OneToMany)(() => BrandWiseCategory_1.BrandWiseCategory, (brandWiseCategory) => brandWiseCategory.brand),
     __metadata("design:type", Array)
 ], Catagory.prototype, "brandCategory", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => target_1.Target, (target) => target.category),
+    __metadata("design:type", Array)
+], Catagory.prototype, "categoryTargets", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => target_1.Target, (target) => target.subCategory),
+    __metadata("design:type", Array)
+], Catagory.prototype, "subCategoryTargets", void 0);
 __decorate([
     (0, typeorm_1.CreateDateColumn)({ type: 'datetime' }),
     __metadata("design:type", Date)

package/dist/entities/target.d.ts

@@ -3,15 +3,29 @@ import { Users } from './Users';
 import { Months } from './Enum/Months';
 import { Product } from './Products';
 import { AchievementHistory } from './AchievementHistory';
+import { Catagory } from './Category';
+import { Brands } from './Brands';
+export declare enum TargetLevel {
+    SKU = "sku",
+    PRODUCT = "product",
+    SUBCATEGORY = "subcategory",
+    CATEGORY = "category"
+}
 export declare class Target extends BaseEntity {
     id: string;
+    storeId: number;
     month: Months;
     year: number;
     target: number;
-    achievement: string;
+    targetLevel: TargetLevel;
+    sku?: string;
+    product?: Product;
+    category?: Catagory;
+    subCategory?: Catagory;
+    brand?: Brands;
+    users: Users;
+    createdBy?: number;
     created_at: Date;
     updated_at: Date;
-    product: Product;
-    users: Users;
     AchHistory: AchievementHistory[];
 }

package/dist/entities/target.js

@@ -1,4 +1,19 @@
 "use strict";
+// import {
+//   BaseEntity,
+//   Column,
+//   CreateDateColumn,
+//   Entity,
+//   JoinColumn,
+//   ManyToOne,
+//   OneToMany,
+//   PrimaryGeneratedColumn,
+//   UpdateDateColumn,
+// } from 'typeorm';
+// import { Users } from './Users';
+// import { Months } from './Enum/Months';
+// import { Product } from './Products';
+// import { AchievementHistory } from './AchievementHistory';
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -9,64 +24,140 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Target = void 0;
+exports.Target = exports.TargetLevel = void 0;
+// @Entity('targets')
+// export class Target extends BaseEntity {
+//   @PrimaryGeneratedColumn({ type: 'bigint', name: 'id' })
+//   id!: string; // Use `string` if your application handles bigint as strings
+//   @Column({
+//     type: 'enum',
+//     enum: Months,
+//     nullable: false, // Make it non-nullable if required
+//   })
+//   month!: Months;
+//   @Column({ type: 'int', nullable: false }) // Use `int` for year
+//   year!: number;
+//   @Column({ type: 'int', nullable: false, default: 0 }) // Use `int` for target
+//   target!: number;
+//   @Column({ type: 'varchar', nullable: true, default: '0' }) // Keep as `varchar` if achievement is a string
+//   achievement!: string;
+//   @CreateDateColumn({ type: 'datetime' })
+//   created_at!: Date;
+//   @UpdateDateColumn({ type: 'datetime' })
+//   updated_at!: Date;
+//   @ManyToOne(() => Product, (product) => product.targets)
+//   @JoinColumn({ name: 'product_id' })
+//   product!: Product;
+//   @ManyToOne(() => Users, (user) => user.targets)
+//   @JoinColumn({ name: 'user_id' })
+//   users!: Users;
+//   @OneToMany(() => AchievementHistory, (achievementHistory) => achievementHistory.target)
+//   AchHistory!: AchievementHistory[];
+// }
 const typeorm_1 = require("typeorm");
 const Users_1 = require("./Users");
 const Months_1 = require("./Enum/Months");
 const Products_1 = require("./Products");
 const AchievementHistory_1 = require("./AchievementHistory");
+const Category_1 = require("./Category");
+const Brands_1 = require("./Brands");
+var TargetLevel;
+(function (TargetLevel) {
+    TargetLevel["SKU"] = "sku";
+    TargetLevel["PRODUCT"] = "product";
+    TargetLevel["SUBCATEGORY"] = "subcategory";
+    TargetLevel["CATEGORY"] = "category";
+})(TargetLevel || (exports.TargetLevel = TargetLevel = {}));
 let Target = class Target extends typeorm_1.BaseEntity {
 };
 exports.Target = Target;
 __decorate([
-    (0, typeorm_1.PrimaryGeneratedColumn)({ type: 'bigint', name: 'id' }),
+    (0, typeorm_1.PrimaryGeneratedColumn)({ type: 'bigint' }),
     __metadata("design:type", String)
 ], Target.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', name: 'store_id' }),
+    __metadata("design:type", Number)
+], Target.prototype, "storeId", void 0);
 __decorate([
     (0, typeorm_1.Column)({
         type: 'enum',
         enum: Months_1.Months,
-        nullable: false, // Make it non-nullable if required
     }),
     __metadata("design:type", String)
 ], Target.prototype, "month", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'int', nullable: false }) // Use `int` for year
-    ,
+    (0, typeorm_1.Column)({ type: 'int' }),
     __metadata("design:type", Number)
 ], Target.prototype, "year", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'int', nullable: false, default: 0 }) // Use `int` for target
-    ,
+    (0, typeorm_1.Column)({ type: 'decimal', precision: 15, scale: 2 }),
     __metadata("design:type", Number)
 ], Target.prototype, "target", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', nullable: true, default: '0' }) // Keep as `varchar` if achievement is a string
-    ,
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: TargetLevel,
+        name: 'target_level',
+    }),
     __metadata("design:type", String)
-], Target.prototype, "achievement", void 0);
+], Target.prototype, "targetLevel", void 0);
 __decorate([
-    (0, typeorm_1.CreateDateColumn)({ type: 'datetime' }),
-    __metadata("design:type", Date)
-], Target.prototype, "created_at", void 0);
-__decorate([
-    (0, typeorm_1.UpdateDateColumn)({ type: 'datetime' }),
-    __metadata("design:type", Date)
-], Target.prototype, "updated_at", void 0);
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
+    __metadata("design:type", String)
+], Target.prototype, "sku", void 0);
 __decorate([
-    (0, typeorm_1.ManyToOne)(() => Products_1.Product, (product) => product.targets),
+    (0, typeorm_1.ManyToOne)(() => Products_1.Product, (product) => product.targets, { nullable: true }),
     (0, typeorm_1.JoinColumn)({ name: 'product_id' }),
     __metadata("design:type", Products_1.Product)
 ], Target.prototype, "product", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => Category_1.Catagory, { nullable: true }),
+    (0, typeorm_1.JoinColumn)({ name: 'category_id' }),
+    __metadata("design:type", Category_1.Catagory)
+], Target.prototype, "category", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => Category_1.Catagory, { nullable: true }),
+    (0, typeorm_1.JoinColumn)({ name: 'subcategory_id' }),
+    __metadata("design:type", Category_1.Catagory)
+], Target.prototype, "subCategory", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => Brands_1.Brands, { nullable: true }),
+    (0, typeorm_1.JoinColumn)({ name: 'brand_id' }),
+    __metadata("design:type", Brands_1.Brands)
+], Target.prototype, "brand", void 0);
 __decorate([
     (0, typeorm_1.ManyToOne)(() => Users_1.Users, (user) => user.targets),
     (0, typeorm_1.JoinColumn)({ name: 'user_id' }),
     __metadata("design:type", Users_1.Users)
 ], Target.prototype, "users", void 0);
 __decorate([
-    (0, typeorm_1.OneToMany)(() => AchievementHistory_1.AchievementHistory, (achievementHistory) => achievementHistory.target),
+    (0, typeorm_1.Column)({ type: 'int', name: 'created_by', nullable: true }),
+    __metadata("design:type", Number)
+], Target.prototype, "createdBy", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'datetime' }),
+    __metadata("design:type", Date)
+], Target.prototype, "created_at", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ type: 'datetime' }),
+    __metadata("design:type", Date)
+], Target.prototype, "updated_at", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => AchievementHistory_1.AchievementHistory, (ah) => ah.target),
     __metadata("design:type", Array)
 ], Target.prototype, "AchHistory", void 0);
 exports.Target = Target = __decorate([
-    (0, typeorm_1.Entity)('targets')
+    (0, typeorm_1.Entity)('targets'),
+    (0, typeorm_1.Index)([
+        'user',
+        'storeId',
+        'month',
+        'year',
+        'targetLevel',
+        'sku',
+        'product',
+        'subCategory',
+        'category',
+    ], { unique: true })
 ], Target);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ashutoshvohra136/tenant-db-contract",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/entities/Brands.ts

@@ -20,6 +20,7 @@ import { BeatPlanVisits } from './BeatPlanVisits';
 import { MerchandiserBrandsMappings } from './MerchandiserBrandsMappings';
 import { BrandPromotionSchemes } from './BrandPromotionSchemes';
 import { NotificationBrandMapping } from './NotificationBrandMapping';
+import { Target } from './target';
 
 @Index('code', ['code'], { unique: true })
 
@@ -84,5 +85,8 @@ export class Brands extends BaseEntity {
 
   @OneToMany(() => NotificationBrandMapping, (mapping) => mapping.brand)
   notificationBrandMappings?: NotificationBrandMapping[];
+
+  @OneToMany(() => Target, (target) => target.brand)
+  targets!: Target[];
 }
 

package/src/entities/Category.ts

@@ -9,6 +9,7 @@ import {
 } from 'typeorm';
 import { Product } from './Products';
 import { BrandWiseCategory } from './BrandWiseCategory';
+import { Target } from './target';
 // import {SalesProduct} from './SalesProducts'
 
 @Entity({ name: 'categories' })
@@ -49,6 +50,14 @@ export class Catagory extends BaseEntity {
   @OneToMany(() => BrandWiseCategory, (brandWiseCategory) => brandWiseCategory.brand)
   brandCategory!: BrandWiseCategory[];
 
+
+  @OneToMany(() => Target, (target) => target.category)
+categoryTargets!: Target[];
+
+@OneToMany(() => Target, (target) => target.subCategory)
+subCategoryTargets!: Target[];
+
+
   @CreateDateColumn({ type: 'datetime' })
   created_at!: Date;
 

package/src/entities/target.ts

@@ -1,3 +1,60 @@
+// import {
+//   BaseEntity,
+//   Column,
+//   CreateDateColumn,
+//   Entity,
+//   JoinColumn,
+//   ManyToOne,
+//   OneToMany,
+//   PrimaryGeneratedColumn,
+//   UpdateDateColumn,
+// } from 'typeorm';
+// import { Users } from './Users';
+// import { Months } from './Enum/Months';
+// import { Product } from './Products';
+// import { AchievementHistory } from './AchievementHistory';
+
+// @Entity('targets')
+// export class Target extends BaseEntity {
+//   @PrimaryGeneratedColumn({ type: 'bigint', name: 'id' })
+//   id!: string; // Use `string` if your application handles bigint as strings
+
+//   @Column({
+//     type: 'enum',
+//     enum: Months,
+//     nullable: false, // Make it non-nullable if required
+//   })
+//   month!: Months;
+
+//   @Column({ type: 'int', nullable: false }) // Use `int` for year
+//   year!: number;
+
+//   @Column({ type: 'int', nullable: false, default: 0 }) // Use `int` for target
+//   target!: number;
+
+//   @Column({ type: 'varchar', nullable: true, default: '0' }) // Keep as `varchar` if achievement is a string
+//   achievement!: string;
+
+//   @CreateDateColumn({ type: 'datetime' })
+//   created_at!: Date;
+
+//   @UpdateDateColumn({ type: 'datetime' })
+//   updated_at!: Date;
+
+//   @ManyToOne(() => Product, (product) => product.targets)
+//   @JoinColumn({ name: 'product_id' })
+//   product!: Product;
+
+//   @ManyToOne(() => Users, (user) => user.targets)
+//   @JoinColumn({ name: 'user_id' })
+//   users!: Users;
+
+//   @OneToMany(() => AchievementHistory, (achievementHistory) => achievementHistory.target)
+//   AchHistory!: AchievementHistory[];
+// }
+
+
+
 import {
   BaseEntity,
   Column,
@@ -8,47 +65,111 @@ import {
   OneToMany,
   PrimaryGeneratedColumn,
   UpdateDateColumn,
+  Index,
 } from 'typeorm';
+
 import { Users } from './Users';
 import { Months } from './Enum/Months';
 import { Product } from './Products';
 import { AchievementHistory } from './AchievementHistory';
+import { Catagory } from './Category';
+import { Brands } from './Brands';
+
+export enum TargetLevel {
+  SKU = 'sku',
+  PRODUCT = 'product',
+  SUBCATEGORY = 'subcategory',
+  CATEGORY = 'category',
+}
 
 @Entity('targets')
+@Index(
+  [
+    'user',
+    'storeId',
+    'month',
+    'year',
+    'targetLevel',
+    'sku',
+    'product',
+    'subCategory',
+    'category',
+  ],
+  { unique: true }
+)
 export class Target extends BaseEntity {
-  @PrimaryGeneratedColumn({ type: 'bigint', name: 'id' })
-  id!: string; // Use `string` if your application handles bigint as strings
+  @PrimaryGeneratedColumn({ type: 'bigint' })
+  id!: string;
+
+  // 🔹 Mandatory
+  @Column({ type: 'int', name: 'store_id' })
+  storeId!: number;
 
   @Column({
     type: 'enum',
     enum: Months,
-    nullable: false, // Make it non-nullable if required
   })
   month!: Months;
 
-  @Column({ type: 'int', nullable: false }) // Use `int` for year
+  @Column({ type: 'int' })
   year!: number;
 
-  @Column({ type: 'int', nullable: false, default: 0 }) // Use `int` for target
+  @Column({ type: 'decimal', precision: 15, scale: 2 })
   target!: number;
 
-  @Column({ type: 'varchar', nullable: true, default: '0' }) // Keep as `varchar` if achievement is a string
-  achievement!: string;
-
-  @CreateDateColumn({ type: 'datetime' })
-  created_at!: Date;
+  @Column({
+    type: 'enum',
+    enum: TargetLevel,
+    name: 'target_level',
+  })
+  targetLevel!: TargetLevel;
 
-  @UpdateDateColumn({ type: 'datetime' })
-  updated_at!: Date;
+  // 🔹 SKU (only for sku-level)
+  @Column({ type: 'varchar', nullable: true })
+  sku?: string;
 
-  @ManyToOne(() => Product, (product) => product.targets)
+  // 🔹 Product (sku + product level)
+  @ManyToOne(() => Product, (product) => product.targets, { nullable: true })
   @JoinColumn({ name: 'product_id' })
-  product!: Product;
+  product?: Product;
+
+  // 🔹 Category (always useful for reporting)
+  @ManyToOne(() => Catagory, { nullable: true })
+  @JoinColumn({ name: 'category_id' })
+  category?: Catagory;
+
+  // 🔹 SubCategory
+  @ManyToOne(() => Catagory, { nullable: true })
+  @JoinColumn({ name: 'subcategory_id' })
+  subCategory?: Catagory;
+
+  // 🔹 Brand (optional but useful)
+  @ManyToOne(() => Brands, { nullable: true })
+  @JoinColumn({ name: 'brand_id' })
+  brand?: Brands;
+
+  // 🔹 User
+ 
+  // @ManyToOne(() => Users, (user) => user.targets)
+  // @JoinColumn({ name: 'user_id' })
+  // user!: Users;
 
-  @ManyToOne(() => Users, (user) => user.targets)
+    @ManyToOne(() => Users, (user) => user.targets)
   @JoinColumn({ name: 'user_id' })
   users!: Users;
 
-  @OneToMany(() => AchievementHistory, (achievementHistory) => achievementHistory.target)
+
+  // 🔹 Audit
+  @Column({ type: 'int', name: 'created_by', nullable: true })
+  createdBy?: number;
+
+  @CreateDateColumn({ type: 'datetime' })
+  created_at!: Date;
+
+  @UpdateDateColumn({ type: 'datetime' })
+  updated_at!: Date;
+
+  // 🔹 Achievement history
+  @OneToMany(() => AchievementHistory, (ah) => ah.target)
   AchHistory!: AchievementHistory[];
-}
+}