eh-commons 0.0.1-testing.99 → 0.0.2-testing.79

package/src/modules/core/index.ts

@@ -0,0 +1,6 @@
+export * from './models/interfaces';
+export * from './models/schemas';
+export * from './instances/app-logger.instance';
+export * from './services/app-logger.service';
+export * from './models/enums/feed-type.enum';
+export * from './core.module';

package/src/modules/core/models/enums/feed-type.enum.ts

@@ -0,0 +1,6 @@
+export enum FeedType {
+  EducationalContent = 'educational-content',
+  News = 'news',
+  Training = 'training',
+  Forum = 'forum',
+}

package/src/modules/core/models/interfaces/feed-thin.interface.ts

@@ -0,0 +1,10 @@
+import { I18n } from '../../../../models/util/embedded/i18n.embedded';
+import { IRef } from './ref.interface';
+import { IScope } from './scope.interface';
+
+export interface IFeedThin {
+  ref: IRef;
+  textNormal?: I18n;
+  textStylized?: I18n;
+  scope: IScope;
+}

package/src/modules/core/models/interfaces/index.ts

@@ -0,0 +1,4 @@
+export * from './range.interface';
+export * from './scope.interface';
+export * from './ref.interface';
+export * from './feed-thin.interface';

package/src/modules/core/models/interfaces/range.interface.ts

@@ -0,0 +1,4 @@
+export interface IRangeINT {
+    min?: number;
+    max?: number;
+}

package/src/modules/core/models/interfaces/ref.interface.ts

@@ -0,0 +1,7 @@
+import { Types } from 'mongoose';
+import { FeedType } from '../enums/feed-type.enum';
+
+export interface IRef {
+  id: Types.ObjectId | string;
+  type: FeedType;
+}

package/src/modules/core/models/interfaces/scope.interface.ts

@@ -0,0 +1,15 @@
+import { IDictionaryEmbedded } from "../../../dictionary";
+import { IRangeINT } from "./range.interface";
+
+export interface IScope {
+  ageRange: IRangeINT;
+  genders: number[];
+  districts: IDictionaryEmbedded[];
+  teacherLevels: IDictionaryEmbedded[];
+  schoolTypes: IDictionaryEmbedded[];
+  languageSectors: IDictionaryEmbedded[];
+  subjects: IDictionaryEmbedded[];
+  levels: IDictionaryEmbedded[];
+  highland: boolean;
+  tags: IDictionaryEmbedded[];
+}

package/src/modules/core/models/schemas/index.ts

@@ -0,0 +1,2 @@
+export * from './range.embedded';
+export * from './scope.embedded';

package/src/modules/core/models/schemas/range.embedded.ts

@@ -0,0 +1,13 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { IRangeINT } from '../interfaces';
+
+@Schema({ _id: false })
+export class RangeINT implements IRangeINT {
+  @Prop({ type: Number, required: false })
+  min: number;
+
+  @Prop({ type: Number, required: false })
+  max: number;
+}
+
+export const RangeINTSchema = SchemaFactory.createForClass(RangeINT);

package/src/modules/core/models/schemas/scope.embedded.ts

@@ -0,0 +1,41 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { RangeINTSchema } from './range.embedded';
+import { IRangeINT, IScope } from '../interfaces';
+import { DictionaryEmbedded, DictionaryEmbeddedSchema } from '../../../dictionary';
+
+@Schema({ _id: false })
+export class Scope implements IScope {
+  @Prop({ type: RangeINTSchema, required: false, default: null })
+  ageRange: IRangeINT;
+
+  @Prop({ type: [Number], required: false, default: [] })
+  genders: number[];
+
+  @Prop({ type: [DictionaryEmbeddedSchema], required: false, default: [] })
+  districts: DictionaryEmbedded[];
+
+  @Prop({ type: [DictionaryEmbeddedSchema], required: false, default: [] })
+  teacherLevels: DictionaryEmbedded[];
+
+  @Prop({ type: [DictionaryEmbeddedSchema], required: false, default: [] })
+  schoolTypes: DictionaryEmbedded[];
+
+  @Prop({ type: [DictionaryEmbeddedSchema], required: false, default: [] })
+  languageSectors: DictionaryEmbedded[];
+
+  @Prop({ type: [DictionaryEmbeddedSchema], required: false, default: [] })
+  subjects: DictionaryEmbedded[];
+
+  @Prop({ type: [DictionaryEmbeddedSchema], required: false, default: [] })
+  levels: DictionaryEmbedded[];
+
+  @Prop({ type: Boolean, required: false, default: null })
+  highland: boolean;
+
+  @Prop({ type: [DictionaryEmbeddedSchema], required: false, default: [] })
+  tags: DictionaryEmbedded[];
+}
+
+export const ScopeSchema = SchemaFactory.createForClass(Scope);
+export type ScopeDocument = HydratedDocument<Scope>;

package/src/modules/dictionary/index.ts

@@ -0,0 +1,5 @@
+export * from './models/dtos/dictionary-list.dto';
+export * from './services/dictionary.service';
+export * from './models/interfaces';
+export * from './models/schemas';
+export * from './dictionary.module';

package/src/modules/dictionary/{dtos → models/dtos}/dictionary-list.dto.ts

@@ -1,13 +1,6 @@
 import { Transform } from 'class-transformer';
-import {
-  ArrayUnique,
-  IsBoolean,
-  IsEnum,
-  IsMongoId,
-  IsOptional,
-  IsString,
-} from 'class-validator';
-import { RecordState } from '../../../models/util/enums/record-state.enum';
+import { ArrayUnique, IsBoolean, IsEnum, IsMongoId, IsOptional, IsString } from 'class-validator';
+import { RecordState } from '../../../../models/util/enums/record-state.enum';
 
 const toStringArray = (value: string | string[]) => {
   return typeof value === 'string' ? [value] : value;
@@ -16,31 +9,31 @@ const toStringArray = (value: string | string[]) => {
 export class DictionaryListDTO {
   @IsOptional()
   @IsBoolean()
-  rootOnly: boolean;
+  rootOnly?: boolean;
 
   @IsOptional()
   @IsString()
-  keyword: string;
+  keyword?: string;
 
   @IsOptional()
   @IsString()
-  title: string;
+  title?: string;
 
   @IsOptional()
   @IsMongoId()
-  parentId: string;
+  parentId?: string;
 
   @IsOptional()
   @IsMongoId()
-  originId: string;
+  originId?: string;
 
   @IsOptional()
   @ArrayUnique()
   @IsEnum(RecordState, { each: true })
   @Transform(({ value }) => toStringArray(value))
-  recordStates: RecordState[];
+  recordStates?: RecordState[];
 
   @IsOptional()
   @IsMongoId({ each: true })
-  ids: string[];
+  ids?: string[];
 }

package/src/modules/dictionary/models/interfaces/index.ts

@@ -0,0 +1,31 @@
+import { IBase } from '../../../../models/commons/interfaces/base.interface';
+import { ResourceType } from '../../../../models/emis/enums/resource-type.enum';
+import { II18n } from '../../../../models/util/interfaces/i18n.interface';
+import { Types } from 'mongoose';
+
+export interface IDictionaryEvent {
+  event: 'create' | 'update' | 'delete';
+  data: IDictionary;
+}
+
+export interface IDictionarySetting {
+  allowedTypes: ResourceType[];
+}
+
+export interface IDictionary extends IBase {
+  keyword: string;
+  originIds: Types.ObjectId[] | string[];
+  parentIds: Types.ObjectId[] | string[] | IDictionary[];
+  title: II18n;
+  settings: IDictionarySetting;
+  metas: Map<string, string>;
+}
+
+export interface IDictionaryEmbedded {
+  id: Types.ObjectId | string;
+  keyword: string;
+  originIds: Types.ObjectId[] | string[];
+  parentIds: Types.ObjectId[] | string[] | IDictionaryEmbedded[];
+  title: II18n;
+  metas: Map<string, string>;
+}

package/src/{models/dictionary/embedded/dictionary.embedded.ts → modules/dictionary/models/schemas/index.ts}

@@ -1,19 +1,18 @@
 import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
-import { HydratedDocument, ObjectId, SchemaTypes } from 'mongoose';
-import { I18n, I18nSchema } from '../../util/embedded/i18n.embedded';
-import { IDictionaryEmbedded } from '../interfaces/dictionary-embedded.interface';
+import { HydratedDocument, SchemaTypes, Types } from 'mongoose';
+import { I18n, I18nSchema } from '../../../../models/util/embedded/i18n.embedded';
+import { IDictionaryEmbedded } from '../interfaces';
 
 @Schema({ _id: false })
 export class DictionaryEmbedded implements IDictionaryEmbedded {
+  @Prop({ type: SchemaTypes.ObjectId, required: false, default: null })
+  id: Types.ObjectId | string;
+
   @Prop({ type: [SchemaTypes.ObjectId], required: true, default: [] })
-  originIds: ObjectId[];
+  originIds: Types.ObjectId[] | string[];
 
-  @Prop({
-    type: [SchemaTypes.ObjectId],
-    ref: 'Dictionary',
-    default: [],
-  })
-  parentIds: ObjectId[] | IDictionaryEmbedded[];
+  @Prop({ type: [SchemaTypes.ObjectId], required: false, default: [] })
+  parentIds: Types.ObjectId[] | string[];
 
   @Prop({ type: I18nSchema, required: true })
   title: I18n;

package/src/modules/dictionary/services/dictionary.service.ts

@@ -1,135 +1,79 @@
-import { Injectable, OnModuleInit } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import { RESTError, RESTResponseBody } from '../../../models/wrappers/rest-wrapper.class';
-import { IDictionary } from '../../../models/dictionary/interfaces/dictionary.interface';
-import { ObjectId } from 'mongoose';
+import { IDictionary, IDictionaryEmbedded } from '../models/interfaces';
+import { ObjectId, Types } from 'mongoose';
 import * as qs from 'qs';
-import axios, { AxiosInstance } from 'axios';
-import { DictionaryListDTO } from '../dtos/dictionary-list.dto';
+import { DictionaryListDTO } from '../models/dtos/dictionary-list.dto';
 import { plainToInstance } from 'class-transformer';
 import { validateOrReject } from 'class-validator';
-
-const BASE_URL = 'EH_DICTIONARIES__REST__BASE_URL';
+import { RestClient } from '../../../clients';
 
 @Injectable()
-export class DictionaryService implements OnModuleInit {
-  private dctUrl: string;
-  private _instance: AxiosInstance;
-
-  constructor(private _configService: ConfigService) {
-    this._instance = axios.create({
-      baseURL: this._configService.get(BASE_URL),
-      timeout: 60000,
+export class DictionaryService {
+  //#region Private Members
+  private readonly _client: RestClient;
+  //#endregion
+
+  //#region Constructor
+  constructor(private readonly _configService: ConfigService) {
+    this._client = new RestClient({
+      name: 'DICTIONARY_SERVICE',
+      baseUrl: this._configService.get('EH_DICTIONARIES__REST__BASE_URL', ''),
+      timeout: 30000,
+      accessToken: this._configService.get('EH_DICTIONARIES__REST__ACCESS_TOKEN', ''),
     });
   }
+  //#endregion
 
-  validateRequest = () => {
-    if (!this.dctUrl) {
-      throw new Error(`${BASE_URL} is not defined in the configuration`);
-    }
-  };
-
-  onModuleInit() {
-    this.dctUrl = this._configService.get(BASE_URL);
+  //#region Public APIs
+  public async fetchActiveById(id: string | ObjectId) {
+    return this._client.get<IDictionary>(`/internals/v1/dictionaries/${id}`);
   }
 
-  /**
-   * Finds a dictionary by its ID.
-   * @param id - The ID of the dictionary to find.
-   * @returns The dictionary if found, or throws an error.
-   */
-  public async findById(id: string | ObjectId) {
-    this.validateRequest();
-
-    try {
-      const response = await this._instance.get<RESTResponseBody<IDictionary>>(`${this.dctUrl}/externals/v1/dictionaries/${id}`);
-      if (response.data.errors) {
-        if (response.data.errors.length === 0) {
-          throw new Error('UNKNOWN_ERROR');
-        }
-        throw new Error(response.data.errors[0].keyword);
-      }
-
-      return response.data.result.data;
-    } catch (error) {
-      if (error instanceof RESTError) {
-        throw new Error(`DICTIONARY__API_ERROR. keyword: ${error.keyword}. statusCode: ${error.statusCode}`);
-      }
-      throw new Error(`DICTIONARY__API_ERROR: ${error.message}`);
-    }
+  public async fetchActivesByIds(ids: string[] | ObjectId[]) {
+    const requestBody = { data: { ids } };
+    return this._client.post<IDictionary[]>(`/internals/v1/dictionaries/by-ids`, requestBody);
   }
 
-  /**
-   * Finds dictionaries by their IDs.
-   * @param ids - The IDs of the dictionaries to find.
-   * @param embedded - Whether to return embedded dictionaries.
-   * @returns The list of dictionaries if found, or throws an error.
-   */
-  public async findByIds(ids: string[] | ObjectId[], embedded: true) {
-    this.validateRequest();
-
-    const query = qs.stringify({
-      ids,
-    });
-
-    try {
-      const response = await this._instance.get<RESTResponseBody<IDictionary[]>>(`/externals/v1/dictionaries?${query}`);
+  public async fetchActiveByKeyword(keyword: string) {
+    return this._client.get<IDictionary>(`/internals/v1/dictionaries/by-keyword/${keyword}`);
+  }
 
-      if (response.data.errors) {
-        if (response.data.errors.length === 0) {
-          throw new Error('UNKNOWN_ERROR');
-        }
-        throw new Error(response.data.errors[0].keyword);
-      }
+  public async fetchActiveByOriginId(originId: string) {
+    return this._client.get<IDictionary>(`/internals/v1/dictionaries/by-origin/${originId}`);
+  }
 
-      if (embedded) {
-        return response.data.result.data;
-      }
-      return response.data.result.data;
-    } catch (error) {
-      if (error instanceof RESTError) {
-        throw new Error(`DICTIONARY__API_ERROR. keyword: ${error.keyword}. statusCode: ${error.statusCode}`);
-      }
-      if (error.data && error.data.errors) {
-        throw new Error(`DICTIONARY__API_ERROR. keyword: ${error.data.errors[0].keyword}. statusCode: ${error.statusCode}`);
-      }
-      throw new Error(`DICTIONARY__API_ERROR: ${error.message}`);
-    }
+  public async fetchList(filters: DictionaryListDTO) {
+    const query = qs.stringify(filters);
+    await this._validateListDTO(filters);
+    return this._client.get<IDictionary[]>(`/internals/v1/dictionaries?${query}`);
   }
 
-  /**
-   * Lists dictionaries based on filters.
-   * @param filters - The filters to apply to the dictionary list.
-   * @param embedded - Whether to return embedded dictionaries.
-   * @returns The list of dictionaries matching the filters, or throws an error.
-   */
-  public async list(filters: DictionaryListDTO, embedded: true) {
-    this.validateRequest();
+  public toEmbedded(dictionary: IDictionary): IDictionaryEmbedded {
+    return {
+      id: dictionary._id,
+      originIds: dictionary.originIds,
+      parentIds: this._extractParentIds(dictionary.parentIds),
+      title: dictionary.title,
+      metas: dictionary.metas,
+      keyword: dictionary.keyword,
+    };
+  }
+  //#endregion
 
+  //#region Private APIs
+  private async _validateListDTO(filters: DictionaryListDTO) {
     const filtersInstance = plainToInstance(DictionaryListDTO, filters);
     await validateOrReject(filtersInstance);
+  }
 
-    const query = qs.stringify(filters);
-
-    try {
-      const response = await this._instance.get<RESTResponseBody<IDictionary[]>>(`/externals/v1/dictionaries?${query}`);
-
-      if (response.data.errors) {
-        if (response.data.errors.length === 0) {
-          throw new Error('UNKNOWN_ERROR');
-        }
-        throw new Error(response.data.errors[0].keyword);
-      }
-
-      return response.data.result.data;
-    } catch (error) {
-      if (error instanceof RESTError) {
-        throw new Error(`DICTIONARY__API_ERROR. keyword: ${error.keyword}. statusCode: ${error.statusCode}`);
-      }
-      if (error.data && error.data.errors) {
-        throw new Error(`DICTIONARY__API_ERROR. keyword: ${error.data.errors[0].keyword}. statusCode: ${error.statusCode}`);
-      }
-      throw new Error(`DICTIONARY__API_ERROR: ${error.message}`);
-    }
+  private _extractParentIds(parentIds: Types.ObjectId[] | string[] | IDictionary[]): string[] {
+    if (!parentIds || !parentIds.length) return [];
+    return parentIds.map((item: Types.ObjectId | string | IDictionary) => {
+      if (typeof item === 'string') return item;
+      if (item instanceof Types.ObjectId) return item.toString();
+      return (item as IDictionary)._id.toString();
+    });
   }
+  //#endregion
 }

package/src/modules/dmm/dmm.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { DMMService } from './services/dmm.service';
+import { DeadMessage, DeadMessageSchema } from './models/schemas';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: DeadMessage.name, schema: DeadMessageSchema }]),
+  ],
+  providers: [DMMService],
+  exports: [DMMService],
+})
+export class DMMModule {}

package/src/modules/dmm/index.ts

@@ -0,0 +1,4 @@
+export * from './services/dmm.service';
+export * from './models/interfaces';
+export * from './models/schemas';
+export * from './dmm.module';

package/src/modules/dmm/models/interfaces/index.ts

@@ -0,0 +1,13 @@
+import { Types } from 'mongoose';
+
+export interface IDeadMessage {
+  _id?: Types.ObjectId | string;
+  topic: string;
+  key?: string;
+  headers?: Map<string, string>;
+  message?: string;
+  ex?: string;
+  resolved: boolean;
+  createdAt: Date;
+  resolvedAt?: Date;
+}

package/src/modules/dmm/models/schemas/index.ts

@@ -0,0 +1,36 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument, SchemaTypes, Types } from 'mongoose';
+import { IDeadMessage } from '../interfaces';
+
+@Schema({ collection: 'dead-messages' })
+export class DeadMessage implements IDeadMessage {
+  @Prop({ type: SchemaTypes.ObjectId, required: false, default: null })
+  _id: Types.ObjectId | string;
+
+  @Prop({ type: String, required: true, default: null })
+  topic: string;
+
+  @Prop({ type: String, required: false, default: null })
+  key: string;
+
+  @Prop({ type: Map, of: String, default: new Map() })
+  headers: Map<string, string>;
+
+  @Prop({ type: String, required: false, default: null })
+  message: string;
+
+  @Prop({ type: String, required: false, default: null })
+  ex?: string;
+
+  @Prop({ type: Boolean, required: false, default: null })
+  resolved: boolean;
+
+  @Prop({ type: Date, required: true, default: null })
+  createdAt: Date;
+
+  @Prop({ type: Date, required: false, default: null })
+  resolvedAt: Date;
+}
+
+export const DeadMessageSchema = SchemaFactory.createForClass(DeadMessage);
+export type DeadMessageDocument = HydratedDocument<DeadMessage>;

package/src/modules/dmm/services/dmm.service.ts

@@ -0,0 +1,33 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, Types } from 'mongoose';
+import { DeadMessage, DeadMessageDocument } from '../models/schemas';
+import { IDeadMessage } from '../models/interfaces';
+
+@Injectable()
+export class DMMService {
+  //#region Constructor
+  constructor(
+    @InjectModel(DeadMessage.name)
+    private readonly _deadMessageModel: Model<DeadMessageDocument>,
+  ) {}
+  //#endregion
+
+  //#region Public APIs
+  public async create(message: IDeadMessage) {
+    return new this._deadMessageModel({
+      ...message,
+      resolved: false,
+      createdAt: new Date(),
+    }).save();
+  }
+
+  public async resolve(id: string | Types.ObjectId) {
+    return this._deadMessageModel.findByIdAndUpdate(id, { $set: { resolved: true, resolvedAt: new Date() } }, { new: true });
+  }
+
+  public async deleteResolveds() {
+    return this._deadMessageModel.deleteMany({ resolved: true });
+  }
+  //#endregion
+}

package/src/modules/emis/emis.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { EMISService } from './services/emis.service';
+
+@Module({
+  imports: [ConfigModule],
+  controllers: [],
+  providers: [EMISService],
+  exports: [EMISService],
+})
+export class EMISModule {}

package/src/modules/emis/index.ts

@@ -0,0 +1,3 @@
+export * from './models/interfaces/emis.interface';
+export * from './services/emis.service';
+export * from './emis.module';

package/src/modules/emis/models/interfaces/emis.interface.ts

@@ -0,0 +1,37 @@
+import { Types } from 'mongoose';
+
+export interface IResourceItem {
+  _id: string | Types.ObjectId;
+  name: string;
+}
+
+export interface ISchoolProjection {
+  _id: string | Types.ObjectId;
+  code: number;
+  name: {
+    ge: string;
+    en: string;
+  };
+  region: IResourceItem;
+  district: IResourceItem;
+  type: IResourceItem;
+  languageSectors: IResourceItem[];
+  levels: IResourceItem[];
+  subjects: IResourceItem[];
+  phone?: string;
+  email?: string;
+  highland: boolean;
+}
+
+export interface ITeacherProjection {
+  pid: string;
+  firstName: string;
+  lastName: string;
+  level: IResourceItem;
+  birthDate?: Date;
+  gender?: number;
+  phone?: string;
+  email?: string;
+  address?: string;
+  schools: ISchoolProjection[];
+}

package/src/modules/emis/services/emis.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { RestClient } from '../../../clients';
+import { ITeacherProjection } from '../models/interfaces/emis.interface';
+import * as qs from 'qs';
+
+@Injectable()
+export class EMISService {
+  //#region Private Members
+  private readonly _client: RestClient;
+  //#endregion
+
+  //#region Constructor
+  constructor(private _configService: ConfigService) {
+    this._client = new RestClient({
+      name: 'EMIS_SERVICE',
+      baseUrl: this._configService.get('EH_EMIS__REST__BASE_URL', ''),
+      timeout: 30000,
+      accessToken: this._configService.get('EH_EMIS__REST__ACCESS_TOKEN', ''),
+    });
+  }
+  //#endregion
+
+  //#region Public APIs
+  public async fetchTeacher(email: string, pid: string) {
+    const query = qs.stringify({ email, pid });
+    return await this._client.get<ITeacherProjection>(`/internals/v1/resources/emis/fetch-teachers?${query}`);
+  }
+  //#endregion
+}

package/src/modules/iam/iam.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { IAMService } from './services/iam.service';
+
+@Module({
+  imports: [ConfigModule],
+  controllers: [],
+  providers: [IAMService],
+  exports: [IAMService],
+})
+export class IAMModule {}

package/src/modules/iam/index.ts

@@ -0,0 +1,5 @@
+export * from './services/iam.service';
+export * from './models/interfaces';
+export * from './models/enums';
+export * from './models/schemas';
+export * from './iam.module';

package/src/modules/iam/models/enums/index.ts

@@ -0,0 +1,6 @@
+export enum ClientType {
+  ADMIN = 'admin',
+  PUBLIC_SCHOOL = 'public-school',
+  PRIVATE_SCHOOL = 'private-school',
+  PROVIDER = 'provider',
+}