test-entity-library-asm 1.0.0

package/README.md

@@ -0,0 +1,2 @@
+# test-entity-library-asm
+Test de librería para probar las entidades de la base de datos asumano

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "test-entity-library-asm",
+  "version": "1.0.0",
+  "description": "Entidades de ejemplo para una base de datos",
+  "main": "index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "typeorm": "^0.3.20"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.7",
+    "typescript": "^5.4.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jesusgomez461/test-entity-library-asm"
+  },
+  "homepage": "https://github.com/jesusgomez461/test-entity-library-asm"
+}

package/src/entities/Category.ts

@@ -0,0 +1,21 @@
+import { Entity, Column, PrimaryGeneratedColumn, ManyToOne, JoinColumn } from 'typeorm';
+import { Local } from './Local';
+
+@Entity()
+export class Category {
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column()
+    localId: number;
+
+    @Column({ length: 30 })
+    name: string;
+
+    @Column()
+    position: number;
+
+    @ManyToOne(() => Local)
+    @JoinColumn({ name: 'localId' })
+    local: Local;
+}

package/src/entities/City.ts

@@ -0,0 +1,37 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm'
+import { Region } from './Region'
+import { User } from './User'
+import { Company } from './Company'
+import { Local } from './Local'
+
+@Entity()
+export class City {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 50 })
+  name: string
+
+  @ManyToOne(() => Region, (region) => region.cities)
+  @JoinColumn({ name: 'region' })
+  region: Region
+
+  @Column({ default: 1 })
+  status: number
+
+  @OneToMany(() => User, (user) => user.city)
+  users: User[]
+
+  @OneToMany(() => Company, (Company) => Company.city)
+  companies: Company[]
+
+  @OneToMany(() => Local, (local) => local.city)
+  locals: Local[]
+}

package/src/entities/CodeRedemptionHistoryCompany.ts

@@ -0,0 +1,35 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm'
+import { DiscountCodeCompany } from './DiscountCodeCompany'
+import { Company } from './Company'
+
+@Entity('code_redemption_history_company')
+export class CodeRedemptionHistoryCompany {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(
+    () => DiscountCodeCompany,
+    (company) => company.code_redemptions_history_company
+  )
+  @JoinColumn({ name: 'discount_code_company' })
+  discount_code_company: DiscountCodeCompany
+
+  @ManyToOne(
+    () => Company,
+    (company) => company.code_redemption_history_company
+  )
+  @JoinColumn({ name: 'company' })
+  company: Company
+
+  @Column({ type: 'datetime' })
+  dateUsed: Date
+
+  @Column({ length: 10 })
+  discountApplied: string
+}

package/src/entities/CodeRedemptionHistoryUser.ts

@@ -0,0 +1,32 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm'
+import { User } from './User'
+import { DiscountCodeUser } from './DiscountCodeUser'
+
+@Entity('code_redemption_history_user')
+export class CodeRedemptionHistoryUser {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(
+    () => DiscountCodeUser,
+    (discountCodeUser) => discountCodeUser.code_redemptions_history_users
+  )
+  @JoinColumn({ name: 'discount_code_user' })
+  discount_code_user: DiscountCodeUser
+
+  @ManyToOne(() => User, (user) => user.code_redemption_history_users)
+  @JoinColumn({ name: 'user' })
+  user: User
+
+  @Column({ type: 'datetime' })
+  date_used: Date
+
+  @Column({ length: 10 })
+  discount_applied: string
+}

package/src/entities/Company.ts

@@ -0,0 +1,113 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  ManyToMany,
+  JoinTable,
+  OneToMany,
+} from 'typeorm'
+import { City } from './City'
+import { User } from './User'
+import { Plan } from './Plan'
+import { TypeFood } from './TypeFood'
+import { Local } from './Local'
+import { CodeRedemptionHistoryCompany } from './CodeRedemptionHistoryCompany'
+import { DiscountCodeUser } from './DiscountCodeUser'
+import { ProductTopping } from './ProductTopping'
+
+@Entity()
+export class Company {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 50 })
+  name: string
+
+  @ManyToOne(() => City, (city) => city.companies)
+  @JoinColumn({ name: 'city' })
+  city: City
+
+  @ManyToOne(() => User, (city) => city.companies)
+  @JoinColumn({ name: 'user' })
+  user: User
+
+  @Column({
+    type: 'longtext',
+    nullable: true,
+    comment:
+      'Campo de tipo JSON donde se guarda información necesaria para la empresa',
+  })
+  profile: string
+
+  @Column({ default: 1 })
+  quantity_locals: number
+
+  @Column({ default: 6 })
+  quantity_users: number
+
+  @Column({
+    type: 'longtext',
+    nullable: true,
+    comment:
+      'Información de tipo JSON donde se guarda la información legal de la empresa',
+  })
+  legal_information: string
+
+  @Column({
+    type: 'longtext',
+    nullable: true,
+    comment:
+      'Información de tipo JSON donde se guarda la información del representante legal del representante',
+  })
+  legal_agent: string
+
+  @ManyToOne(() => Plan, (plan) => plan.companies)
+  @JoinColumn({ name: 'plan' })
+  plan: Plan
+
+  @Column({ type: 'datetime' })
+  created: Date
+
+  @Column({ type: 'date', nullable: true })
+  expiration: Date
+
+  @Column({ type: 'datetime' })
+  updated: Date
+
+  @Column({ default: 1 })
+  status: number
+
+  @ManyToMany(() => TypeFood)
+  @JoinTable({
+    name: 'type_food_company',
+    joinColumn: {
+      name: 'company',
+      referencedColumnName: 'id',
+    },
+    inverseJoinColumn: {
+      name: 'type_food',
+      referencedColumnName: 'id',
+    },
+  })
+  types_food: TypeFood[]
+
+  @OneToMany(() => Local, (local) => local.company)
+  locals: Local[]
+
+  @OneToMany(
+    () => CodeRedemptionHistoryCompany,
+    (codeRedemptionHistoryCompany) => codeRedemptionHistoryCompany.company
+  )
+  code_redemption_history_company: CodeRedemptionHistoryCompany[]
+
+  @OneToMany(
+    () => DiscountCodeUser,
+    (discountCodeUser) => discountCodeUser.company
+  )
+  discount_code_users: DiscountCodeUser[]
+
+  @OneToMany(() => ProductTopping, (productTopping) => productTopping.company)
+  product_toppings: ProductTopping[]
+}

package/src/entities/Configuration.ts

@@ -0,0 +1,14 @@
+import { Entity, Column, PrimaryColumn } from 'typeorm'
+
+@Entity()
+export class Configuration {
+  @PrimaryColumn({ length: 20 })
+  profile: string
+
+  @Column({
+    type: 'longtext',
+    comment:
+      'Columna de tipo JSON para agregar la información y configuración respecto a la plataforma.',
+  })
+  settings: string
+}

package/src/entities/Country.ts

@@ -0,0 +1,44 @@
+import { Entity, Column, PrimaryGeneratedColumn, OneToMany } from 'typeorm'
+import { Region } from './Region'
+
+@Entity()
+export class Country {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 10 })
+  code: string
+
+  @Column({ length: 50 })
+  name: string
+
+  @Column({
+    length: 10,
+    comment:
+      'Usamos esta columna para saber la moneda del país y sugerírsela al usuario o al local',
+  })
+  currency: string
+
+  @Column({ length: 10 })
+  prefix: string
+
+  @Column({
+    type: 'longtext',
+    comment:
+      'Esta columna de tipo JSON nos sirve para agregar toda la información que se necesita a nivel de información legal de la empresa que se registre, ya que para cada país cambia la información',
+  })
+  legal_information: string
+
+  @Column({
+    type: 'longtext',
+    comment:
+      'Columna de tipo JSON para almacenar la información que se necesita para la información del representante legal de la empresa',
+  })
+  legal_agent: string
+
+  @Column({ default: 1 })
+  status: number
+
+  @OneToMany(() => Region, (region) => region.country)
+  regions: Region[]
+}

package/src/entities/Day.ts

@@ -0,0 +1,13 @@
+import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm'
+
+@Entity()
+export class Day {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 50 })
+  name: string
+
+  @Column({ default: 1 })
+  status: number
+}

package/src/entities/DiscountCodeCompany.ts

@@ -0,0 +1,59 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm'
+import { User } from './User'
+import { CodeRedemptionHistoryCompany } from './CodeRedemptionHistoryCompany'
+
+@Entity('discount_code_company')
+export class DiscountCodeCompany {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 10 })
+  code: string
+
+  @Column({ length: 10 })
+  discount: string
+
+  @Column({
+    default: 1,
+    comment:
+      'Campo para el tipo de descuento:\r\n1. Porcentaje.\r\n2. Valor en moneda.',
+  })
+  type: number
+
+  @Column({
+    default: 1,
+    comment:
+      'Con esto validamos si la empresa puede usar el código una vez o varias veces:\r\n1. Una sola vez.\r\n0. Más de una vez.\r\n\r\nCon esto validamos sí tenemos qué ir a buscar a la tabla code_redemption_history_company',
+  })
+  single_use: number
+
+  @Column({ type: 'datetime' })
+  created: Date
+
+  @Column({ type: 'date' })
+  expiration: Date
+
+  @Column({ type: 'datetime' })
+  updated: Date
+
+  @Column({ default: 1 })
+  status: number
+
+  @ManyToOne(() => User, (user) => user.discount_code_companies)
+  @JoinColumn({ name: 'update_by' })
+  updated_by: User
+
+  @OneToMany(
+    () => CodeRedemptionHistoryCompany,
+    (codeRedemptionHistoryCompany) =>
+      codeRedemptionHistoryCompany.discount_code_company
+  )
+  code_redemptions_history_company: CodeRedemptionHistoryCompany[]
+}

package/src/entities/DiscountCodeUser.ts

@@ -0,0 +1,63 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm'
+import { User } from './User'
+import { Company } from './Company'
+import { CodeRedemptionHistoryUser } from './CodeRedemptionHistoryUser'
+
+@Entity('discount_code_user')
+export class DiscountCodeUser {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(() => Company, (company) => company.discount_code_users)
+  @JoinColumn({ name: 'company' })
+  company: Company
+
+  @Column({ length: 10 })
+  code: string
+
+  @Column({ length: 10 })
+  discount: string
+
+  @Column({
+    comment:
+      'Campo para el tipo de descuento: \r\n1. Porcentaje.\r\n2. Valor en moneda.',
+  })
+  type: number
+
+  @Column({
+    default: 1,
+    comment:
+      'Con esto validamos si la empresa puede usar el código una vez o varias veces:\r\n1. Una sola vez.\r\n0. Más de una vez.\r\n\r\nCon esto validamos sí tenemos que ir a buscar a la tabla code_redemption_history_user',
+  })
+  single_use: number
+
+  @Column({ type: 'datetime' })
+  created: Date
+
+  @Column({ type: 'date' })
+  expiration: Date
+
+  @ManyToOne(() => User, (user) => user.discount_code_users)
+  @JoinColumn({ name: 'updated_by' })
+  updated_by: User
+
+  @Column({ type: 'datetime' })
+  updated: Date
+
+  @Column({ default: 1 })
+  status: number
+
+  @OneToMany(
+    () => CodeRedemptionHistoryUser,
+    (codeRedemptionHistoryUser) =>
+      codeRedemptionHistoryUser.discount_code_user
+  )
+  code_redemptions_history_users: CodeRedemptionHistoryUser[]
+}

package/src/entities/Local.ts

@@ -0,0 +1,86 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  ManyToMany,
+  JoinTable,
+  OneToMany,
+} from 'typeorm'
+import { Company } from './Company'
+import { City } from './City'
+import { User } from './User'
+import { Product } from './Product'
+
+@Entity()
+export class Local {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(() => Company, (company) => company.locals)
+  @JoinColumn({ name: 'company' })
+  company: Company
+
+  @Column({ length: 100 })
+  name: string
+
+  @ManyToOne(() => City, (city) => city.locals)
+  @JoinColumn({ name: 'city' })
+  city: City
+
+  @Column({ length: 120 })
+  address: string
+
+  @Column({ type: 'decimal', precision: 10, scale: 8 })
+  latitude: number
+
+  @Column({ type: 'decimal', precision: 10, scale: 8 })
+  longitude: number
+
+  @Column({
+    type: 'longtext',
+    nullable: true,
+    comment:
+      'Campo de tipo JSON por si es necesario agregar información adicional',
+  })
+  details: string
+
+  @Column({ type: 'datetime' })
+  created: Date
+
+  @Column({ type: 'datetime' })
+  updated: Date
+
+  @ManyToOne(() => User, (user) => user.locals)
+  @JoinColumn({ name: 'update_by' })
+  updated_by: User
+
+  @Column({
+    type: 'int',
+    default: 0,
+    comment:
+      'Me indica si el local está en una plazoleta o no:\r\n1. Plazoleta.\r\n0. No plazoleta.',
+  })
+  square: number
+
+  @Column({ default: 1 })
+  status: number
+
+  @ManyToMany(() => User)
+  @JoinTable({
+    name: 'local_user',
+    joinColumn: {
+      name: 'user',
+      referencedColumnName: 'id',
+    },
+    inverseJoinColumn: {
+      name: 'local',
+      referencedColumnName: 'id',
+    },
+  })
+  users: User[]
+
+  @OneToMany(() => Product, (product) => product.local)
+  products: Product[]
+}

package/src/entities/Master.ts

@@ -0,0 +1,15 @@
+import { Entity, Column, PrimaryColumn, ManyToOne, JoinColumn } from 'typeorm'
+import { User } from './User'
+
+@Entity()
+export class Master {
+  @PrimaryColumn()
+  id: number
+
+  @ManyToOne(() => User, (user) => user.masters)
+  @JoinColumn({ name: 'user' })
+  user: User
+
+  @Column({ default: 1 })
+  status: number
+}

package/src/entities/Permission.ts

@@ -0,0 +1,40 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToMany,
+  JoinTable,
+} from 'typeorm'
+import { Role } from './Role'
+
+@Entity()
+export class Permission {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 10, unique: true })
+  code: string
+
+  @Column({
+    length: 40,
+    comment:
+      'Id de la variable que se encuentra en los archivos "locale" para el multilenguaje.',
+  })
+  name: string
+
+  @Column({
+    length: 40,
+    comment:
+      'Id de la variable que se encuentra en los archivos "locale" para el multilenguaje.',
+  })
+  description: string
+
+  @Column({ default: 1 })
+  status: number
+
+  @ManyToMany(() => Role)
+  @JoinTable({
+    name: 'role_permission',
+  })
+  roles: Role[]
+}

package/src/entities/Plan.ts

@@ -0,0 +1,57 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm'
+import { User } from './User'
+import { Company } from './Company'
+
+@Entity()
+export class Plan {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 20, unique: true })
+  code: string
+
+  @Column({
+    length: 50,
+    comment:
+      'Id de la variable que se encuentra en los archivos "locale" para el multilenguaje.',
+  })
+  name: string
+
+  @Column({
+    type: 'mediumtext',
+    nullable: true,
+    comment:
+      'Campo de tipo JSON donde se guarda información necesaria para el plan',
+  })
+  description: string
+
+  @Column({
+    default: 0,
+    comment:
+      'Con este campo sabemos sí el plan es o no es personalizado para una empresa en específico.\r\n1. Personalizado.\r\n0. No personalizado.',
+  })
+  customized: number
+
+  @Column({ type: 'datetime' })
+  created: Date
+
+  @Column({ type: 'date' })
+  expiration: Date
+
+  @ManyToOne(() => User, (user) => user.plans, { nullable: true })
+  @JoinColumn({ name: 'created_by' })
+  created_by: User
+
+  @Column({ default: 1 })
+  status: number
+
+  @OneToMany(() => Company, (company) => company.plan)
+  companies: Company[]
+}

package/src/entities/Product.ts

@@ -0,0 +1,64 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm'
+import { Local } from './Local'
+import { ProductGroup } from './ProductGroup'
+
+@Entity()
+export class Product {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(() => Local, (local) => local.products)
+  @JoinColumn({ name: 'local' })
+  local: Local
+
+  @Column({ length: 50 })
+  name: string
+
+  @Column({ length: 400 })
+  details: string
+
+  @Column({ length: 20 })
+  price: string
+
+  @Column({
+    default: 0,
+    comment:
+      '¿El producto cuenta con restricción de edad?\r\n1. Cuenta con restricción.\r\n0. No cuenta con restricción.',
+  })
+  age_restriction: number
+
+  @Column({
+    default: 0,
+    comment: '¿El producto es un combo?\r\n1. Combo.\r\n0. No es un combo.',
+  })
+  combo: number
+
+  @Column()
+  position: number
+
+  @Column({
+    type: 'text',
+    nullable: true,
+    comment: 'Campo de tipo json para guardar el id y la url de la foto',
+  })
+  photo: string
+
+  @Column({ type: 'mediumtext', nullable: true })
+  additional_information: string
+
+  @Column({ type: 'datetime' })
+  created: Date
+
+  @Column({ type: 'datetime' })
+  updated: Date
+
+  @OneToMany(() => ProductGroup, (productGroup) => productGroup.product)
+  product_groups: ProductGroup[]
+}

package/src/entities/ProductGroup.ts

@@ -0,0 +1,62 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm'
+import { Product } from './Product'
+import { ProductTopping } from './ProductTopping'
+import { ProductGroupComplement } from './productGroupComplement'
+
+@Entity('product_group', {
+  comment: 'Grupos para agregar al topping por producto',
+})
+export class ProductGroup {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(() => Product, (product) => product.product_groups)
+  @JoinColumn({ name: 'product' })
+  product: Product
+
+  @ManyToOne(
+    () => ProductTopping,
+    (productTopping) => productTopping.product_groups
+  )
+  @JoinColumn({ name: 'topping' })
+  topping: ProductTopping
+
+  @Column({ length: 30 })
+  name: string
+
+  @Column({
+    default: 1,
+    comment:
+      'El "type" se refiere a si el grupo es opcional o si es requerido:\r\n1. Opcional.\r\n2. Requerido.',
+  })
+  type: number
+
+  @Column({
+    default: 0,
+    comment:
+      'Cantidad mínima que el usuario puede agregar para el grupo.\r\n\r\n- Cuando "type" es "Requerido (2)" entonces la cantidad mínima debería ser 1.\r\n\r\n- Cuando "type" es "Opcional (1)" entonces la cantidad puede ser 0.',
+  })
+  minimum_quantity: number
+
+  @Column({
+    default: 0,
+    comment: 'Cantidad máxima que el usuario puede agregar para el grupo.',
+  })
+  maximum_quantity: number
+
+  @Column()
+  position: number
+
+  @OneToMany(
+    () => ProductGroupComplement,
+    (productGroupComplement) => productGroupComplement.group_id
+  )
+  groups_complement: ProductGroupComplement[]
+}

package/src/entities/ProductTopping.ts

@@ -0,0 +1,36 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm'
+import { Company } from './Company'
+import { ProductGroup } from './ProductGroup'
+
+@Entity('product_topping', {
+  comment:
+    'Tabla para crear toppings y poder agregarlos a los productos, hay toppings que ya están creados para que el usuario no tenga qué agregarlos, o que el usuario pueda agregar sus propios toppings.',
+})
+export class ProductTopping {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(() => Company, (company) => company.product_toppings)
+  @JoinColumn({ name: 'company' })
+  company: Company
+
+  @Column({
+    length: 50,
+    comment:
+      'El "name" se refiere al id de los archivos de lenguaje que está en "locale" del proyecto. Esto se hace para qué sirva el multilenguaje en el proyecto. Cabe recalcar qué las empresas pueden crear sus propios toppings, entonces no pasa nada el lenguaje en el que ellos lo escriban.',
+  })
+  name: string
+
+  @Column({ default: 1 })
+  status: number
+
+  @OneToMany(() => ProductGroup, (productGroup) => productGroup.topping)
+  product_groups: ProductGroup[]
+}

package/src/entities/Region.ts

@@ -0,0 +1,29 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm'
+import { Country } from './Country'
+import { City } from './City'
+
+@Entity()
+export class Region {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 50 })
+  name: string
+
+  @ManyToOne(() => Country, (country) => country.regions)
+  @JoinColumn({ name: 'country' })
+  country: Country
+
+  @Column({ default: 1 })
+  status: number
+
+  @OneToMany(() => City, (city) => city.region)
+  cities: City[]
+}

package/src/entities/Role.ts

@@ -0,0 +1,57 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToMany,
+  JoinTable,
+  OneToMany,
+} from 'typeorm'
+import { Permission } from './Permission'
+import { RoleVisibleTo } from './RoleVisibleTo'
+
+@Entity()
+export class Role {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 10 })
+  code: string
+
+  @Column({
+    length: 40,
+    comment:
+      'Id de la variable que se encuentra en los archivos "locale" para el multilenguaje.\r\n\r\nCabe recordar qué los usuarios también pueden crear roles, estos deben ir normal, sin id para el lenguaje.',
+  })
+  name: string
+
+  @Column({
+    length: 40,
+    nullable: true,
+    comment:
+      'Id de la variable que se encuentra en los archivos "locale" para el multilenguaje.\r\n\r\nCabe recordar qué los usuarios también pueden crear roles, estos deben ir normal, sin id para el lenguaje.',
+  })
+  description: string | null
+
+  @Column({ default: 1 })
+  status: number
+
+  @ManyToMany(() => Permission)
+  @JoinTable({
+    name: 'role_permission',
+    joinColumn: {
+      name: 'permission',
+      referencedColumnName: 'id',
+    },
+    inverseJoinColumn: {
+      name: 'role',
+      referencedColumnName: 'id',
+    },
+  })
+  permissions: Permission[]
+
+  @OneToMany(() => RoleVisibleTo, (roleVisibleTo) => roleVisibleTo.role)
+  rolesVisibleTo: RoleVisibleTo[]
+
+  @OneToMany(() => RoleVisibleTo, (roleVisibleTo) => roleVisibleTo.visible_to)
+  visiblesTo: RoleVisibleTo[]
+}

package/src/entities/RoleVisibleTo.ts

@@ -0,0 +1,25 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm'
+import { Role } from './Role'
+
+@Entity('role_visible_to', {
+  comment:
+    'Con esta tabla validamos cuales son los roles que puede agregar a otros usuarios qué roles',
+})
+export class RoleVisibleTo {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(() => Role, (role) => role.rolesVisibleTo)
+  @JoinColumn({ name: 'role' })
+  role: Role
+
+  @ManyToOne(() => Role, (role) => role.visiblesTo)
+  @JoinColumn({ name: 'visible_to' })
+  visible_to: Role
+}

package/src/entities/ScheduleCategory.ts

@@ -0,0 +1,32 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm'
+import { Category } from './Category'
+import { Day } from './Day'
+
+@Entity('schedule_category', {
+  comment:
+    'Acá podemos agregar los horarios para las categorías de los productos. O sea, si una categoría sólo está los miércoles, entonces podría agregar el día y los horarios.',
+})
+export class ScheduleCategory {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(() => Category, { onDelete: 'CASCADE', onUpdate: 'NO ACTION' })
+  @JoinColumn({ name: 'category' })
+  category: Category
+
+  @ManyToOne(() => Day, { onDelete: 'CASCADE', onUpdate: 'NO ACTION' })
+  @JoinColumn({ name: 'day' })
+  day: Day
+
+  @Column()
+  start_time: string
+
+  @Column()
+  end_time: string
+}

package/src/entities/Terminal.ts

@@ -0,0 +1,47 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToMany,
+  JoinTable,
+  OneToMany,
+} from 'typeorm'
+import { User } from './User'
+import { TerminalSession } from './TerminalSession'
+
+@Entity()
+export class Terminal {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 50 })
+  name: string
+
+  @Column({
+    type: 'longtext',
+    nullable: true,
+    comment:
+      'Campo de tipo JSON donde se guarda información necesaria para la terminal si es necesario',
+  })
+  settings: string
+
+  @Column({ default: 1 })
+  status: number
+
+  @ManyToMany(() => User)
+  @JoinTable({
+    name: 'user_terminal',
+    joinColumn: {
+      name: 'user',
+      referencedColumnName: 'id',
+    },
+    inverseJoinColumn: {
+      name: 'terminal',
+      referencedColumnName: 'id',
+    },
+  })
+  users: User[]
+
+  @OneToMany(() => TerminalSession, (terminalsUser) => terminalsUser.terminal)
+  terminalsUser: TerminalSession[]
+}

package/src/entities/TerminalSession.ts

@@ -0,0 +1,38 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm'
+import { User } from './User'
+import { Terminal } from './Terminal'
+
+@Entity('terminal_session')
+export class TerminalSession {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(() => User, (user) => user.terminalUsers, { nullable: true })
+  @JoinColumn({ name: 'user' })
+  user: User
+
+  @ManyToOne(() => Terminal, (terminal) => terminal.terminalsUser, {
+    nullable: true,
+  })
+  @JoinColumn({ name: 'terminal' })
+  terminal: Terminal
+
+  @Column({ type: 'datetime' })
+  open: Date
+
+  @Column({ type: 'datetime' })
+  close: Date
+
+  @Column({
+    default: 1,
+    comment:
+      'Se valida si la sesión está abierta o cerrada:\r\n1. Abierta.\r\n0. Cerrada.',
+  })
+  status: number
+}

package/src/entities/TypeFood.ts

@@ -0,0 +1,26 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToMany,
+  JoinTable,
+} from 'typeorm'
+import { Company } from './Company'
+
+@Entity('type_food')
+export class TypeFood {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 40 })
+  name: string
+
+  @Column({ default: 1 })
+  status: number
+
+  @ManyToMany(() => Company)
+  @JoinTable({
+    name: 'type_food_company',
+  })
+  companies: Company[]
+}

package/src/entities/User.ts

@@ -0,0 +1,122 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  ManyToMany,
+  JoinTable,
+  OneToMany,
+} from 'typeorm'
+import { City } from './City'
+import { Terminal } from './Terminal'
+import { TerminalSession } from './TerminalSession'
+import { Plan } from './Plan'
+import { Company } from './Company'
+import { Local } from './Local'
+import { DiscountCodeCompany } from './DiscountCodeCompany'
+import { DiscountCodeUser } from './DiscountCodeUser'
+import { CodeRedemptionHistoryUser } from './CodeRedemptionHistoryUser'
+import { Master } from './Master'
+
+@Entity()
+export class User {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @Column({ length: 30, unique: true })
+  code: string
+
+  @Column()
+  document: number
+
+  @Column({ length: 50 })
+  name: string
+
+  @Column({ length: 50 })
+  surname: string
+
+  @Column({ length: 60, unique: true })
+  email: string
+
+  @Column({ length: 12, unique: true })
+  phone: string
+
+  @ManyToOne(() => City, (city) => city.users)
+  @JoinColumn({ name: 'city' })
+  city: City
+
+  @Column({ nullable: true, length: 100 })
+  address: string
+
+  @Column({ type: 'decimal', precision: 10, scale: 8, nullable: true })
+  latitude: number
+
+  @Column({ type: 'decimal', precision: 10, scale: 8, nullable: true })
+  longitude: number
+
+  @Column({ length: 20 })
+  password: string
+
+  @Column({
+    type: 'longtext',
+    nullable: true,
+    comment:
+      'Campo de tipo JSON donde se guarda información necesaria para el usuario',
+  })
+  profile: string
+
+  @Column({ type: 'datetime' })
+  created: Date
+
+  @Column({ type: 'datetime' })
+  updated: Date
+
+  @Column({ default: 1 })
+  status: number
+
+  @ManyToMany(() => Terminal)
+  @JoinTable({
+    name: 'user_terminal',
+  })
+  terminals: Terminal[]
+
+  @OneToMany(() => TerminalSession, (terminalSession) => terminalSession.user)
+  terminalUsers: TerminalSession[]
+
+  @OneToMany(() => Plan, (plan) => plan.created_by)
+  plans: Plan[]
+
+  @OneToMany(() => Company, (company) => company.user)
+  companies: Company[]
+
+  @OneToMany(() => Local, (local) => local.updated_by)
+  locals: Local[]
+
+  @OneToMany(
+    () => DiscountCodeCompany,
+    (discountCodeCompany) => discountCodeCompany.updated_by
+  )
+  discount_code_companies: DiscountCodeCompany[]
+
+  @OneToMany(
+    () => DiscountCodeUser,
+    (discountCodeUser) => discountCodeUser.updated_by
+  )
+  discount_code_users: DiscountCodeUser[]
+
+  @OneToMany(
+    () => CodeRedemptionHistoryUser,
+    (codeRedemptionHistoryUser) => codeRedemptionHistoryUser.user
+  )
+  code_redemption_history_users: CodeRedemptionHistoryUser[]
+
+  @ManyToMany(() => Local)
+  @JoinTable({
+    name: 'local_user',
+  })
+  locals_user: Local[]
+
+  @OneToMany(() => Master, (master) => master.user)
+  masters: Master[]
+}

package/src/entities/productGroupComplement.ts

@@ -0,0 +1,32 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm'
+import { ProductGroup } from './ProductGroup'
+
+@Entity('product_group_complement', {
+  comment: 'Los complementos que tiene el grupo de un producto.',
+})
+export class ProductGroupComplement {
+  @PrimaryGeneratedColumn()
+  id: number
+
+  @ManyToOne(
+    () => ProductGroup,
+    (productGroup) => productGroup.groups_complement
+  )
+  @JoinColumn({ name: 'group_id' })
+  group_id: ProductGroup
+
+  @Column({ length: 30 })
+  name: string
+
+  @Column({ length: 20 })
+  price: string
+
+  @Column()
+  position: number
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+import { IShowEntity } from './interfaces'
+
+// DOCUMENTATION: Función para retornar la entidad de una base de datos en específico por medio de un DataSource
+export function showEntity({ entityName, connection }: IShowEntity): any {
+  return connection.getRepository(entityName)
+}

package/src/interfaces.ts

@@ -0,0 +1,6 @@
+import { DataSource } from 'typeorm'
+
+export interface IShowEntity {
+  entityName: string
+  connection: DataSource
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "strictPropertyInitialization": false,
+  },
+  "include": ["src"]
+}