eh-commons 0.0.1-testing.1

package/src/models/dtos/state-params.dto.ts

@@ -0,0 +1,10 @@
+import { IsEnum, IsString } from 'class-validator';
+import { RecordState } from '../enums/record-state.enum';
+
+export class StateParamDTO {
+  @IsString()
+  id: string;
+
+  @IsEnum(RecordState)
+  state: RecordState;
+}

package/src/models/embedded/address.embedded.ts

@@ -0,0 +1,17 @@
+import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
+import { IAddress } from "../interfaces/address.interface";
+import { GeoLocation } from "./geo-location.embedded";
+import { HydratedDocument } from "mongoose";
+
+@Schema({ _id: false })
+export class Address implements IAddress{
+    @Prop({ type: String, required: false })
+    city: string;
+    @Prop({ type: String, required: false })
+    address: string;
+    @Prop({ type: GeoLocation, required: false })
+    location: GeoLocation;
+}
+
+export const AddressSchema = SchemaFactory.createForClass(Address);
+export type AddressDocument = HydratedDocument<Address>;

package/src/models/embedded/contact.embedded.ts

@@ -0,0 +1,22 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { ContactType } from '../enums/contact-type.enum';
+import { IContact } from '../interfaces/contact.interface';
+import { HydratedDocument } from 'mongoose';
+
+@Schema({ _id: false })
+export class Contact implements IContact {
+  @Prop({
+    type: String,
+    enum: ContactType,
+    required: true,
+  })
+  type: ContactType;
+
+  @Prop({ type: String, required: true })
+  value: string;
+  @Prop({ type: Boolean, required: true, default: false })
+  verified: boolean;
+}
+
+export const ContactSchema = SchemaFactory.createForClass(Contact);
+export type ContactDocument = HydratedDocument<Contact>;

package/src/models/embedded/geo-location.embedded.ts

@@ -0,0 +1,17 @@
+import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
+import { IGeoLocation } from "../interfaces/geo-location.interface";
+import { HydratedDocument } from "mongoose";
+
+
+@Schema({ _id: false })
+export class GeoLocation implements IGeoLocation{
+    @Prop({ type: Number, required: false })
+    lat: number;
+    @Prop({ type: Number, required: false })
+    lng: number;
+    @Prop({ type: String, required: false })
+    system: string;
+}
+
+export const GeoLocationSchema = SchemaFactory.createForClass(GeoLocation);
+export type GeoLocationDocument = HydratedDocument<GeoLocation>;

package/src/models/embedded/i18n.embedded.ts

@@ -0,0 +1,16 @@
+import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
+import { II18n } from "../interfaces/i18n.interface";
+import { HydratedDocument } from "mongoose";
+
+@Schema({ _id: false })
+export class I18n implements II18n{
+    @Prop({ type: String, required: false })
+    ge: string;
+    @Prop({ type: String, required: false })
+    en: string;
+    @Prop({ type: String, required: false })
+    ua: string;
+}
+
+export const I18nSchema = SchemaFactory.createForClass(I18n);
+export type I18nDocument = HydratedDocument<I18n>;

package/src/models/embedded/person.embedded.ts

@@ -0,0 +1,16 @@
+import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
+import { IPerson } from "../interfaces/person.interface";
+import { HydratedDocument } from "mongoose";
+
+@Schema({ _id: false })
+export class Person implements IPerson{
+    @Prop({ type: String, required: false })
+    pid: string;
+    @Prop({ type: String, required: false })
+    firstName: string;
+    @Prop({ type: String, required: false })
+    lastName: string;
+}
+
+export const PersonSchema = SchemaFactory.createForClass(Person);
+export type PersonDocument = HydratedDocument<Person>;

package/src/models/embedded/record.embedded.ts

@@ -0,0 +1,30 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { RecordState } from '../enums/record-state.enum';
+import { HydratedDocument } from 'mongoose';
+import { IRecord } from '../interfaces/record.interface';
+
+@Schema({ _id: false })
+export class Record implements IRecord {
+  @Prop({
+    type: String,
+    enum: RecordState,
+    required: true,
+    default: RecordState.DRAFT,
+  })
+  state: RecordState;
+
+  @Prop({ type: Boolean, required: true, default: false })
+  deleted: boolean;
+
+  @Prop({ type: Date, required: true, default: Date.now })
+  createdAt: Date;
+
+  @Prop({ type: Date, required: false })
+  updatedAt: Date;
+
+  @Prop({ type: Date, required: false })
+  deletedAt: Date;
+}
+
+export const RecordSchema = SchemaFactory.createForClass(Record);
+export type RecordDocument = HydratedDocument<Record>;

package/src/models/enums/contact-type.enum.ts

@@ -0,0 +1,4 @@
+export enum ContactType {
+  EMAIL = 'email',
+  PHONE = 'phone',
+}

package/src/models/enums/env.enum.ts

@@ -0,0 +1,5 @@
+export enum Env {
+    MAIN = 'main',
+    STAGING = 'staging',
+    TESTING = 'testing',
+  }

package/src/models/enums/fail-keyword.enum.ts

@@ -0,0 +1,6 @@
+export enum FailKeywords {
+  SYSTEM = 'SYSTEM',
+  THROTTLE = 'THROTTLE',
+  UNKNOWN = 'UNKNOWN',
+  //todo add more keywords
+}

package/src/models/enums/http-method.enum.ts

@@ -0,0 +1,7 @@
+export enum HTTPMethod {
+  POST = 'post',
+  GET = 'get',
+  PUT = 'put',
+  PATCH = 'patch',
+  DELETE = 'delete',
+}

package/src/models/enums/permission-include-strategy.enum.ts

@@ -0,0 +1,5 @@
+export enum PermissionsIncludeStrategy {
+  ONLY_CHECK = 'ONLY_CHECK',
+  CHECK_AND_INCLUDE_SELECTED = 'CHECK_AND_INCLUDE_SELECTED',
+  CHECK_AND_INCLUDE_ALL = 'CHECK_AND_INCLUDE_ALL',
+}

package/src/models/enums/record-state.enum.ts

@@ -0,0 +1,5 @@
+export enum RecordState {
+  DRAFT = 'draft',
+  ACTIVE = 'active',
+  INACTIVE = 'inactive',
+}

package/src/models/interfaces/address.interface.ts

@@ -0,0 +1,7 @@
+import { IGeoLocation } from "./geo-location.interface";
+
+export interface IAddress{
+    city: string;
+    address: string;
+    location: IGeoLocation;
+}

package/src/models/interfaces/contact.interface.ts

@@ -0,0 +1,7 @@
+import { ContactType } from "../enums/contact-type.enum";
+
+export interface IContact{
+    type: ContactType;
+    value: string;
+    verified: boolean;
+}

package/src/models/interfaces/geo-location.interface.ts

@@ -0,0 +1,5 @@
+export interface IGeoLocation{
+    lat: number;
+    lng: number;
+    system: string;
+}

package/src/models/interfaces/i18n.interface.ts

@@ -0,0 +1,5 @@
+export interface II18n{
+    ge: string;
+    en: string;
+    ua: string;
+}

package/src/models/interfaces/person.interface.ts

@@ -0,0 +1,5 @@
+export interface IPerson{
+    pid: string;
+    firstName: string;
+    lastName: string;
+}

package/src/models/interfaces/record.interface.ts

@@ -0,0 +1,9 @@
+import { RecordState } from "../enums/record-state.enum";
+
+export interface IRecord {
+  state: RecordState;
+  deleted: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  deletedAt: Date;
+}

package/src/models/interfaces/session/session-data.interface.ts

@@ -0,0 +1,11 @@
+export interface ISessionUserData {
+    id: number;
+    primaryEmail: string;
+    primaryPhone: string;
+    personInfo: {
+        pid: string;
+        firstName: string;
+        lastName: string;
+        birthDate: Date;
+    }
+}

package/src/models/interfaces/session/session.interface.ts

@@ -0,0 +1,9 @@
+import { ISessionUserData } from "./session-data.interface";
+
+export interface ISession {
+    token: string;
+    userAgent: string;
+    createdAt: Date;
+    expiresAt: Date;
+    data: ISessionUserData
+}

package/src/models/wrappers/client-permissions.wrapper.ts

@@ -0,0 +1,4 @@
+export class ClientPermissions {
+  clientId: number;
+  permissions: string[];
+}

package/src/models/wrappers/permission-guard-config.wrapper.ts

@@ -0,0 +1,7 @@
+import { PermissionsIncludeStrategy } from '../enums/permission-include-strategy.enum';
+
+export class PermissionGuardConfig {
+  appAbbr?: string = 'EH';
+  includeStrategy?: PermissionsIncludeStrategy;
+  keyword?: string;
+}

package/src/models/wrappers/rest-wrapper.class.ts

@@ -0,0 +1,172 @@
+import { HttpStatus } from '@nestjs/common';
+import { Type } from 'class-transformer';
+import { IsArray, IsEnum, IsNotEmpty, IsNumber, IsOptional, IsString, ValidateNested } from 'class-validator';
+
+export enum SortDirection {
+  asc = 1,
+  desc = -1,
+}
+
+export abstract class RESTSort {
+  @IsNotEmpty()
+  @IsString()
+  property: string;
+
+  @IsNotEmpty()
+  @IsNumber()
+  @IsEnum(SortDirection)
+  direction: SortDirection;
+}
+
+export abstract class RESTPaging {
+  @IsNotEmpty()
+  @IsNumber()
+  page: number;
+
+  @IsNotEmpty()
+  @IsNumber()
+  size: number;
+
+  public extract() {
+    const skip = (this.page - 1) * this.size;
+    return { skip, limit: this.size };
+  }
+}
+
+export abstract class RESTRequestBody {
+  @IsNotEmpty()
+  @ValidateNested()
+  abstract data: any;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => RESTPaging)
+  paging: RESTPaging;
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested()
+  @Type(() => RESTSort)
+  sort: RESTSort[];
+
+  public isPagingPresent() {
+    if (this.paging && this.paging.page) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public isSortPresent() {
+    if (this.sort && this.sort.length) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public extractPaging() {
+    if (this.isPagingPresent()) {
+      return this.paging.extract();
+    }
+    return null;
+  }
+
+  public extractSort() {
+    const sort = {};
+    if (this.isSortPresent()) {
+      for (let item of this.sort) {
+        sort[item.property] = item.direction;
+      }
+    }
+    return sort;
+  }
+}
+
+export class RESTPage {
+  // გვერდი
+  page: number;
+
+  // ჩანაწერების რაოდენობა გვერდზე
+  size: number;
+
+  // გვერდების ჯამური რაოდენობა
+  number: number;
+
+  // ჩანაწერების ჯამური რაოდენობა
+  total: number;
+
+  public static create(count: number, paging: RESTPaging): RESTPage {
+    const page = new RESTPage();
+    page.page = paging.page;
+    page.size = paging.size;
+    page.number = (count - (count % paging.size)) / paging.size;
+    if (count % paging.size > 0) {
+      page.number += 1;
+    }
+    page.total = count;
+    return page;
+  }
+}
+
+export class RESTResult<T> {
+  data: T;
+  page: RESTPage;
+  sort: RESTSort[];
+}
+
+export class RESTError {
+  keyword: string;
+  debug?: any;
+  validation?: any;
+  statusCode?: HttpStatus;
+
+  constructor(keyword: string, debug?: any) {
+    this.keyword = keyword;
+    this.debug = debug;
+  }
+
+  public static throw(keyword: string, statusCode?: HttpStatus, debug?: any) {
+    const error = new RESTError(keyword, debug);
+    error.statusCode = statusCode || HttpStatus.BAD_REQUEST;
+    throw error;
+  }
+
+  public static dataValidation(validation: any) {
+    const error = new RESTError('body_validation_error', null);
+    error.validation = validation;
+    return error;
+  }
+}
+
+export class RESTResponseBody<T> {
+  public statusCode: number;
+  public result: RESTResult<T>;
+  public errors: RESTError[];
+
+  public addError(error: RESTError): void {
+    if (!this.errors) {
+      this.errors = [];
+    }
+    this.errors.push(error);
+  }
+
+  public static success<T>(data: T, page?: RESTPage, sort?: RESTSort[]): RESTResponseBody<T> {
+    const response = new RESTResponseBody<T>();
+
+    response.statusCode = 200;
+    response.result = new RESTResult<T>();
+    response.result.data = data;
+    response.result.page = page;
+    response.result.sort = sort;
+
+    return response;
+  }
+
+  public static fail(errors: RESTError[], statusCode?: number): RESTResponseBody<any> {
+    const response = new RESTResponseBody<any>();
+    response.statusCode = statusCode;
+    response.errors = errors;
+    return response;
+  }
+}

package/src/modules/cache/cache.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { RedisService } from './services/redis.service';
+import { SessionService } from './services/session.service';
+import { PermissionGuard } from './guards/permission.guard';
+
+@Module({
+  imports: [],
+  controllers: [],
+  providers: [RedisService, SessionService, PermissionGuard],
+  exports: [],
+})
+export class CacheModule {}

package/src/modules/cache/guards/permission.guard.ts

@@ -0,0 +1,166 @@
+import {
+  Injectable,
+  CanActivate,
+  ExecutionContext,
+  HttpStatus,
+} from '@nestjs/common';
+import { SessionService } from '../services/session.service';
+import { Reflector } from '@nestjs/core';
+import { Permission } from '../reflector/permission.reflector';
+import { PermissionsIncludeStrategy } from '../../../models/enums/permission-include-strategy.enum';
+import { ISessionUserData } from '../../../models/interfaces/session/session-data.interface';
+import { ClientPermissions } from '../../../models/wrappers/client-permissions.wrapper';
+import { RESTError } from '../../../models/wrappers/rest-wrapper.class';
+
+@Injectable()
+export class PermissionGuard implements CanActivate {
+  constructor(
+    private sessionService: SessionService,
+    private reflector: Reflector,
+  ) { }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const config = this.reflector.get(Permission, context.getHandler());
+    const request = context.switchToHttp().getRequest();
+    const queryParameters = request.query;
+    const headers = request.headers;
+    const token: string = this.getTokenFromHeaders(headers);
+    if (!token) RESTError.throw('unauthorized', HttpStatus.UNAUTHORIZED);
+    
+    const userData = {};
+    // await this.sessionService.getUserByToken(token);
+    if (!userData) {
+      RESTError.throw('unauthorized', HttpStatus.UNAUTHORIZED);
+      return false;
+    }
+    const abbr = config.appAbbr;
+    const clientId: number = this.getClientIdFromQuery(queryParameters);
+    let clientPermissionsArray: ClientPermissions[];
+    switch (config.includeStrategy) {
+      case PermissionsIncludeStrategy.ONLY_CHECK:
+        break;
+      case PermissionsIncludeStrategy.CHECK_AND_INCLUDE_ALL:
+        // clientPermissionsArray = await this.getAllClientPermissions(
+        //   userData,
+        //   abbr,
+        // );
+        break;
+      case PermissionsIncludeStrategy.CHECK_AND_INCLUDE_SELECTED:
+        if (!clientId) {
+          RESTError.throw('CLIENT_ID_REQUIRED', HttpStatus.FORBIDDEN);
+        }
+        // clientPermissionsArray = await this.getSelectedClientPermissions(
+        //   clientId,
+        //   userData,
+        //   abbr,
+        // );
+        break;
+    }
+
+    // this.setUserData(userData, clientPermissionsArray, request);
+
+    if (config.includeStrategy) {
+      if (!clientId) {
+        RESTError.throw('CLIENT_ID_REQUIRED', HttpStatus.FORBIDDEN);
+      }
+      if (!clientPermissionsArray || clientPermissionsArray.length <= 0) {
+        // clientPermissionsArray = await this.getSelectedClientPermissions(
+        //   clientId,
+        //   userData,
+        //   abbr,
+        // );
+      }
+      const selectedPermissions = clientPermissionsArray.find(
+        (clientPermissions) => clientPermissions.clientId === clientId,
+      );
+      return this.checkPerrmission(
+        ((selectedPermissions || {}).permissions || []),
+        config.keyword,
+      );
+    } else {
+      return true;
+    }
+  }
+
+  private getTokenFromHeaders(headers: any) {
+    let token = headers.authorization;
+    if (token) {
+      token = token.replace('bearer ', '');
+      token = token.replace('Bearer ', '');
+    }
+    return token;
+  }
+
+  private getClientIdFromQuery(queryParameters: any) {
+    return +queryParameters.clientId;
+  }
+
+  private getPermissionAbbr(inputString: string): string {
+    const parts: string[] = inputString.split('.');
+    if (parts.length > 1) {
+      return parts[0];
+    } else {
+      return inputString;
+    }
+  }
+
+  private checkPerrmission(
+    userPermissions: string[],
+    allowedPermission: string,
+  ): boolean {
+    return !allowedPermission || userPermissions.includes(allowedPermission);
+  }
+
+  // private async getAllClientPermissions(
+  //   userData: ISessionUserData,
+  //   abbr: string,
+  // ) {
+  //   const clients = await this.sessionService.getUserClientsById(userData.id);
+  //   let permissionPromises: {
+  //     clientId: number;
+  //     promise: Promise<string[]>;
+  //   }[] = [];
+  //   clients.forEach((client) => {
+  //     const permissions = this.sessionService.getUserPermissions(
+  //       userData.id,
+  //       client,
+  //       abbr,
+  //     );
+  //     permissionPromises.push({ clientId: client, promise: permissions });
+  //   });
+  //   const results = await Promise.all(
+  //     permissionPromises.map(({ promise }) => promise),
+  //   );
+
+  //   const combinedResults = permissionPromises.map(({ clientId }, index) => ({
+  //     clientId,
+  //     permissions: results[index],
+  //   }));
+  //   return combinedResults;
+  // }
+
+  // private async getSelectedClientPermissions(
+  //   clientId: number,
+  //   userData: ISessionUserData,
+  //   abbr: string,
+  // ) {
+  //   const userPermissions = await this.sessionService.getUserPermissions(
+  //     userData.id,
+  //     clientId,
+  //     abbr,
+  //   );
+  //   return [{ clientId, permissions: userPermissions }];
+  // }
+
+  private setUserData(
+    userData: ISessionUserData,
+    clientPermissions: ClientPermissions[],
+    request: Request,
+  ) {
+    const userInfo = {
+      ...userData,
+      clientPermissions,
+    };
+    request['user'] = userInfo;
+  }
+}

package/src/modules/cache/reflector/permission.reflector.ts

@@ -0,0 +1,4 @@
+import { Reflector } from '@nestjs/core';
+import { PermissionGuardConfig } from '../../../models/wrappers/permission-guard-config.wrapper';
+
+export const Permission = Reflector.createDecorator<PermissionGuardConfig>();

package/src/modules/cache/services/redis.service.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as IORedis from 'ioredis';
+
+@Injectable()
+export class RedisService {
+  private client: IORedis.Redis;
+
+  constructor(private configService: ConfigService) {
+    const redisConnectionString = this.configService.get(
+      'REDIS__CONNECTION_STRING',
+    );
+    this.client = new IORedis.Redis(redisConnectionString);
+  }
+
+  async set(key: string, value: string, ttl?: number): Promise<string> {
+    let result: string | PromiseLike<string>;
+    if (ttl) {
+      result = await this.client.set(key, value, 'EX', ttl);
+    } else {
+      result = await this.client.set(key, value);
+    }
+    return result;
+  }
+
+  async get(key: string): Promise<string> {
+    return await this.client.get(key);
+  }
+
+  async del(key: string): Promise<number> {
+    return await this.client.del(key);
+  }
+
+  getRedisClient() {
+    return this.client;
+  }
+}

package/src/modules/cache/services/session.service.ts

@@ -0,0 +1,11 @@
+import { Injectable } from '@nestjs/common';
+import { RedisService } from './redis.service';
+import { SessionClient } from '../../../clients/session.client';
+
+@Injectable()
+export class SessionService {
+  private sessionClient: SessionClient;
+  constructor(private redisService: RedisService) {
+    this.sessionClient = new SessionClient(this.redisService.getRedisClient());
+  }
+}