init

.eslintrc.js

@@ -0,0 +1,24 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+  ],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  ignorePatterns: ['.eslintrc.js'],
+  rules: {
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+  },
+};

.gitignore

@@ -0,0 +1,35 @@
+# compiled output
+/dist
+/node_modules
+
+# Logs
+logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# OS
+.DS_Store
+
+# Tests
+/coverage
+/.nyc_output
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json

.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

README.md

@@ -0,0 +1,73 @@
+<p align="center">
+  <a href="http://nestjs.com/" target="blank"><img src="https://nestjs.com/img/logo_text.svg" width="320" alt="Nest Logo" /></a>
+</p>
+
+[circleci-image]: https://img.shields.io/circleci/build/github/nestjs/nest/master?token=abc123def456
+[circleci-url]: https://circleci.com/gh/nestjs/nest
+
+  <p align="center">A progressive <a href="http://nodejs.org" target="_blank">Node.js</a> framework for building efficient and scalable server-side applications.</p>
+    <p align="center">
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/v/@nestjs/core.svg" alt="NPM Version" /></a>
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/l/@nestjs/core.svg" alt="Package License" /></a>
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/dm/@nestjs/common.svg" alt="NPM Downloads" /></a>
+<a href="https://circleci.com/gh/nestjs/nest" target="_blank"><img src="https://img.shields.io/circleci/build/github/nestjs/nest/master" alt="CircleCI" /></a>
+<a href="https://coveralls.io/github/nestjs/nest?branch=master" target="_blank"><img src="https://coveralls.io/repos/github/nestjs/nest/badge.svg?branch=master#9" alt="Coverage" /></a>
+<a href="https://discord.gg/G7Qnnhy" target="_blank"><img src="https://img.shields.io/badge/discord-online-brightgreen.svg" alt="Discord"/></a>
+<a href="https://opencollective.com/nest#backer" target="_blank"><img src="https://opencollective.com/nest/backers/badge.svg" alt="Backers on Open Collective" /></a>
+<a href="https://opencollective.com/nest#sponsor" target="_blank"><img src="https://opencollective.com/nest/sponsors/badge.svg" alt="Sponsors on Open Collective" /></a>
+  <a href="https://paypal.me/kamilmysliwiec" target="_blank"><img src="https://img.shields.io/badge/Donate-PayPal-ff3f59.svg"/></a>
+    <a href="https://opencollective.com/nest#sponsor"  target="_blank"><img src="https://img.shields.io/badge/Support%20us-Open%20Collective-41B883.svg" alt="Support us"></a>
+  <a href="https://twitter.com/nestframework" target="_blank"><img src="https://img.shields.io/twitter/follow/nestframework.svg?style=social&label=Follow"></a>
+</p>
+  <!--[![Backers on Open Collective](https://opencollective.com/nest/backers/badge.svg)](https://opencollective.com/nest#backer)
+  [![Sponsors on Open Collective](https://opencollective.com/nest/sponsors/badge.svg)](https://opencollective.com/nest#sponsor)-->
+
+## Description
+
+[Nest](https://github.com/nestjs/nest) framework TypeScript starter repository.
+
+## Installation
+
+```bash
+$ npm install
+```
+
+## Running the app
+
+```bash
+# development
+$ npm run start
+
+# watch mode
+$ npm run start:dev
+
+# production mode
+$ npm run start:prod
+```
+
+## Test
+
+```bash
+# unit tests
+$ npm run test
+
+# e2e tests
+$ npm run test:e2e
+
+# test coverage
+$ npm run test:cov
+```
+
+## Support
+
+Nest is an MIT-licensed open source project. It can grow thanks to the sponsors and support by the amazing backers. If you'd like to join them, please [read more here](https://docs.nestjs.com/support).
+
+## Stay in touch
+
+- Author - [Kamil Myśliwiec](https://kamilmysliwiec.com)
+- Website - [https://nestjs.com](https://nestjs.com/)
+- Twitter - [@nestframework](https://twitter.com/nestframework)
+
+## License
+
+Nest is [MIT licensed](LICENSE).

libs/event-emitter/src/app.controller.spec.ts

@@ -0,0 +1,22 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+describe('AppController', () => {
+  let appController: AppController;
+
+  beforeEach(async () => {
+    const app: TestingModule = await Test.createTestingModule({
+      controllers: [AppController],
+      providers: [AppService],
+    }).compile();
+
+    appController = app.get<AppController>(AppController);
+  });
+
+  describe('root', () => {
+    it('should return "Hello World!"', () => {
+      expect(appController.getHello()).toBe('Hello World!');
+    });
+  });
+});

libs/event-emitter/src/app.controller.ts

@@ -0,0 +1,16 @@
+import { Body, Controller, Post } from "@nestjs/common";
+import { AppService } from './app.service';
+import { RedmineEventsGateway } from "./events/redmine-events.gateway";
+
+@Controller()
+export class AppController {
+  constructor(
+    private readonly appService: AppService,
+    private readonly redmineEventsGateway: RedmineEventsGateway
+  ) {}
+
+  @Post("append-issues")
+  async appendIssues(@Body() issues: number[]): Promise<void> {
+    this.redmineEventsGateway.addIssues(issues)
+  }
+}

libs/event-emitter/src/app.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+import { RedmineEventsGateway } from './events/redmine-events.gateway';
+import { ServeStaticModule } from '@nestjs/serve-static';
+import { join } from 'path';
+import MainConfig from './configs/main-config';
+import { ConfigModule } from '@nestjs/config';
+import { RedmineDataLoader } from './redmine-data-loader/redmine-data-loader';
+
+@Module({
+  imports: [
+    ServeStaticModule.forRoot({rootPath: join(__dirname, '..', 'client')}),
+    ConfigModule.forRoot({load: [MainConfig]})
+  ],
+  controllers: [AppController],
+  providers: [AppService, RedmineEventsGateway, RedmineDataLoader],
+})
+export class AppModule {}

libs/event-emitter/src/app.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}

libs/event-emitter/src/configs/main-config.ts

@@ -0,0 +1,10 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { parse } from 'jsonc-parser';
+import { MainConfigModel } from "../models/main-config-model";
+
+export default (): MainConfigModel => {
+  const rawData = readFileSync(join(__dirname, '..', '..', 'configs', 'main-config.jsonc'), {encoding: "utf-8"});
+  const data: MainConfigModel = parse(rawData);
+  return data;
+};

libs/event-emitter/src/event-emitter.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { EventEmitterService } from './event-emitter.service';
+import { RedmineEventsGateway } from './events/redmine-events.gateway';
+import { ServeStaticModule } from '@nestjs/serve-static';
+import { join } from 'path';
+import MainConfig from './configs/main-config';
+import { ConfigModule } from '@nestjs/config';
+import { RedmineDataLoader } from './redmine-data-loader/redmine-data-loader';
+
+@Module({
+  imports: [
+    ServeStaticModule.forRoot({rootPath: join(__dirname, '..', 'client')}),
+    ConfigModule.forRoot({load: [MainConfig]})
+  ],
+  providers: [EventEmitterService, RedmineEventsGateway, RedmineDataLoader],
+  exports: [EventEmitterService, RedmineEventsGateway, RedmineDataLoader],
+})
+export class EventEmitterModule {}

libs/event-emitter/src/event-emitter.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { EventEmitterService } from './event-emitter.service';
+
+describe('EventEmitterService', () => {
+  let service: EventEmitterService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [EventEmitterService],
+    }).compile();
+
+    service = module.get<EventEmitterService>(EventEmitterService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

libs/event-emitter/src/event-emitter.service.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class EventEmitterService {}

libs/event-emitter/src/events/events-listener.ts

@@ -0,0 +1,7 @@
+import { BehaviorSubject } from "rxjs";
+
+export interface EventsListener {
+  issues: BehaviorSubject<number[]>;
+  start(): void;
+  stop(): void;
+}

libs/event-emitter/src/events/redmine-events.gateway.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { RedmineEventsGateway } from './redmine-events.gateway';
+
+describe('RedmineEventsGateway', () => {
+  let gateway: RedmineEventsGateway;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [RedmineEventsGateway],
+    }).compile();
+
+    gateway = module.get<RedmineEventsGateway>(RedmineEventsGateway);
+  });
+
+  it('should be defined', () => {
+    expect(gateway).toBeDefined();
+  });
+});

libs/event-emitter/src/events/redmine-events.gateway.ts

@@ -0,0 +1,160 @@
+import { MessageBody, SubscribeMessage, WebSocketGateway, WebSocketServer, WsResponse } from "@nestjs/websockets";
+import { Server } from "socket.io";
+import { Observable } from "rxjs";
+import { map } from "rxjs/operators";
+import { MailListener } from "../maillistener/maillistener";
+import { Queue } from "../queue/queue";
+import { RedmineDataLoader } from "../redmine-data-loader/redmine-data-loader";
+import { RedmineIssueData } from "../models/RedmineIssueData";
+import { ConfigService } from "@nestjs/config";
+import axios from "axios";
+import { WebhookConfigItemModel } from "../models/webhook-config-item-model";
+import { RssListener } from "../rsslistener/rsslistener";
+import { EventsListener } from "./events-listener";
+
+type IssuesChangesQueueParams = {
+  updateInterval: number,
+  itemsLimit: number
+}
+
+@WebSocketGateway({namespace: 'redmine-events'})
+export class RedmineEventsGateway {
+  @WebSocketServer()
+  server: Server;
+
+  issuesChangesObservable: Observable<WsResponse<RedmineIssueData[]>>;
+
+  private issueNumberParser: RegExp;
+  private issuesChangesQueueParams: IssuesChangesQueueParams
+
+  constructor(
+    private config: ConfigService,
+    private redmineDataLoader: RedmineDataLoader
+  ) {
+    this.issuesChangesQueueParams = this.config.get<IssuesChangesQueueParams>("issueChangesQueue")
+    this.initRedmineEventsGateway();
+  }
+
+  @SubscribeMessage('issues-changes')
+  issuesChanges(@MessageBody() data: any): Observable<WsResponse<RedmineIssueData[]>> {
+    return this.issuesChangesObservable;
+  }
+
+  private issuesChangesQueue: Queue<number, RedmineIssueData>;
+  getIssuesChangesQueue(): Queue<number, RedmineIssueData> {
+    if (!this.issuesChangesQueue) {
+      this.issuesChangesQueue = new Queue<number, RedmineIssueData>(
+        this.issuesChangesQueueParams.updateInterval,
+        this.issuesChangesQueueParams.itemsLimit,
+        async (issueNumbers) => {
+          let res;
+          try {
+            res = await this.redmineDataLoader.loadIssues(issueNumbers);
+          } catch (e) {
+            console.error('Error load issues:', e, 'for issues:', issueNumbers);
+            return [];
+          }
+          return res;
+        }
+      );
+      this.issuesChangesQueue.start();
+    }
+    return this.issuesChangesQueue;
+  }
+
+  addIssues(issues: number[]): void {
+    issues.forEach(issue => {
+      if (!this.issuesChangesQueue.isItemExists(issue)) {
+        this.issuesChangesQueue.add([issue]);
+      }
+    });
+  }
+
+  private sendWebHookFullDataEvents(data: RedmineIssueData[]): void {
+    const webhooks = this.config.get<WebhookConfigItemModel[]>("webhooks");
+    webhooks.forEach(webhook => {
+      let config = undefined;
+      if (webhook.apiKeyName && webhook.apiKeyValue) {
+        config = {headers: {}};
+        config.headers[webhook.apiKeyName] = webhook.apiKeyValue;
+      }
+      axios.post(webhook.url, data, config).catch((err) => {
+        console.error('Error at webhook send request:', err)
+      });
+    });
+  }
+
+  private mailListener: MailListener|null|undefined;
+  private getMailListener(): MailListener|null {
+    if (typeof this.mailListener === 'undefined') {
+      const mailListenerParams = this.config.get<any>('mailListener');
+      if (mailListenerParams) {
+        this.mailListener = new MailListener(mailListenerParams);
+      } else {
+        this.mailListener = null;
+      }
+    }
+    return this.mailListener;
+  }
+
+  private rssListener: RssListener|null|undefined;
+  private getRssListener(): RssListener|null {
+    if (typeof this.rssListener === 'undefined') {
+      const rssListenerParams = this.config.get<any>('rssListener');
+      if (rssListenerParams) {
+        this.rssListener = new RssListener(rssListenerParams);
+      } else {
+        this.rssListener = null;
+      }
+    }
+    return this.rssListener;
+  }
+
+  private listener: EventsListener|null|undefined;
+  private getMainListener(): EventsListener|null {
+    if (typeof this.listener !== 'undefined') {
+      return this.listener;
+    }
+
+    const mailListener = this.getMailListener();
+    const rssListener = this.getRssListener();
+    if (mailListener) {
+      this.listener = mailListener;
+    } else if (rssListener) {
+      this.listener = rssListener;
+    } else {
+      this.listener = null;
+    }
+    if (this.listener) {
+      this.listener.start();
+    }
+    return this.listener;
+  }
+
+  private initWebSocketsSendData(): void {
+    const queue: Queue<number, RedmineIssueData> = this.getIssuesChangesQueue();
+    this.issuesChangesObservable = queue.queue.pipe(map(data => {
+      return {event: 'issues-changes', data: data}
+    }));
+  }
+
+  private initWebHooksSendData(): void {
+    const queue: Queue<number, RedmineIssueData> = this.getIssuesChangesQueue();
+    queue.queue.subscribe(data => this.sendWebHookFullDataEvents(data));
+  }
+
+  private initRedmineEventsGateway(): boolean {
+    const listener = this.getMainListener();
+    if (!listener) {
+      console.error('Listener not created');
+      return false;
+    }
+    const issuesChangesQueue = this.getIssuesChangesQueue();
+    listener.issues.subscribe(issues => {
+      issuesChangesQueue.add(issues);
+    });
+    this.initWebSocketsSendData();
+    this.initWebHooksSendData();
+    return true;
+  }
+}

libs/event-emitter/src/index.ts

@@ -0,0 +1,2 @@
+export * from './event-emitter.module';
+export * from './event-emitter.service';

libs/event-emitter/src/maillistener/maillistener-params.ts

@@ -0,0 +1,8 @@
+import { RssListenerParams } from "../rsslistener/rsslistener-params";
+
+export type MailListenerParams = {
+  issueNumberParser: string;
+  imapSimpleConfig: Record<string, any>;
+  updateInterval: number;
+  boxName: string;
+}

libs/event-emitter/src/maillistener/maillistener.ts

@@ -0,0 +1,109 @@
+import { BehaviorSubject } from "rxjs";
+import * as ImapSimple from "imap-simple";
+import { Injectable } from "@nestjs/common";
+import { MailListenerParams } from "./maillistener-params";
+import { CreateSubjectsParserByRegExp } from "../subjects-parser/subjects-parser";
+import { EventsListener } from "../events/events-listener";
+import {Message} from "imap-simple";
+
+const UPDATE_INTERVAL_AFTER_ERROR = 5 * 60 * 1000;
+
+@Injectable()
+export class MailListener implements EventsListener {
+
+  issues = new BehaviorSubject<number[]>([])
+
+  private updateTimeout;
+
+  constructor(private config: MailListenerParams | null = null) {}
+
+  start(): void {
+    this.updateMessages();
+  }
+
+  stop(): void {
+    clearTimeout(this.updateTimeout);
+    this.updateTimeout = null;
+  }
+
+  private async updateMessages(): Promise<void> {
+    if (!this.config) {
+      console.error('Mail listener config not defined');
+      return;
+    }
+
+    let connection: ImapSimple.ImapSimple;
+    try {
+      connection = await this.getConnection();
+    } catch (ex) {
+      console.error('Mail listener error on getConnection:', ex);
+      this.closeConnection();
+      this.repeatUpdate(UPDATE_INTERVAL_AFTER_ERROR);
+      return;
+    }
+
+    const searchCriteria = [
+      'UNSEEN'
+    ];
+    const fetchOptions = {
+      bodies: ['HEADER', 'TEXT'],
+      markSeen: true
+    };
+    // const boxes = await connection.getBoxes();
+
+    let messages: Message[];
+
+    try {
+      await connection.openBox(this.config.boxName)
+      messages = await connection.search(searchCriteria, fetchOptions)
+    } catch (ex) {
+      console.error('Mail listener error on openBox and search:', ex);
+      this.closeConnection();
+      this.repeatUpdate(UPDATE_INTERVAL_AFTER_ERROR);
+      return;
+    }
+
+    const subjects: string[] = messages.map(message => {
+      return message.parts.filter(function (part) {
+        return part.which === 'HEADER';
+      })[0].body.subject[0]
+    });
+    const regexp = new RegExp(this.config.issueNumberParser);
+    const subjectParser = CreateSubjectsParserByRegExp(regexp);
+    const numbers: number[] = subjects.map(subject => {
+      return subjectParser.getIssueNumber(subject);
+    });
+    this.issues.next(numbers);
+
+    this.repeatUpdate(this.config.updateInterval);
+  }
+
+  private connection: ImapSimple.ImapSimple;
+  async getConnection(): Promise<ImapSimple.ImapSimple> {
+    if (!this.connection) {
+      this.connection = await ImapSimple.connect(this.config.imapSimpleConfig as any);
+    }
+    return this.connection;
+  }
+
+  private repeatUpdate(interval: number): void {
+    this.updateTimeout = setTimeout(() => {
+      this.updateMessages().catch(reason => {
+        console.error('Mail listener unknown error:', reason);
+      });
+    }, interval);
+  }
+
+  private closeConnection(): void {
+    if (!this.connection) return;
+    try {
+      this.connection.closeBox(false);
+    } catch (e) {
+      console.error('Mail listener error at closeBox:', e);
+    }
+    this.connection = null;
+  }
+
+  // TODO: 2021-05-08 Добавить функцию получения списка папок на сервере
+
+}

libs/event-emitter/src/main.ts

@@ -0,0 +1,10 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = "0";
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(process.env['PORT'] || 3000);
+}
+bootstrap();

libs/event-emitter/src/models/RedmineIssueData.ts

@@ -0,0 +1 @@
+export type RedmineIssueData = any;

libs/event-emitter/src/models/main-config-model.ts

@@ -0,0 +1,14 @@
+import { WebhookConfigItemModel } from "./webhook-config-item-model";
+import { RssListenerParams } from "../rsslistener/rsslistener-params";
+import { MailListenerParams } from "../maillistener/maillistener-params";
+
+export type MainConfigModel = {
+  issueChangesQueue: {
+    updateInterval: number,
+    itemsLimit: number
+  },
+  mailListener: MailListenerParams | null,
+  rssListener: RssListenerParams | null,
+  redmineUrlPrefix: string,
+  webhooks: WebhookConfigItemModel[]
+}

libs/event-emitter/src/models/webhook-config-item-model.ts

@@ -0,0 +1,5 @@
+export type WebhookConfigItemModel = {
+  url: string,
+  apiKeyName: string,
+  apiKeyValue: string
+}

libs/event-emitter/src/queue/queue.ts

@@ -0,0 +1,45 @@
+import { Subject } from "rxjs";
+
+export class Queue<T, NT> {
+
+  private items: T[] = [];
+
+  queue: Subject<NT[]> = new Subject<NT[]>();
+
+  constructor(
+    private updateInterval: number,
+    private itemsLimit: number,
+    private transformationFn: ((arg: Array<T>) => Promise<Array<NT>>)
+  ) {}
+
+  add(values: T[]): void {
+    this.items.push(...values);
+  }
+
+  isItemExists(value: T): boolean {
+    return this.items.indexOf(value) >= 0;
+  }
+
+  start(): void {
+    this.update();
+  }
+
+  stop(): void {
+    clearTimeout(this.updateTimeout);
+    this.updateTimeout = null;
+  }
+
+  private updateTimeout;
+
+  private async update(): Promise<void> {
+    if (this.items.length > 0) {
+      const items = this.items.splice(0, this.itemsLimit);
+      const transformedItems = await this.transformationFn(items);
+      this.queue.next(transformedItems);
+    }
+    this.updateTimeout = setTimeout(() => {
+      this.update();
+    }, this.updateInterval);
+  }
+
+}

libs/event-emitter/src/redmine-data-loader/redmine-data-loader.ts

@@ -0,0 +1,37 @@
+import axios from "axios";
+import { RedmineIssueData } from "../models/RedmineIssueData";
+import { Injectable } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+
+@Injectable()
+export class RedmineDataLoader {
+
+  urlPrefix: string;
+
+  constructor(private configService: ConfigService) {
+    this.urlPrefix = this.configService.get<string>('redmineUrlPrefix');
+  }
+
+  async loadIssues(issues: number[]): Promise<RedmineIssueData[]> {
+    const promises = issues.map(issue => this.loadIssue(issue));
+    return Promise.all(promises);
+  }
+
+  async loadIssue(issueNumber: number): Promise<RedmineIssueData> {
+    const url = this.getUrl(issueNumber);
+    const resp = await axios.get(url);
+    if (!resp || !resp.data || !resp.data.issue) {
+      console.error("Failed to load data from redmine");
+      return null;
+    }
+    return resp.data.issue;
+  }
+
+  private getUrl(issueNumber: number): string {
+    if (typeof this.urlPrefix !== 'string' || this.urlPrefix.length === 0) {
+      throw 'REDMINE_URL_PREFIX is undefined';
+    }
+    return `${this.urlPrefix}/issues/${issueNumber}.json?include=children,journals,relations`;
+  }
+
+}

libs/event-emitter/src/rsslistener/rsslistener-params.ts

@@ -0,0 +1,14 @@
+export type RssListenerSubscriptionParams = {
+  url: string;
+  issueNumberParser: string;
+};
+
+export type RssListenerParams = {
+  subscriptions: RssListenerSubscriptionParams[];
+  updateInterval: number;
+};
+
+export const RssListenerDefaultParams: RssListenerParams = {
+  subscriptions: [],
+  updateInterval: 300000 // 5min
+}

libs/event-emitter/src/rsslistener/rsslistener.ts

@@ -0,0 +1,76 @@
+import { Injectable } from "@nestjs/common";
+import { RssListenerDefaultParams, RssListenerParams, RssListenerSubscriptionParams } from "./rsslistener-params";
+import { BehaviorSubject } from "rxjs";
+import { CreateSubjectsParserByRegExp } from "../subjects-parser/subjects-parser";
+import { EventsListener } from "../events/events-listener";
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const Parser = require('rss-parser');
+const parser = new Parser();
+
+@Injectable()
+export class RssListener implements EventsListener {
+
+  issues = new BehaviorSubject<number[]>([])
+
+  private updateTimeout;
+
+  private lastTimeUpdate: Date | null = null;
+
+  constructor(private config: RssListenerParams = RssListenerDefaultParams) {
+  }
+
+  start(): void {
+    this.updateMessages();
+  }
+
+  stop(): void {
+    clearTimeout(this.updateTimeout);
+    this.updateTimeout = null;
+  }
+
+  private async updateMessages(): Promise<void> {
+    const issues = await this.getIssues();
+    this.issues.next(issues);
+    this.updateTimeout = setTimeout(() => {
+      this.updateMessages();
+    }, this.config.updateInterval);
+  }
+
+  private async getIssues(): Promise<number[]> {
+    const promises = this.config.subscriptions.map(sub => this.createSubscriptionPromise(sub));
+    const issues = await Promise.all(promises);
+    this.lastTimeUpdate = new Date();
+    return this.getFlatIssueNumbers(issues);
+  }
+
+  private async createSubscriptionPromise(subscription: RssListenerSubscriptionParams): Promise<number[]> {
+    const url = subscription.url;
+    const regexp = new RegExp(subscription.issueNumberParser);
+    const subjectParser = CreateSubjectsParserByRegExp(regexp);
+    const feed = await parser.parseURL(url);
+    const issueNumbers: number[] = feed.items
+      .filter(item => {
+        const itemDate = new Date(item.pubDate);
+        return itemDate >= this.lastTimeUpdate;
+      })
+      .map(item => {
+        const issueNumber = subjectParser.getIssueNumber(item.title);
+        return issueNumber;
+      });
+    return issueNumbers;
+  }
+
+  private getFlatIssueNumbers(issues: number[][]): number[] {
+    const res: number[] = [];
+    issues.forEach(issueNumbers => {
+      issueNumbers.forEach(num => {
+        if (res.indexOf(num) < 0) {
+          res.push(num);
+        }
+      });
+    });
+    return res;
+  }
+
+}

libs/event-emitter/src/subjects-parser/subjects-parser.ts

@@ -0,0 +1,17 @@
+export class SubjectsParser {
+
+  constructor(private parser: (string) => number) {}
+
+  getIssueNumber(subject: string): number {
+    return this.parser(subject)
+  }
+
+}
+
+export function CreateSubjectsParserByRegExp(regexp: RegExp): SubjectsParser {
+  const parser = (subject: string): number => {
+    const res = subject.match(regexp)
+    return res && res.length > 0 ? Number(res[0]) : -1;
+  }
+  return new SubjectsParser(parser)
+}

libs/event-emitter/src/utils/random.ts

@@ -0,0 +1,5 @@
+export function random(min: number, max: number): number {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min)) + min;
+}

libs/event-emitter/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "../../dist/libs/event-emitter"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}

nest-cli.json

@@ -0,0 +1,18 @@
+{
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "projects": {
+    "event-emitter": {
+      "type": "library",
+      "root": "libs/event-emitter",
+      "entryFile": "index",
+      "sourceRoot": "libs/event-emitter/src",
+      "compilerOptions": {
+        "tsConfigPath": "libs/event-emitter/tsconfig.lib.json"
+      }
+    }
+  },
+  "compilerOptions": {
+    "webpack": true
+  }
+}

package.json

@@ -0,0 +1,80 @@
+{
+  "name": "eltex-redmine-helper-2",
+  "version": "0.0.1",
+  "description": "",
+  "author": "",
+  "private": true,
+  "license": "UNLICENSED",
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\" \"libs/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json"
+  },
+  "dependencies": {
+    "@nestjs/common": "^8.0.0",
+    "@nestjs/config": "^2.0.0",
+    "@nestjs/core": "^8.0.0",
+    "@nestjs/platform-express": "^8.0.0",
+    "@nestjs/serve-static": "^2.2.2",
+    "reflect-metadata": "^0.1.13",
+    "rimraf": "^3.0.2",
+    "rxjs": "^7.2.0"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^8.0.0",
+    "@nestjs/schematics": "^8.0.0",
+    "@nestjs/testing": "^8.0.0",
+    "@types/express": "^4.17.13",
+    "@types/jest": "27.4.0",
+    "@types/node": "^16.0.0",
+    "@types/supertest": "^2.0.11",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "eslint": "^8.0.1",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^27.2.5",
+    "prettier": "^2.3.2",
+    "source-map-support": "^0.5.20",
+    "supertest": "^6.1.3",
+    "ts-jest": "^27.0.3",
+    "ts-loader": "^9.2.3",
+    "ts-node": "^10.0.0",
+    "tsconfig-paths": "^3.10.1",
+    "typescript": "^4.3.5"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": ".",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "./coverage",
+    "testEnvironment": "node",
+    "roots": [
+      "<rootDir>/src/",
+      "<rootDir>/libs/"
+    ],
+    "moduleNameMapper": {
+      "^@app/event-emitter(|/.*)$": "<rootDir>/libs/event-emitter/src/$1"
+    }
+  }
+}

src/app.controller.spec.ts

@@ -0,0 +1,22 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+describe('AppController', () => {
+  let appController: AppController;
+
+  beforeEach(async () => {
+    const app: TestingModule = await Test.createTestingModule({
+      controllers: [AppController],
+      providers: [AppService],
+    }).compile();
+
+    appController = app.get<AppController>(AppController);
+  });
+
+  describe('root', () => {
+    it('should return "Hello World!"', () => {
+      expect(appController.getHello()).toBe('Hello World!');
+    });
+  });
+});

src/app.controller.ts

@@ -0,0 +1,12 @@
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}

src/app.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}

src/app.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}

src/main.ts

@@ -0,0 +1,8 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+}
+bootstrap();

test/app.e2e-spec.ts

@@ -0,0 +1,24 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import * as request from 'supertest';
+import { AppModule } from './../src/app.module';
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('/ (GET)', () => {
+    return request(app.getHttpServer())
+      .get('/')
+      .expect(200)
+      .expect('Hello World!');
+  });
+});

test/jest-e2e.json

@@ -0,0 +1,17 @@
+{
+  "moduleFileExtensions": [
+    "js",
+    "json",
+    "ts"
+  ],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  },
+  "moduleNameMapper": {
+    "@app/event-emitter/(.*)": "<rootDir>/../libs/event-emitter/src/$1",
+    "@app/event-emitter": "<rootDir>/../libs/event-emitter/src"
+  }
+}

tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2017",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "paths": {
+      "@app/event-emitter": [
+        "libs/event-emitter/src"
+      ],
+      "@app/event-emitter/*": [
+        "libs/event-emitter/src/*"
+      ]
+    }
+  }
+}