@valentine-efagene/qshelter-common 1.0.0

package/entities/property.entity.ts

@@ -0,0 +1,147 @@
+import { Column, Entity, JoinColumn, JoinTable, ManyToMany, ManyToOne, OneToMany, OneToOne } from 'typeorm';
+import { PropertyDocument } from './property-document.entity';
+import { PropertyMedia } from './property-media.entity';
+import { User } from './user.entity';
+import { Amenity } from './amenity.entity';
+import { AbstractBaseReviewableEntity } from './common.entity';
+import { Mortgage } from './mortgage.entity';
+import { PropertyStatus, PropertyType } from '../types/property.type';
+import { Currency, PropertyCategory } from '../types/social.enums';
+
+@Entity({ name: 'property' })
+export class Property extends AbstractBaseReviewableEntity {
+  @ManyToOne(() => User, {
+    //eager: true,
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @Column({ nullable: true })
+  userId: number;
+
+  @OneToMany(
+    () => PropertyDocument,
+    (propertyDocument) => propertyDocument.property,
+  )
+  documents: PropertyDocument[];
+
+  @ManyToMany(() => Amenity)
+  @JoinTable()
+  amenities: Amenity[]
+
+  @OneToMany(
+    () => PropertyMedia,
+    (propertyDocument) => propertyDocument.property,
+  )
+
+  media: PropertyMedia[];
+
+  @OneToMany(() => Mortgage, (mortgage) => mortgage.property)
+  mortgages: Mortgage[];
+  @OneToOne(() => PropertyMedia, {
+    onDelete: 'SET NULL', // prevents FK errors if image is deleted
+    onUpdate: 'CASCADE'
+  })
+  @JoinColumn({ name: 'display_image_id' })
+  displayImage: PropertyMedia;
+
+  @Column({
+    nullable: true
+  })
+  displayImageId: number
+
+  @Column({ nullable: true })
+  title: string;
+
+  @Column({
+    nullable: true,
+    type: 'enum',
+    enum: PropertyCategory,
+  })
+  category: PropertyCategory;
+
+  @Column({
+    nullable: true,
+    type: 'enum',
+    enum: PropertyType
+  })
+  propertyType: string;
+
+  @Column({ nullable: true })
+  country: string;
+
+  @Column({
+    nullable: true,
+    type: 'enum',
+    enum: Currency,
+  })
+  currency: Currency;
+
+  @Column({ nullable: true })
+  city: string;
+
+  @Column({ nullable: true })
+  district: string;
+
+  @Column({ nullable: true })
+  zipCode: string;
+
+  @Column({ nullable: true })
+  streetAddress: string;
+
+  @Column({ nullable: false })
+  nBedrooms: string
+
+  @Column({ nullable: false })
+  nBathrooms: string
+
+  @Column({ nullable: false })
+  nParkingSpots: string
+
+  @Column({
+    type: 'double precision',
+    scale: 2,
+    precision: 20,
+    nullable: true,
+  })
+  price: number
+
+  @Column({
+    type: 'double precision',
+    scale: 2,
+    precision: 20,
+    nullable: true,
+  })
+  longitude: number
+
+  @Column({
+    type: 'double precision',
+    scale: 2,
+    precision: 20,
+    nullable: true,
+  })
+  latitude: number
+
+  @Column({
+    type: 'double precision',
+    scale: 2,
+    precision: 20,
+    nullable: true,
+  })
+  area: number
+
+  @Column({
+    type: 'text',
+    nullable: true
+  })
+  description: string
+
+  @Column({
+    type: 'enum',
+    enum: PropertyStatus,
+    default: PropertyStatus.PENDING,
+  })
+  status: PropertyStatus;
+}

package/entities/refresh_token.entity.ts

@@ -0,0 +1,16 @@
+import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
+import { BaseEntity } from './BaseEntity';
+import { User } from './user.entity';
+
+@Entity({ name: 'refresh_tokens' })
+export class RefreshToken extends BaseEntity {
+  @ManyToOne(() => User, (user) => user.refreshTokens)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @Column({ nullable: true })
+  userId: number;
+
+  @Column({ nullable: false, type: 'text' })
+  token: string;
+}

package/entities/role.entity.ts

@@ -0,0 +1,20 @@
+import { Column, Entity, JoinTable, ManyToMany } from 'typeorm';
+import { Permission } from './permission.entity';
+import { User } from './user.entity';
+import { BaseEntity } from './BaseEntity';
+
+@Entity({ name: 'roles' })
+export class Role extends BaseEntity {
+  @Column({ nullable: true })
+  name: string;
+
+  @ManyToMany(() => Permission, (permission) => permission.roles, {
+    onDelete: 'CASCADE',
+    eager: true
+  })
+  @JoinTable()
+  permissions: Permission[]
+
+  @ManyToMany(() => User, (user) => user.roles)
+  users: User[]
+}

package/entities/settings.entity.ts

@@ -0,0 +1,56 @@
+import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+import { PropertyMedia } from './property-media.entity';
+import { User } from './user.entity';
+import { AbstractBaseReviewableEntity } from './common.entity';
+import { Status } from '../types/common.type';
+
+@Entity({ name: 'settings' })
+export class Settings extends AbstractBaseReviewableEntity {
+  @ManyToOne(() => User, {
+    //eager: true,
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: 'created_by' })
+  creator: User;
+
+  @Column({ nullable: true })
+  createdBy: number;
+
+  @OneToMany(
+    () => PropertyMedia,
+    (PropertyMedia) => PropertyMedia.property,
+  )
+  media: PropertyMedia[];
+
+  @Column({ nullable: true })
+  title: string;
+
+  @Column()
+  location: string;
+
+  @Column()
+  startTime: Date;
+
+  @Column()
+  endTime: Date;
+
+  @Column({ default: true })
+  isPrivate: boolean;
+
+  @Column({ nullable: true })
+  qrOfflineCode: string;
+
+  @Column({
+    type: 'text',
+    nullable: true
+  })
+  description: string
+
+  @Column({
+    type: 'enum',
+    enum: Status,
+    default: Status.PENDING,
+  })
+  status: Status;
+}

package/entities/social.entity.ts

@@ -0,0 +1,27 @@
+import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
+import { User } from './user.entity';
+import { AbstractBaseReviewableEntity } from './common.entity';
+
+@Entity({ name: 'social' })
+export class Social extends AbstractBaseReviewableEntity {
+  @ManyToOne(() => User, {
+    //eager: true,
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @Column({ nullable: true })
+  userId: number;
+
+  @Column({
+    nullable: true,
+  })
+  brand: string;
+
+  @Column({
+    nullable: true,
+  })
+  link: string;
+}

package/entities/tenant.entity.ts

@@ -0,0 +1,65 @@
+import { Entity, Column, Index, Unique } from 'typeorm';
+import { BaseEntity } from './BaseEntity';
+import { TenantStatus, TenantPlan } from '../types/tenant.enums';
+
+@Entity({ name: 'tenants' })
+@Unique(['subdomain'])
+@Unique(['domain'])
+export class Tenant extends BaseEntity {
+    @Column({ length: 255 })
+    name: string;
+
+    @Column({ length: 100, unique: true })
+    @Index()
+    subdomain: string; // e.g., 'acme' for acme.yourdomain.com
+
+    @Column({ length: 255, nullable: true, unique: true })
+    domain: string; // Optional custom domain: e.g., 'realestate.acme.com'
+
+    @Column({ type: 'varchar', default: TenantStatus.ACTIVE })
+    status: TenantStatus;
+
+    @Column({ type: 'varchar', default: TenantPlan.FREE })
+    plan: TenantPlan;
+
+    @Column({ type: 'json', nullable: true })
+    config: {
+        maxUsers?: number;
+        maxProperties?: number;
+        features?: string[];
+        customBranding?: {
+            logo?: string;
+            primaryColor?: string;
+            secondaryColor?: string;
+        };
+        [key: string]: any;
+    };
+
+    @Column({ type: 'json', nullable: true })
+    metadata: any; // Additional tenant-specific metadata
+
+    @Column({ type: 'timestamp', nullable: true })
+    trialEndsAt: Date;
+
+    @Column({ type: 'timestamp', nullable: true })
+    subscriptionEndsAt: Date;
+
+    // Contact information
+    @Column({ length: 255, nullable: true })
+    contactEmail: string;
+
+    @Column({ length: 50, nullable: true })
+    contactPhone: string;
+
+    // Database strategy (for future use if migrating to separate databases per tenant)
+    @Column({ type: 'varchar', default: 'shared' })
+    databaseStrategy: 'shared' | 'isolated';
+
+    @Column({ length: 255, nullable: true })
+    databaseHost: string;
+
+    @Column({ length: 100, nullable: true })
+    databaseName: string;
+}
+
+export default Tenant;

package/entities/transaction.entity.ts

@@ -0,0 +1,56 @@
+import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+import { Provider, TransactionType } from '../types/transaction.type';
+import { Wallet } from './wallet.entity';
+import { User } from './user.entity';
+
+@Entity({ name: 'prod_transactions' })
+export class Transaction {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({
+    type: 'enum',
+    enum: TransactionType
+  })
+  type: TransactionType
+
+  @ManyToOne(() => Wallet, wallet => wallet.transactions, {
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: 'wallet_id' })
+  wallet: Wallet;
+
+  @Column()
+  walletId: number
+
+  @ManyToOne(() => User, (user) => user.transactions)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @Column()
+  userId: number
+
+  @Column({
+    type: 'enum',
+    enum: Provider
+  })
+  provider: Provider
+
+  @Column()
+  ref: string
+
+  @Column({
+    type: 'text'
+  })
+  metadata: string
+
+  @Column({ type: 'decimal', precision: 65, scale: 2, nullable: true })
+  amount: number;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

package/entities/user.entity.ts

@@ -0,0 +1,89 @@
+import { Column, Entity, JoinTable, ManyToMany, OneToMany } from 'typeorm';
+import { TenantAwareBaseEntity } from './BaseEntity';
+import { UserStatus } from '../types/user.enums';
+import { Role } from './role.entity';
+import { RefreshToken } from './refresh_token.entity';
+import { Property } from './property.entity';
+import { Transaction } from './transaction.entity';
+import { Wallet } from './wallet.entity';
+
+@Entity({ name: 'users' })
+export class User extends TenantAwareBaseEntity {
+  @Column({ nullable: true })
+  firstName?: string;
+
+  @Column({ nullable: true })
+  lastName?: string;
+
+  @Column({ nullable: true })
+  phone?: string;
+
+  @Column({ nullable: true, type: 'text' })
+  bio?: string;
+
+  @Column({ nullable: true })
+  address?: string;
+
+  @Column({ nullable: true })
+  email: string;
+
+  @Column({ nullable: true })
+  password: string;
+
+  @Column({ type: 'text', nullable: true })
+  avatar?: string;
+
+  @Column({ nullable: true })
+  gender: string;
+
+  @ManyToMany(() => Role, (role) => role.users, {
+    onDelete: 'CASCADE',
+    eager: true
+  })
+  @JoinTable()
+  roles?: Role[]
+
+  @OneToMany(
+    () => RefreshToken,
+    (refreshToken) =>
+      refreshToken.user,
+    { eager: true },
+  )
+  refreshTokens: RefreshToken[];
+
+  @OneToMany(
+    () => Wallet,
+    (wallet) =>
+      wallet.user,
+    { eager: true },
+  )
+  wallets: Wallet[];
+
+  @OneToMany(
+    () => Transaction,
+    (transaction) =>
+      transaction.user,
+    { eager: true },
+  )
+  transactions: Transaction[];
+
+  @OneToMany(
+    () => Property,
+    (property) =>
+      property.user,
+  )
+  properties: Property[];
+
+  @Column({
+    type: 'enum',
+    enum: UserStatus,
+    default: UserStatus.PENDING
+  })
+  status: UserStatus
+
+  @Column({ default: false })
+  isEmailVerified?: boolean;
+
+  @Column({ nullable: true })
+  emailVerificationToken: string | null
+}

package/entities/user_suspensions.entity.ts

@@ -0,0 +1,24 @@
+import { Column, Entity, JoinColumn, OneToOne } from 'typeorm';
+import { BaseEntity } from './BaseEntity';
+import { User } from './user.entity';
+
+@Entity({ name: 'user_suspension' })
+export class UserSuspension extends BaseEntity {
+  @OneToOne(() => User, {
+    //eager: true,
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @Column({
+    nullable: false
+  })
+  userId: number
+
+  @Column({
+    nullable: false
+  })
+  reason: string
+}

package/entities/wallet.entity.ts

@@ -0,0 +1,54 @@
+import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+import { Transaction } from './transaction.entity';
+import { User } from './user.entity';
+import { Currency } from '../types/social.enums';
+
+@Entity({ name: 'wallets' })
+export class Wallet {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @ManyToOne(() => User, (user) => user.wallets)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @Column()
+  userId: number
+
+  @Column({
+    type: 'enum',
+    enum: Currency
+  })
+  currency: number
+
+  @Column({
+  })
+  customerId: string
+
+  @Column({
+  })
+  bankName: string
+
+  @Column({
+  })
+  accountNumber: string
+
+  @Column({
+  })
+  accountName: string
+
+  @Column({ type: 'decimal', precision: 65, scale: 2, nullable: true })
+  balance: number;
+
+  @Column()
+  enabled: boolean
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @OneToMany(() => Transaction, transaction => transaction.wallet)
+  transactions: Transaction[]
+}

package/guard/permission.guard.ts

@@ -0,0 +1,42 @@
+import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { RequirePermission } from '../decorator/permission.decorator';
+import { Observable } from 'rxjs';
+import { User } from '../../user/user.entity';
+
+@Injectable()
+export class PermissionGuard implements CanActivate {
+  constructor(private reflector: Reflector) { }
+
+  canActivate(
+    context: ExecutionContext,
+  ): boolean | Promise<boolean> | Observable<boolean> {
+    const permission = this.reflector.get(RequirePermission, context.getHandler());
+
+    if (!permission) {
+      return true;
+    }
+
+    const request = context.switchToHttp().getRequest();
+
+    const user: User = request.user;
+
+    if (!user) {
+      return false
+    }
+
+    return this.matchPermission(permission, user);
+  }
+
+  matchPermission(permission: string, user: User) {
+    const roles = user.roles
+
+    if (!roles || roles.length < 1) {
+      return false
+    }
+
+    const permissions = roles.map(role => role.permissions).reduce((acc, curr) => [...acc, ...curr]) ?? []
+    const permissionNames = permissions?.map(permission => permission.name)
+    return permissionNames.includes(permission)
+  }
+}

package/guard/swagger-auth.guard.ts

@@ -0,0 +1,9 @@
+import { applyDecorators, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth } from '@nestjs/swagger';
+
+export function SwaggerAuth() {
+    return applyDecorators(
+        // UseGuards(AuthGuard),
+        ApiBearerAuth()
+    );
+}

package/helpers/ArrayHelper.ts

@@ -0,0 +1 @@
+export default class ArrayHelper {}