Merge branch 'dev'

.gitignore

@@ -43,3 +43,4 @@ configs/eccm-config.jsonc
 configs/current-user-rules.jsonc
 configs/simple-kanban-board-config.jsonc
 configs/kanban-boards/
+configs/calendar-enhancer.jsonc

configs/calendar-enhancer.jsonc.dist

@@ -0,0 +1,17 @@
+{
+	"useForProjects": [
+		"*" // '*' - все, или перечислить отдельные проекты
+	],
+	"customFields": [
+		{
+			"dateFormat": "yyyy-MM-dd HH:mm",
+			"customFieldName": "Custom field name",
+			"alias": ""
+		}
+	],
+	"descriptionCalendarParams": {
+		"title": "Calendar:",
+		"lineRegexp": "(?<=\\*\\ ).+"
+	},
+	"calendarEventsKey": "calendar"
+}

frontend/.env.development

@@ -0,0 +1 @@
+REACT_APP_BACKEND=http://localhost:3001/

frontend/.env.production

@@ -0,0 +1 @@
+REACT_APP_BACKEND=/

frontend/public/images/anchor BLUE.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 55.58 63.52"><defs><style>.a{fill:none;stroke:#135fab;stroke-linecap:round;stroke-miterlimit:10;stroke-width:4px;}</style></defs><circle class="a" cx="27.79" cy="8.94" r="6.94"/><line class="a" x1="27.79" y1="15.89" x2="27.79" y2="61.52"/><line class="a" x1="27.79" y1="25.81" x2="41.68" y2="25.81"/><line class="a" x1="13.9" y1="25.81" x2="27.79" y2="25.81"/><path class="a" d="M76.08,41.4q-1.15,8.64-6,11.91c-4.52,3.07-9.11.76-13.89,4-3.66,2.46-5.21,6.66-6,9.92" transform="translate(-22.5 -5.68)"/><path class="a" d="M24.5,41.4Q25.66,50,30.45,53.31c4.52,3.07,9.11.76,13.89,4,3.66,2.46,5.21,6.66,5.95,9.92" transform="translate(-22.5 -5.68)"/></svg>

frontend/src/issues-list-board/issues-list-board.module.css

@@ -2,5 +2,41 @@
 	display: flex;
 	flex-direction: column;
 	width: 100%;
-	background-color: rgb(225, 225, 225);
+}
+
+.boardName {
+	display: flex;
+	flex-direction: row;
+	padding-left: 10px;
+	padding-right: 10px;
+}
+
+.anchorIcon {
+	width: 24px;
+	padding-left: 30px;
+}
+
+.boardName a {
+	display: flex;
+}
+
+.board {
+	line-height: 30px;
+	
+	background-color: rgb(255, 255, 255);
+	margin: 0;
+	padding: 0;
+	color: rgba(0, 0, 0, 0.8);
+	font-size: 24px;
+	font-family: 'Inter', sans-serif;
+	font-style: normal;
+	line-height: 40px;
+	font-weight: 600;
+	font-size: 24px;
+	line-height: 30px;
+}
+
+.boardHeader {
+	color: #202020;
+	font-family: 'Source Code Pro';
 }

frontend/src/issues-list-board/issues-list-board.tsx

@@ -21,11 +21,16 @@ export const IssuesListBoard = observer((props: Props): JSX.Element => {
 		title = <>{props.store.metainfo.title}</>;
 	}
 	return (
-		<>
+		<div className={Css.board}>
-			<h1 id={props.store.metainfo.title}>{title} <a href={`#${props.store.metainfo.title}`}>#</a></h1>
+			<div className={Css.boardName}>
+				<h2 className={Css.boardHeader} id={props.store.metainfo.title}>{title}</h2>
+				<a href={`#${props.store.metainfo.title}`}>
+					<img src="/images/anchor BLUE.svg" alt="anchor" className={Css.anchorIcon} />
+				</a>
+			</div>
 			<div className={Css.listContainer}>
 				{list}
 			</div>
-		</>
+		</div>
 	);
 });

frontend/src/issues-list-board/issues-list-card.module.css

@@ -5,7 +5,56 @@
 	flex-direction: column;
 }
 
-.issueSubject {}
+.relevanceColor {
+	width: 30px;
+}
+
+.todoBlock {
+	display: flex;
+	flex-direction: row;
+	padding-left: 10px;
+	padding-right: 10px;
+}
+
+.todoBlock:hover {
+	background-color: rgba(0, 0, 0, 0.1);
+}
+
+.importantInformation {
+	width: 100%;
+}
+
+.timeBox {
+	color: #393838;
+	font-weight: 400;
+	font-size: 11px;
+}
+
+.positionInfo {
+	list-style-image: relative;
+	bottom: 3px;
+	right: 3px;
+	text-align: right;
+	float: right;
+}
+
+.priorityBox {
+	background-color: #FFFFFF;
+	border-radius: 2px;
+	padding: 2px 2px 3px 2px;
+	font-size: 10px;
+	line-height: 12px;
+	/* border: 0.5px solid #393838; */
+	color: #ffffff;
+}
+
+.issueSubject {
+	color: #202020;
+	text-decoration: none;
+	font-weight: 400;
+	font-size: 15px;
+	line-height: 18px;
+}
 
 .issueStatus {}
 

frontend/src/issues-list-board/issues-list-card.tsx

@@ -7,11 +7,15 @@ import * as TagsNs from '../misc-components/tags';
 import * as IssueHrefNs from '../misc-components/issue-href';
 import * as IssueDetailsDialogNs from '../misc-components/issue-details-dialog';
 import * as UnreadedFlagNs from '../misc-components/unreaded-flag';
+import { SpentHoursToFixed } from '../utils/spent-hours-to-fixed';
+import { getStyleObjectFromString } from '../utils/style';
 
 export type Props = {
 	store: IIssueStore
 };
 
+export const defaultPriorityStyleKey = 'priorityStyle';
+
 export const IssuesListCard = observer((props: Props): JSX.Element => {
 	const unreadedStore = UnreadedFlagNs.CreateStoreFromLocalStorage(props.store);
 	const detailsStore = IssueDetailsDialogNs.Store.create({
@@ -19,12 +23,15 @@ export const IssuesListCard = observer((props: Props): JSX.Element => {
 		visible: false,
 		unreadedFlagStore: unreadedStore
 	});
+	const priorityStyle = getStyleObjectFromString(props.store[defaultPriorityStyleKey]);
+	const tagsNewLine = (props.store.styledTags && props.store.styledTags.length > 0) ? <br/> : null;
 	return (
-		<div className={Css.listItem} onClick={(e) => {e.stopPropagation(); detailsStore.show();}}>
+		<div className={Css.todoBlock} onClick={(e) => { e.stopPropagation(); detailsStore.show(); }}>
-			<IssueDetailsDialogNs.IssueDetailsDialog store={detailsStore}/>
+			<IssueDetailsDialogNs.IssueDetailsDialog store={detailsStore} />
-			<div>
+			<div className={Css.relevanceColor}>
-				<UnreadedFlagNs.UnreadedFlag store={unreadedStore}/>
+				<TimePassedNs.TimePassed params={{ fromIssue: { issue: props.store, keyName: 'timePassedClass' } }} />
-				<TimePassedNs.TimePassed params={{ fromIssue: { issue: props.store, keyName: 'timePassedClass' } }}/>
+			</div>
+			<div className={Css.importantInformation}>
 				<span className={Css.issueSubject}>
 					<IssueHrefNs.IssueHref
 						url={props.store.url?.url || ''}
@@ -33,11 +40,14 @@ export const IssuesListCard = observer((props: Props): JSX.Element => {
 						id={props.store.id}
 					/>
 				</span>
-				<span className={Css.issueStatus}>| {props.store.status.name}</span>
+				<span> </span>
-				<span className={Css.issueTime}>| {props.store.total_spent_hours} / {props.store.total_estimated_hours}</span>
+				<span className={Css.timeBox}>{SpentHoursToFixed(props.store.total_spent_hours)} / {SpentHoursToFixed(props.store.total_estimated_hours)}</span>
-			</div>
+				{tagsNewLine}
-			<div className={Css.tagsContainer}>
+				<TagsNs.Tags params={{ tags: props.store.styledTags }} />
-				<TagsNs.Tags params={{ tags: props.store.styledTags }}/>
+				<div className={Css.positionInfo}>
+					<span className={Css.timeBox}>{props.store.status.name}</span><span> </span>
+					<span className={Css.priorityBox} style={priorityStyle}>{props.store.priority.name}</span>
+				</div>
 			</div>
 		</div>
 	);

frontend/src/issues-list-board/store.ts

@@ -61,7 +61,7 @@ export const PageStore = types.model({
 });
 
 export async function PageStoreLoadData(store: IPageStore): Promise<void> {
-	const url = `/simple-kanban-board/${store.type}/${store.name}/raw`;
+	const url = `${process.env.REACT_APP_BACKEND}simple-kanban-board/${store.type}/${store.name}/raw`;
 	const resp = await axios.get(url);
 	if (!(resp?.data)) return;
 	

frontend/src/kanban-board/kanban-boards.tsx

@@ -34,7 +34,7 @@ export const KanbanBoards = observer((props: Props) => {
 		const onTreeRefreshClick = (e: React.MouseEvent) => {
 			if (e.target !== e.currentTarget) return;
 			e.stopPropagation();
-			axios.get(`/simple-kanban-board/tree/${props.store.name}/refresh`);
+			axios.get(`${process.env.REACT_APP_BACKEND}simple-kanban-board/tree/${props.store.name}/refresh`);
 		}
 		treeRefreshMenuItem = <button onClick={onTreeRefreshClick}>Force tree refresh</button>;
 	}

frontend/src/kanban-board/store.ts

@@ -86,7 +86,7 @@ export const PageStore = types.model({
 });
 
 export async function PageStoreLoadData(store: IPageStore): Promise<void> {
-	const url = `/simple-kanban-board/${store.type}/${store.name}/raw`;
+	const url = `${process.env.REACT_APP_BACKEND}simple-kanban-board/${store.type}/${store.name}/raw`;
 	const resp = await axios.get(url);
 	if (!(resp?.data)) return;
 	store.setData(resp.data);

frontend/src/misc-components/issue-details-dialog.module.css

@@ -1,3 +1,7 @@
+.reset {
+	all: initial;
+}
+
 .modal {
 	z-index: 1000;
 	position: fixed;

frontend/src/misc-components/issue-details-dialog.tsx

@@ -43,7 +43,7 @@ export type Props = {
 
 export const IssueDetailsDialog = observer((props: Props): JSX.Element => {
 	const onUpdateClick = (e: React.MouseEvent) => {
-		const url = `/redmine-event-emitter/append-issues`;
+		const url = `${process.env.REACT_APP_BACKEND}redmine-event-emitter/append-issues`;
 		axios.post(url, [props.store.issue.id]);
 	};
 	const onCloseClick = (e: React.MouseEvent) => {
@@ -52,29 +52,31 @@ export const IssueDetailsDialog = observer((props: Props): JSX.Element => {
 		props.store.hide();
 	};
 	return (
-		<div className={Css.modal} style={props.store.displayStyle} onClick={onCloseClick}>
+		<div className={Css.reset}>
-			<div className={Css.modalContent}>
+			<div className={Css.modal} style={props.store.displayStyle} onClick={onCloseClick}>
-				<h1>
+				<div className={Css.modalContent}>
-					<button onClick={onCloseClick}>close</button>
+					<h1>
-					<button onClick={onUpdateClick}>force update</button>
+						<button onClick={onCloseClick}>close</button>
-					<IssueHrefNs.IssueHref
+						<button onClick={onUpdateClick}>force update</button>
-						id={props.store.issue?.id || -1}
+						<IssueHrefNs.IssueHref
-						subject={props.store.issue?.subject || ''}
+							id={props.store.issue?.id || -1}
-						tracker={props.store.issue?.tracker?.name || ''}
+							subject={props.store.issue?.subject || ''}
-						url={props.store.issue?.url?.url || ''}
+							tracker={props.store.issue?.tracker?.name || ''}
-					/>
+							url={props.store.issue?.url?.url || ''}
-				</h1>
+						/>
-				<hr/>
+					</h1>
-				<div>
+					<hr/>
-					<h2>Описание:</h2>
+					<div>
-					<pre>
+						<h2>Описание:</h2>
-						{props.store.issue.description}
+						<pre>
-					</pre>
+							{props.store.issue.description}
-				</div>
+						</pre>
-				<hr/>
+					</div>
-				<div>
+					<hr/>
-					<h2>Комментарии:</h2>
+					<div>
-					<Comments details={props.store.issue.journals || []} issue={props.store.issue}/>
+						<h2>Комментарии:</h2>
+						<Comments details={props.store.issue.journals || []} issue={props.store.issue}/>
+					</div>
 				</div>
 			</div>
 		</div>

frontend/src/misc-components/tags.tsx

@@ -14,13 +14,14 @@ export const Tags = (props: Props): JSX.Element => {
 	if (!props.params.tags) {
 		return (<></>);
 	}
-	const label = props.params.label || 'Tags';
+	let label = props.params.label || '';
+	if (label) label = `${label}: `;
 	const tags = props.params.tags.map((tag) => {
 		return <TagNs.Tag tag={tag.tag} style={tag.style} key={tag.tag}/>;
 	}) || [];
 	return (
-		<div>
+		<>
-			{label}: {tags}
+			{label}{tags}
-		</div>
+		</>
 	);
 }

frontend/src/misc-components/time-passed.module.css

@@ -1,27 +1,27 @@
 .timepassedDot {
-	height: 10px;
+	height: 15px;
-	width: 10px;
+	width: 15px;
-	background-color: #bbb;
+	background-color: #808080;
 	border-radius: 50%;
 	display: inline-block;
 }
 
 .timepassedDot.hot {
-	background-color: red;
+	background-color: #92201A;
 }
 
 .timepassedDot.warm {
-	background-color: orange;
+	background-color: #FA5E26;
 }
 
 .timepassedDot.comfort {
-	background-color: rgba(255, 255, 0, 0.4);
+	background-color: #FAD116;
 }
 
 .timepassedDot.breezy {
-	background-color: rgba(0, 255, 0, 0.4);
+	background-color: #117722;
 }
 
 .timepassedDot.cold {
-	background-color: rgba(0, 0, 255, 0.1);
+	background-color: #808080;
 }

frontend/src/utils/service-actions.ts

@@ -14,7 +14,7 @@ export const onIssuesRefreshClick = (e: React.MouseEvent) => {
 export const onGetIssuesQueueSizeClick = async (e: React.MouseEvent): Promise<void> => {
 	if (e.target !== e.currentTarget) return;
 	e.stopPropagation();
-	const resp = await axios.get(`/redmine-event-emitter/get-issues-queue-size`);
+	const resp = await axios.get(`${process.env.REACT_APP_BACKEND}redmine-event-emitter/get-issues-queue-size`);
 	console.debug(`resp -`, resp); // DEBUG
 	if (!resp || typeof resp.data !== 'number') return;
 	alert(`Issues queue size - ${resp.data}`);

frontend/src/utils/spent-hours-to-fixed.ts

@@ -0,0 +1,11 @@
+/**
+ * Форматирование чисел для вывода трудозатрат
+ * @param a 
+ * @returns 
+ */
+export const SpentHoursToFixed = (a: number|string|null|undefined): string => {
+	if (a === null || typeof a === 'undefined') return '-';
+	const res = (typeof a === 'number') ? a : Number(a);
+	if (!Number.isFinite(res)) return '-';
+	return `${parseFloat(res.toFixed(1))}`;
+};

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

@@ -0,0 +1,58 @@
+import { Controller, Get, Inject, Logger, Param, Query } from "@nestjs/common";
+import { CalendarService } from "./calendar.service";
+import nano from 'nano';
+import { UNLIMITED } from "../consts/consts";
+
+@Controller('calendar')
+export class CalendarController {
+	private logger = new Logger(CalendarController.name);
+	
+	constructor(
+		@Inject('CALENDAR_SERVICE')
+		private calendarService: CalendarService
+	) {}
+	
+	@Get()
+	async get(@Param('filter') filter: any): Promise<string> {
+		return await this.calendarService.getICalData(filter);
+	}
+	
+	@Get('/simple')
+	async simple(
+		@Query('project') project?: string,
+		@Query('category') category?: string
+	): Promise<string> {
+		const andSection: any[] = [
+			{
+				"closed_on": {
+					"$exists": false
+				}
+			}
+		];
+		if (project) {
+			andSection.push({
+				"project.name": {
+					"$in": [
+						project
+					]
+				}
+			});
+		}
+		if (category) {
+			andSection.push({
+				"category.name": {
+					"$in": [
+						category
+					]
+				}
+			});
+		}
+		const query: nano.MangoQuery = {
+			selector: {
+				"$and": andSection
+			},
+			limit: UNLIMITED
+		};
+		return await this.calendarService.getICalData(query);
+	}
+}

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

@@ -0,0 +1,113 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { CalendarEvent } from "../models/calendar-event";
+import { RedmineTypes } from "../models/redmine-types";
+import * as Luxon from 'luxon';
+import { IssuesService } from "../issues/issues.service";
+import { randomUUID } from 'crypto';
+
+/*
+BEGIN:VCALENDAR
+PRODID:-//Example Corp.//CalDAV Client//EN
+VERSION:2.0
+BEGIN:VEVENT
+UID:1@example.com
+SUMMARY:One-off Meeting
+DTSTAMP:20041210T183904Z
+DTSTART:20041207T120000Z
+DTEND:20041207T130000Z
+END:VEVENT
+BEGIN:VEVENT
+UID:2@example.com
+SUMMARY:Weekly Meeting
+DTSTAMP:20041210T183838Z
+DTSTART:20041206T120000Z
+DTEND:20041206T130000Z
+RRULE:FREQ=WEEKLY
+END:VEVENT
+BEGIN:VEVENT
+UID:2@example.com
+SUMMARY:Weekly Meeting
+RECURRENCE-ID:20041213T120000Z
+DTSTAMP:20041210T183838Z
+DTSTART:20041213T130000Z
+DTEND:20041213T140000Z
+END:VEVENT
+END:VCALENDAR
+*/
+
+export type IssueAndEvent = {
+	issue: RedmineTypes.ExtendedIssue;
+	event: CalendarEvent;
+};
+
+@Injectable()
+export class CalendarService {
+	private interval = 30 * 24 * 60 * 60 * 1000; // 30 days
+	
+	constructor(public calendarEventsKey: string, private issuesService: IssuesService) {}
+	
+	async getICalData(filter: any): Promise<string> {
+		const issues = await this.issuesService.find(filter);
+		const actualEvents = this.getActualEvents(issues);
+		const formattedEvents = actualEvents.map((event) => {
+			return this.generateICalendarEvent(event.issue, event.event);
+		}).filter((event) => {
+			return !!event;
+		});
+		const res = this.generateICalendar(formattedEvents);
+		return res;
+	}
+	
+	private getActualEvents(issues: RedmineTypes.ExtendedIssue[]): IssueAndEvent[] {
+		const res: IssueAndEvent[] = [];
+		for (let i = 0; i < issues.length; i++) {
+			const issue = issues[i];
+			if (!issue[this.calendarEventsKey] || issue[this.calendarEventsKey].length <= 0) {
+				continue;
+			}
+			const events = issue[this.calendarEventsKey];
+			for (let j = 0; j < events.length; j++) {
+				const event = events[j];
+				if (this.actualEvent(event)) res.push({event: event, issue: issue});
+			}
+		}
+		return res;
+	}
+	
+	private actualEvent(event: CalendarEvent): boolean {
+		const now = Luxon.DateTime.now().toMillis();
+		const from = now - this.interval;
+		const to = now + this.interval;
+		return Boolean(
+			(from <= event.fromTimestamp && event.fromTimestamp <= to) ||
+			(from <= event.toTimestamp && event.toTimestamp <= to)
+		);
+	}
+	
+	private generateICalendarEvent(issue: RedmineTypes.Issue, data: CalendarEvent): string | null {
+		if (!data) return null;
+		return `BEGIN:VEVENT
+UID:${randomUUID()}@example.com
+DTSTAMP:${this.formatTimestamp(data.fromTimestamp, data.fullDay)}
+ORGANIZER;CN=John Doe:MAILTO:john.doe@example.com
+DTSTART:${this.formatTimestamp(data.fromTimestamp, data.fullDay)}
+DTEND:${this.formatTimestamp(data.toTimestamp, data.fullDay)}
+SUMMARY:#${issue.id} - ${data.description} - ${issue.subject}
+END:VEVENT`;
+	}
+	
+	private formatTimestamp(timestamp: number, fullDay?: boolean): string {
+		let format: string = fullDay ? "yyyyMMdd" : "yyyyMMdd'T'HHmmss'Z'";
+		let datetime = Luxon.DateTime.fromMillis(timestamp);
+		if (!fullDay) datetime = datetime.setZone('utc');
+		return datetime.toFormat(format);
+	}
+	
+	private generateICalendar(events: string[]): string {
+		return `BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Example Corp.//CalDAV Client//EN
+${events.join("\n")}
+END:VCALENDAR`;
+	}
+}

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

@@ -28,6 +28,9 @@ import { ListIssuesByUsersLikeJiraWidgetService } from './project-dashboard/widg
 import { TimePassedHighlightEnhancer } from './issue-enhancers/time-passed-highlight-enhancer';
 import { ListIssuesByFieldsWidgetService } from './project-dashboard/widgets/list-issues-by-fields.widget.service';
 import { IssuesUpdaterService } from './issues-updater/issues-updater.service';
+import { CalendarEnhancer } from './issue-enhancers/calendar-enhancer';
+import { CalendarService } from './calendar/calendar.service';
+import { CalendarController } from './calendar/calendar.controller';
 
 @Module({})
 export class EventEmitterModule implements OnModuleInit {
@@ -68,6 +71,28 @@ export class EventEmitterModule implements OnModuleInit {
           },
           inject: [ConfigService],
         },
+        {
+          provide: 'CALENDAR_ENHANCER',
+          useFactory: (configService: ConfigService) => {
+            const calendarEnhancerConfig =
+              configService.get<Record<string, any>>('calendarEnhancer');
+            return new CalendarEnhancer(
+              calendarEnhancerConfig.useForProjects,
+              calendarEnhancerConfig.customFields,
+              calendarEnhancerConfig.descriptionCalendarParams,
+              calendarEnhancerConfig.calendarEventsKey,
+            );
+          },
+          inject: [ConfigService],
+        },
+        {
+          provide: 'CALENDAR_SERVICE',
+          useFactory: (calendarEnhancer: CalendarEnhancer, issuesService: IssuesService): CalendarService => {
+            const calendarEventsKey = calendarEnhancer.calendarEventsKey;
+            return new CalendarService(calendarEventsKey, issuesService);
+          },
+          inject: ['CALENDAR_ENHANCER', IssuesService]
+        },
       ],
       exports: [
         EventEmitterService,
@@ -95,8 +120,16 @@ export class EventEmitterModule implements OnModuleInit {
           provide: 'ISSUES_UPDATER_SERVICE',
           useExisting: 'ISSUES_UPDATER_SERVICE',
         },
+        {
+          provide: 'CALENDAR_ENHANCER',
+          useExisting: 'CALENDAR_ENHANCER',
+        },
+        {
+          provide: 'CALENDAR_SERVICE',
+          useExisting: 'CALENDAR_SERVICE',
+        },
       ],
-      controllers: [MainController, UsersController, IssuesController],
+      controllers: [MainController, UsersController, IssuesController, CalendarController],
     };
   }
 

libs/event-emitter/src/issue-enhancers/calendar-enhancer.ts

@@ -0,0 +1,178 @@
+import { IssueEnhancerInterface } from '@app/event-emitter/issue-enhancers/issue-enhancer-interface';
+import { RedmineTypes } from '@app/event-emitter/models/redmine-types';
+import { Injectable, Logger } from '@nestjs/common';
+import * as Luxon from 'luxon';
+import { CalendarEvent } from '../models/calendar-event';
+import * as DatesParser from '../utils/string-with-dates-parser';
+
+export type DescriptionParserParams = {
+  title: string;
+  lineRegexp: string;
+};
+
+export type CustomFieldParserParams = {
+  dateFormat: string;
+  customFieldName: string;
+  /** Время в минутах */
+  interval?: number;
+  fullDay?: boolean;
+  alias?: string;
+};
+
+export const UNKNOWN_CALENDAR_EVENT = 'Unknown calendar event';
+
+@Injectable()
+export class CalendarEnhancer implements IssueEnhancerInterface {
+  private logger = new Logger(CalendarEnhancer.name);
+  
+  name = 'calendar';
+
+  constructor(
+    public useForProjects: string[],
+    public customFields: CustomFieldParserParams[],
+    public descriptionCalendarParams: DescriptionParserParams,
+    public calendarEventsKey: string,
+  ) {
+    const initParams = {useForProjects, customFields, descriptionCalendarParams, calendarEventsKey};
+    this.logger.debug(`Calendar enhancer init with ${JSON.stringify(initParams)}`);
+  }
+
+  async enhance(
+    issue: RedmineTypes.ExtendedIssue,
+  ): Promise<RedmineTypes.ExtendedIssue> {
+    const res: RedmineTypes.ExtendedIssue = { ...issue };
+
+    if (!this.checkProject(res)) {
+      return res;
+    }
+
+    try {
+      res[this.calendarEventsKey] = this.getCalendarEvents(res);
+    } catch (ex) {
+      this.logger.error(`Error at parsing calendar events, message - ${ex}: ${(ex as Error)?.stack}`);
+      return res;
+    }
+    this.logger.debug(`Calendar events for #${issue.id}: issue.${this.calendarEventsKey} = ${JSON.stringify(res[this.calendarEventsKey])}`);
+
+    return res;
+  }
+
+  private checkProject(issue: RedmineTypes.ExtendedIssue): boolean {
+    if (this.useForProjects.indexOf('*') >= 0) {
+      return true;
+    }
+    if (
+      this.useForProjects.length > 0 &&
+      this.useForProjects.indexOf(issue.project.name) >= 0
+    ) {
+      return true;
+    }
+    return false;
+  }
+
+  private getCalendarEvents(
+    issue: RedmineTypes.ExtendedIssue,
+  ): CalendarEvent[] {
+    return [
+      ...this.getCalendarEventsFromCustomFields(issue),
+      ...this.getCalendarEventsFromSubject(issue),
+      ...this.getCalendarEventsFromDescription(issue),
+    ];
+  }
+
+  private getCalendarEventsFromCustomFields(
+    issue: RedmineTypes.ExtendedIssue,
+  ): CalendarEvent[] {
+    const res: CalendarEvent[] = [];
+    for (let i = 0; i < this.customFields.length; i++) {
+      const cfParam = this.customFields[i];
+      const event = this.getCalendarEventFromCustomField(issue, cfParam);
+      if (event) res.push(event);
+    }
+    return res;
+  }
+
+  private getCalendarEventFromCustomField(
+    issue: RedmineTypes.ExtendedIssue,
+    params: CustomFieldParserParams,
+  ): CalendarEvent | null {
+    if (typeof params.interval !== 'number' && params.fullDay !== true)
+      return null;
+
+    const cf = issue.custom_fields.find((issueCf) => {
+      return issueCf.name === params.customFieldName;
+    });
+    if (!cf) return null;
+
+    const from = Luxon.DateTime.fromFormat(cf.value, params.dateFormat);
+    if (!from.isValid) return null;
+
+    let to: Luxon.DateTime;
+    if (typeof params.interval === 'number') {
+      const interval = Luxon.Duration.fromObject({ minutes: params.interval });
+      to = from.plus(interval);
+    } else if (params.fullDay) {
+      from.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+      to = from.plus(Luxon.Duration.fromObject({ day: 1 }));
+    } else {
+      return null;
+    }
+    if (!to.isValid) return null;
+
+    return {
+      from: from.toISO(),
+      fromTimestamp: from.toMillis(),
+      to: to.toISO(),
+      toTimestamp: to.toMillis(),
+      fullDay: Boolean(params.fullDay),
+      description: params.alias || cf.name || UNKNOWN_CALENDAR_EVENT,
+    };
+  }
+
+  private getCalendarEventsFromSubject(
+    issue: RedmineTypes.ExtendedIssue,
+  ): CalendarEvent[] {
+    const matches = issue.subject.matchAll(/(?<=\()[^()]*(?=\))/g);
+    const items = [...matches].map((i) => i[0]).filter((i) => !!i);
+
+    return items
+      .map((item) => DatesParser.parseToCalendarEvent(item))
+      .filter((i) => !!i);
+  }
+
+  private getCalendarEventsFromDescription(
+    issue: RedmineTypes.ExtendedIssue,
+  ): CalendarEvent[] {
+    const text = issue.description;
+
+    const lines = text.split('\n').map((line) => line.trim());
+
+    const calendarStartIndex = lines.indexOf(this.descriptionCalendarParams.title);
+    if (calendarStartIndex < 0) return [];
+
+    let index = calendarStartIndex + 1;
+    let line = this.extractFromList(lines[index]);
+    if (!line) {
+      index++;
+      line = this.extractFromList(lines[index]);
+    }
+    if (!line) return [];
+
+    const res: string[] = [];
+
+    do {
+      res.push(line);
+      index++;
+      line = this.extractFromList(lines[index]);
+    } while (line);
+
+    return res.map((line) => DatesParser.parseToCalendarEvent(line));
+  }
+
+  private extractFromList(line: string): string | null {
+    if (!line || line.length <= 0) return null;
+    const regexp = new RegExp(this.descriptionCalendarParams.lineRegexp);
+    const match = line.match(regexp);
+    return match && match[0] ? match[0] : null;
+  }
+}

libs/event-emitter/src/issue-enhancers/priority-styles-enhancer.ts

@@ -0,0 +1,103 @@
+import { Injectable } from '@nestjs/common';
+import { RedmineTypes } from '../models/redmine-types';
+import { IssueEnhancerInterface } from './issue-enhancer-interface';
+
+export type StyleRule = {
+  default?: boolean;
+  priorityName?: string;
+  style?: string;
+  className?: string;
+};
+
+export const defaultRule: StyleRule = {
+  default: true,
+  style: 'background-color: gray; color: white;',
+};
+
+export const defaultKey = 'priorityStyle';
+
+export function ValidateStyleRule(rule: StyleRule): boolean {
+  return (
+    // check default prop
+    (typeof rule.default === 'boolean' ||
+      typeof rule.default === 'undefined') &&
+    // check priority name prop
+    (rule.default ||
+      (!rule.default &&
+        typeof rule.priorityName === 'string' &&
+        rule.priorityName.length > 0)) &&
+    // check style or className props
+    ((typeof rule.style === 'string' && rule.style.length > 0) ||
+      (typeof rule.className === 'string' && rule.className.length > 0))
+  );
+}
+
+export function HasDefaultRule(rules: StyleRule[]): boolean {
+  const hasDefaultRule = rules.find((rule) => rule.default);
+  return Boolean(hasDefaultRule);
+}
+
+@Injectable()
+export class PriorityStylesEnhancer implements IssueEnhancerInterface {
+  name: string;
+
+  private rules: StyleRule[];
+
+  private targetKey: string;
+
+  constructor(rules?: StyleRule[], targetKey?: string) {
+    let validatedRules: StyleRule[] = [];
+    if (rules && rules.length > 0) {
+      validatedRules = rules.filter(ValidateStyleRule);
+    }
+    if (!HasDefaultRule(validatedRules)) {
+      validatedRules.push(defaultRule);
+    }
+    this.rules = validatedRules;
+
+    this.targetKey =
+      typeof targetKey === 'string' && targetKey.length > 0
+        ? targetKey
+        : defaultKey;
+  }
+
+  async enhance(
+    issue: RedmineTypes.ExtendedIssue,
+  ): Promise<RedmineTypes.ExtendedIssue> {
+    const priorityName = issue?.priority?.name;
+    if (!priorityName) return issue;
+    const priorityRule = this.findPriorityRule(priorityName);
+    issue[this.targetKey] = priorityRule.style || priorityRule.className;
+    return issue;
+  }
+
+  private findPriorityRule(priority: string): StyleRule {
+    return (this.rules.find((r) => r.priorityName === priority) ||
+      this.rules.find((r) => r.default)) as StyleRule;
+  }
+}
+
+export type PrioritiesStyleParams = {
+  rules: StyleRule[];
+  targetKey: string;
+};
+
+export type ConfigWithPriorityStyles = {
+  priorities?: PrioritiesStyleParams;
+  [key: string]: any;
+};
+
+export function CreatePriorityStylesEnhancer(
+  cfg: ConfigWithPriorityStyles,
+): PriorityStylesEnhancer {
+  let params: PrioritiesStyleParams;
+  if (cfg.priorities && cfg.priorities.rules && cfg.priorities.targetKey) {
+    params = cfg.priorities;
+  } else {
+    params = {
+      rules: [defaultRule],
+      targetKey: defaultKey,
+    };
+  }
+  return new PriorityStylesEnhancer(params.rules, params.targetKey);
+}

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

@@ -0,0 +1,8 @@
+export type CalendarEvent = {
+  from: string;
+  fromTimestamp: number;
+  to: string;
+  toTimestamp: number;
+  fullDay: boolean;
+  description: string;
+};

libs/event-emitter/src/project-dashboard/widgets/list-issues-by-fields.widget.service.ts

@@ -13,6 +13,7 @@ import { TreeIssuesStore } from '@app/event-emitter/utils/tree-issues-store';
 import { Injectable, Logger } from '@nestjs/common';
 import nano from 'nano';
 import { WidgetInterface } from '../widget-interface';
+import * as PriorityStylesEnhancerNs from '@app/event-emitter/issue-enhancers/priority-styles-enhancer';
 
 export namespace ListIssuesByFieldsWidgetNs {
   export type Params = {
@@ -66,6 +67,7 @@ export class ListIssuesByFieldsWidgetService
       this.timePassedHighlightEnhancer,
       this.issueUrlEnhancer,
       TagStyledEnhancerNs.CreateTagStyledEnhancerForConfig(widgetParams),
+      PriorityStylesEnhancerNs.CreatePriorityStylesEnhancer(widgetParams),
     ]);
     const grouped = store.groupByStatusWithExtra((issue) => {
       return this.getGroupFromIssue(issue, widgetParams);

libs/event-emitter/src/project-dashboard/widgets/list-issues-by-users-like-jira.widget.service.ts

@@ -12,6 +12,7 @@ import { TreeIssuesStore } from '@app/event-emitter/utils/tree-issues-store';
 import { Injectable, Logger } from '@nestjs/common';
 import nano from 'nano';
 import { WidgetInterface } from '../widget-interface';
+import * as PriorityStylesEnhancerNs from '@app/event-emitter/issue-enhancers/priority-styles-enhancer';
 
 export namespace ListIssuesByUsersLikeJiraWidgetNs {
   export namespace Models {
@@ -61,6 +62,7 @@ export class ListIssuesByUsersLikeJiraWidgetService
       this.timePassedHighlightEnhancer,
       this.issueUrlEnhancer,
       TagStyledEnhancerNs.CreateTagStyledEnhancerForConfig(widgetParams),
+      PriorityStylesEnhancerNs.CreatePriorityStylesEnhancer(widgetParams),
     ]);
     const grouped = store.groupByStatusWithExtraToMultipleStories((issue) => {
       const users = [] as string[];

libs/event-emitter/src/project-dashboard/widgets/list-issues-by-users.widget.service.ts

@@ -13,6 +13,7 @@ import { TreeIssuesStore } from '@app/event-emitter/utils/tree-issues-store';
 import { Injectable, Logger } from '@nestjs/common';
 import nano from 'nano';
 import { WidgetInterface } from '../widget-interface';
+import * as PriorityStylesEnhancerNs from '@app/event-emitter/issue-enhancers/priority-styles-enhancer';
 
 export namespace ListIssuesByUsersWidgetNs {
   export namespace Models {
@@ -73,6 +74,7 @@ export class ListIssuesByUsersWidgetService
       this.timePassedHighlightEnhancer,
       this.issueUrlEnhancer,
       TagStyledEnhancerNs.CreateTagStyledEnhancerForConfig(widgetParams),
+      PriorityStylesEnhancerNs.CreatePriorityStylesEnhancer(widgetParams),
     ]);
     const grouped = store.groupByStatusWithExtra((issue) => {
       const res = this.getUserValueByKey(issue, widgetParams.userKey);

libs/event-emitter/src/project-dashboard/widgets/root-issue-subtrees.widget.service.ts

@@ -12,6 +12,7 @@ import {
 } from '@app/event-emitter/utils/tree-issues-store';
 import { Injectable } from '@nestjs/common';
 import { WidgetInterface } from '../widget-interface';
+import * as PriorityStylesEnhancerNs from '@app/event-emitter/issue-enhancers/priority-styles-enhancer';
 
 export namespace RootIssueSubTreesWidgetNs {
   export namespace Models {
@@ -66,6 +67,7 @@ export class RootIssueSubTreesWidgetService
       this.timePassedHighlightEnhancer,
       this.issueUrlEnhancer,
       TagStyledEnhancerNs.CreateTagStyledEnhancerForConfig(widgetParams),
+      PriorityStylesEnhancerNs.CreatePriorityStylesEnhancer(widgetParams),
     ]);
     let stories: TreeIssuesStoreNs.Models.GetFlatStories.Result;
     if (widgetParams.parentsAsGroups) {

libs/event-emitter/src/utils/string-with-dates-parser.ts

@@ -0,0 +1,157 @@
+import * as Moo from 'moo';
+import { CalendarEvent } from '../models/calendar-event';
+import * as Luxon from 'luxon';
+import { Logger } from '@nestjs/common';
+
+export const DEFAULT_PARAMS: Moo.Rules = {
+  WS: /[ \t]+/,
+  delimiter: /(?: - |: )/,
+  delimiter2: /(?:^\* |^- |(?!\d)T(?!>\d))/,
+  date: /\b(?:(?:\d{2}\.\d{2}\.(?:\d{2}|\d{4}))|(?:\d{4}-\d{2}-\d{2}))\b/,
+  time: /\b(?:\d{2}\b:\d{2}:\d{2}|\d{2}:\d{2})\b/,
+  word: /[\wА-Яа-я]+/,
+  other: { match: /./, lineBreaks: true },
+  NL: { match: /\n/, lineBreaks: true },
+};
+
+export const DEFAULT_DATE_FORMATS = ['yyyy-MM-dd', 'dd.MM.yyyy', 'dd.MM.yy'];
+
+export const DEFAULT_TIME_FORMATS = ['HH:mm:ss', 'HH:mm'];
+
+export const DEFAULT_EVENT_DURATION = 60 * 60 * 1000; // 1 hour in millis
+
+const logger = new Logger('string-with-dates-parser');
+
+export function parse(str: string, params?: Moo.Rules): Moo.Token[] {
+  if (!params) params = DEFAULT_PARAMS;
+  try {
+    const lexer = Moo.compile(params);
+    lexer.reset(str);
+    const res: Moo.Token[] = [];
+    let token = lexer.next();
+    while (token) {
+      res.push(token);
+      token = lexer.next();
+    }
+    return res;
+  } catch (ex) {
+    logger.error(`Error at parse str=${str} with params=${params}, error message - ${ex}`);
+    return [];
+  }
+}
+
+export type ParserOpts = {
+  rules?: Moo.Rules;
+  dateFormats?: string[];
+  timeFormats?: string[];
+};
+
+export const DEFAULT_PARSER_OPTS: ParserOpts = {
+  rules: DEFAULT_PARAMS,
+  dateFormats: DEFAULT_DATE_FORMATS,
+  timeFormats: DEFAULT_TIME_FORMATS,
+};
+
+export function parseDate(
+  str: string,
+  formats?: string[],
+): Luxon.DateTime | null {
+  if (!str) return null;
+  if (!formats) formats = DEFAULT_DATE_FORMATS;
+  let res: Luxon.DateTime;
+  for (let i = 0; i < formats.length; i++) {
+    const format = formats[i];
+    res = Luxon.DateTime.fromFormat(str, format);
+    if (res.isValid) return res;
+  }
+  return null;
+}
+
+export function parseTime(
+  str: string,
+  formats?: string[],
+): Luxon.Duration | null {
+  if (!str) return null;
+  if (!formats) formats = DEFAULT_TIME_FORMATS;
+  let res: Luxon.DateTime;
+  for (let i = 0; i < formats.length; i++) {
+    const format = formats[i];
+    res = Luxon.DateTime.fromFormat(str, format);
+    if (res.isValid) {
+      const startOfDay = res.set({
+        hour: 0,
+        minute: 0,
+        second: 0,
+        millisecond: 0,
+      });
+      return res.diff(startOfDay).shiftToAll();
+    }
+  }
+  return null;
+}
+
+export function parseToCalendarEvent(
+  str: string,
+  opts?: ParserOpts,
+): CalendarEvent | null {
+  if (!opts) opts = DEFAULT_PARSER_OPTS;
+  const tokens = parse(str, opts?.rules);
+
+  const words = tokens.filter((i) => i.type === 'word');
+
+  const dates = tokens.filter((i) => i.type === 'date');
+  if (dates.length < 0) return null;
+  const date1 = parseDate(dates[0]?.value, opts?.dateFormats);
+  const date2 = parseDate(dates[1]?.value, opts?.dateFormats);
+
+  const times = tokens.filter((i) => i.type === 'time');
+  const time1 = parseTime(times[0]?.value, opts?.timeFormats);
+  const time2 = parseTime(times[1]?.value, opts?.timeFormats);
+
+  let from: Luxon.DateTime;
+  let to: Luxon.DateTime;
+  let fullDay: boolean;
+
+  if (date1 && time1) {
+    from = date1.set({
+      hour: time1.hours,
+      minute: time1.minutes,
+      second: time1.seconds,
+    });
+    fullDay = false;
+  } else if (date1) {
+    from = date1;
+    fullDay = true;
+  } else {
+    return null;
+  }
+
+  if (date2 && time2) {
+    to = date2.set({
+      hour: time2.hours,
+      minute: time2.minutes,
+      second: time2.seconds,
+    });
+  } else if (date2) {
+    to = date2.plus({ day: 1 });
+  } else if (fullDay) {
+    to = from.plus({ day: 1 });
+  } else if (time2) {
+    to = date1.set({
+      hour: time2.hours,
+      minute: time2.minutes,
+      second: time2.seconds
+    });
+  } else {
+    to = from.plus(Luxon.Duration.fromMillis(DEFAULT_EVENT_DURATION));
+  }
+
+  return {
+    from: from.toISO(),
+    fromTimestamp: from.toMillis(),
+    to: to.toISO(),
+    toTimestamp: to.toMillis(),
+    description: words.join(' '),
+    fullDay: fullDay,
+  };
+}

package-lock.json

@@ -24,6 +24,7 @@
         "imap-simple": "^5.1.0",
         "jsonc-parser": "^3.2.0",
         "luxon": "^3.1.0",
+        "moo": "^0.5.2",
         "nano": "^10.0.0",
         "node-telegram-bot-api": "^0.59.0",
         "reflect-metadata": "^0.1.13",
@@ -41,6 +42,7 @@
         "@types/express": "^4.17.13",
         "@types/jest": "27.4.0",
         "@types/luxon": "^3.1.0",
+        "@types/moo": "^0.5.6",
         "@types/node": "^16.0.0",
         "@types/node-telegram-bot-api": "^0.57.1",
         "@types/supertest": "^2.0.11",
@@ -2141,6 +2143,12 @@
       "integrity": "sha512-Y4XFY5VJAuw0FgAqPNd6NNoV44jbq9Bz2L7Rh/J6jLTiHBSBJa9fxqQIvkIld4GsoDOcCbvzOUAbLPsSKKg+uA==",
       "dev": true
     },
+    "node_modules/@types/moo": {
+      "version": "0.5.6",
+      "resolved": "https://registry.npmjs.org/@types/moo/-/moo-0.5.6.tgz",
+      "integrity": "sha512-Q60hZhulhl2Ox4LjbJvhH+HzsKrwzLPjEB8dZw0fK1MH2HyOLe6LDou68yTfsWasxGv7DPZe5VNM5vgpzOa2nw==",
+      "dev": true
+    },
     "node_modules/@types/node": {
       "version": "16.11.49",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.49.tgz",
@@ -7452,6 +7460,11 @@
         "mkdirp": "bin/cmd.js"
       }
     },
+    "node_modules/moo": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/moo/-/moo-0.5.2.tgz",
+      "integrity": "sha512-iSAJLHYKnX41mKcJKjqvnAN9sf0LMDTXDEvFv+ffuRR9a1MIuXLjMNL6EsnDHSkKLTWNqQQ5uo61P4EbU4NU+Q=="
+    },
     "node_modules/ms": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
@@ -12014,6 +12027,12 @@
       "integrity": "sha512-Y4XFY5VJAuw0FgAqPNd6NNoV44jbq9Bz2L7Rh/J6jLTiHBSBJa9fxqQIvkIld4GsoDOcCbvzOUAbLPsSKKg+uA==",
       "dev": true
     },
+    "@types/moo": {
+      "version": "0.5.6",
+      "resolved": "https://registry.npmjs.org/@types/moo/-/moo-0.5.6.tgz",
+      "integrity": "sha512-Q60hZhulhl2Ox4LjbJvhH+HzsKrwzLPjEB8dZw0fK1MH2HyOLe6LDou68yTfsWasxGv7DPZe5VNM5vgpzOa2nw==",
+      "dev": true
+    },
     "@types/node": {
       "version": "16.11.49",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.49.tgz",
@@ -16024,6 +16043,11 @@
         "minimist": "^1.2.6"
       }
     },
+    "moo": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/moo/-/moo-0.5.2.tgz",
+      "integrity": "sha512-iSAJLHYKnX41mKcJKjqvnAN9sf0LMDTXDEvFv+ffuRR9a1MIuXLjMNL6EsnDHSkKLTWNqQQ5uo61P4EbU4NU+Q=="
+    },
     "ms": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",

package.json

@@ -36,6 +36,7 @@
     "imap-simple": "^5.1.0",
     "jsonc-parser": "^3.2.0",
     "luxon": "^3.1.0",
+    "moo": "^0.5.2",
     "nano": "^10.0.0",
     "node-telegram-bot-api": "^0.59.0",
     "reflect-metadata": "^0.1.13",
@@ -53,6 +54,7 @@
     "@types/express": "^4.17.13",
     "@types/jest": "27.4.0",
     "@types/luxon": "^3.1.0",
+    "@types/moo": "^0.5.6",
     "@types/node": "^16.0.0",
     "@types/node-telegram-bot-api": "^0.57.1",
     "@types/supertest": "^2.0.11",

src/app.module.ts

@@ -50,6 +50,7 @@ import { join } from 'path';
 import { SimpleIssuesListController } from './dashboards/simple-issues-list.controller';
 import { TagsManagerController } from './tags-manager/tags-manager.controller';
 import { CreateTagManagerServiceProvider } from './tags-manager/tags-manager.service';
+import { CalendarEnhancer } from '@app/event-emitter/issue-enhancers/calendar-enhancer';
 
 @Module({
   imports: [
@@ -132,6 +133,9 @@ export class AppModule implements OnModuleInit {
 
     @Inject('CATEGORY_MERGE_TO_TAGS_ENHANCER')
     private categoryMergeToTagsEnhancer: CategoryMergeToTagsEnhancer,
+
+    @Inject('CALENDAR_ENHANCER')
+    private calendarEnhancer: CalendarEnhancer,
   ) {}
 
   onModuleInit() {
@@ -148,6 +152,7 @@ export class AppModule implements OnModuleInit {
       this.currentUserEnhancer,
       this.issueUrlEnhancer,
       this.categoryMergeToTagsEnhancer,
+      this.calendarEnhancer,
     ]);
 
     this.personalNotificationsService.$messages.subscribe((resp) => {

src/configs/app.ts

@@ -8,6 +8,7 @@ import RedmineStatusChangesConfigLoader from './status-changes.config';
 import RedmineEccmConfig from './eccm.config';
 import RedmineCurrentUserRulesConfig from './current-user-rules.config';
 import SimpleKanbanBoardConfig from './simple-kanban-board.config';
+import CalendarEnhancer from './calendar-enhancer.config';
 
 const redmineIssueEventEmitterConfig = RedmineIssueEventEmitterConfigLoader();
 const redmineStatusesConfig = RedmineStatusesConfigLoader();
@@ -15,6 +16,7 @@ const redmineStatusChanges = RedmineStatusChangesConfigLoader();
 const redmineEccm = RedmineEccmConfig();
 const redmineCurrentUserRules = RedmineCurrentUserRulesConfig();
 const simpleKanbanBoard = SimpleKanbanBoardConfig();
+const calendarEnhancer = CalendarEnhancer();
 
 let appConfig: AppConfig;
 
@@ -39,6 +41,7 @@ export default (): AppConfig => {
     redmineEccm: redmineEccm,
     redmineCurrentUserRules: redmineCurrentUserRules,
     simpleKanbanBoard: simpleKanbanBoard,
+    calendarEnhancer: calendarEnhancer,
   };
 
   return appConfig;

src/configs/calendar-enhancer.config.ts

@@ -0,0 +1,23 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { parse } from 'jsonc-parser';
+
+let config: Record<string, any>;
+
+export default (): Record<string, any> => {
+  if (config) {
+    return config;
+  }
+
+  const userDefinedConfigPath =
+    process.env['ELTEX_REDMINE_HELPER_CALENDAR_ENHANCER_CONFIG_PATH'];
+  const defaultConfigPath = join('configs', 'calendar-enhancer.jsonc');
+
+  const configPath = userDefinedConfigPath || defaultConfigPath;
+
+  const rawData = readFileSync(configPath, { encoding: 'utf-8' });
+
+  config = parse(rawData);
+
+  return config;
+};

src/dashboards/widgets/issues-by-tags.widget.service.ts

@@ -12,6 +12,7 @@ import { GetValueFromObjectByKey } from '@app/event-emitter/utils/get-value-from
 import { TreeIssuesStore } from '@app/event-emitter/utils/tree-issues-store';
 import { Injectable, Logger } from '@nestjs/common';
 import nano from 'nano';
+import * as PriorityStylesEnhancerNs from '@app/event-emitter/issue-enhancers/priority-styles-enhancer';
 
 export namespace IssuesByTagsWidgetNs {
   export type Params = {
@@ -59,6 +60,7 @@ export class IssuesByTagsWidgetService
       this.timePassedHighlightEnhancer,
       this.issueUrlEnhancer,
       TagStyledEnhancerNs.CreateTagStyledEnhancerForConfig(widgetParams),
+      PriorityStylesEnhancerNs.CreatePriorityStylesEnhancer(widgetParams),
     ]);
     const grouped = store.groupByStatusWithExtraToMultipleStories((issue) => {
       if (!issue || !widgetParams.tags || !widgetParams.tags.tagsKeyName) {

src/main.ts

@@ -12,6 +12,8 @@ async function bootstrap() {
     logger: ['debug', 'error', 'warn', 'log', 'verbose'],
   });
 
+  app.enableCors();
+
   app.setBaseViewsDir(join(__dirname, '..', 'views'));
   app.setViewEngine('hbs');
 

src/models/app-config.model.ts

@@ -26,4 +26,4 @@ export type AppConfig = {
     updateItemsLimit: number;
     tagsCustomFieldName: string;
   };
-};
+} & Record<string, any>;