aril 1.1.72 → 1.1.73

package/boot/mfe/src/monaco.config.ts

@@ -0,0 +1,266 @@
+declare const monaco: any;
+
+export const monacoConfig = {
+	baseUrl: 'assets',
+	defaultOptions: { scrollBeyondLastLine: false },
+	onMonacoLoad: () => {
+		// JSON düzenleyici ayarları
+		if (monaco && monaco.languages && monaco.languages.json) {
+			monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
+				validate: true,
+				allowComments: false,
+				schemas: []
+			});
+		}
+
+		// JavaScript/TypeScript düzenleyici ayarları
+		if (monaco && monaco.languages && monaco.languages.typescript) {
+			monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
+				target: monaco.languages.typescript.ScriptTarget.ES2016,
+				allowNonTsExtensions: true,
+				moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+				module: monaco.languages.typescript.ModuleKind.CommonJS,
+				noEmit: true,
+				typeRoots: ['node_modules/@types']
+			});
+
+			// TypeScript düzenleyici ayarları
+			monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
+				target: monaco.languages.typescript.ScriptTarget.ES2016,
+				allowNonTsExtensions: true,
+				moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+				module: monaco.languages.typescript.ModuleKind.CommonJS,
+				noEmit: true,
+				typeRoots: ['node_modules/@types']
+			});
+		}
+
+		// HTML, XML ve diğer markup dilleri için ayarlar
+		if (monaco && monaco.languages && monaco.languages.html) {
+			monaco.languages.html.htmlDefaults.setOptions({
+				format: {
+					tabSize: 2,
+					insertSpaces: true
+				},
+				suggest: {
+					html5: true
+				}
+			});
+		}
+
+		// Python için syntax highlighting ve özel formatlamalar
+		if (monaco && monaco.languages) {
+			monaco.languages.registerDocumentFormattingEditProvider('python', {
+				provideDocumentFormattingEdits: function (model: any) {
+					const text = model.getValue();
+					return [
+						{
+							range: model.getFullModelRange(),
+							text: text
+						}
+					];
+				}
+			});
+
+			// Python için özel linting kuralları
+			monaco.languages.registerCompletionItemProvider('python', {
+				provideCompletionItems: function (model: any, position: any) {
+					const suggestions = [
+						{
+							label: 'def',
+							kind: monaco.languages.CompletionItemKind.Keyword,
+							insertText: 'def ${1:function_name}(${2:parameters}):\n\t${3:pass}',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'Fonksiyon tanımlama'
+						},
+						{
+							label: 'class',
+							kind: monaco.languages.CompletionItemKind.Keyword,
+							insertText: 'class ${1:ClassName}:\n\tdef __init__(self, ${2:parameters}):\n\t\t${3:pass}',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'Sınıf tanımlama'
+						},
+						{
+							label: 'if',
+							kind: monaco.languages.CompletionItemKind.Keyword,
+							insertText: 'if ${1:condition}:\n\t${2:pass}',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'If bloğu'
+						},
+						{
+							label: 'for',
+							kind: monaco.languages.CompletionItemKind.Keyword,
+							insertText: 'for ${1:item} in ${2:iterable}:\n\t${3:pass}',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'For döngüsü'
+						}
+					];
+
+					return { suggestions: suggestions };
+				}
+			});
+		}
+
+		// Lua için özel ayarlar
+		if (monaco && monaco.languages) {
+			monaco.languages.registerDocumentFormattingEditProvider('lua', {
+				provideDocumentFormattingEdits: function (model: any) {
+					const text = model.getValue();
+					return [
+						{
+							range: model.getFullModelRange(),
+							text: text
+						}
+					];
+				}
+			});
+
+			monaco.languages.registerCompletionItemProvider('lua', {
+				provideCompletionItems: function (model: any, position: any) {
+					const suggestions = [
+						{
+							label: 'function',
+							kind: monaco.languages.CompletionItemKind.Keyword,
+							insertText: 'function ${1:name}(${2:params})\n\t${3:-- body}\nend',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'Fonksiyon tanımlama'
+						},
+						{
+							label: 'if',
+							kind: monaco.languages.CompletionItemKind.Keyword,
+							insertText: 'if ${1:condition} then\n\t${2:-- body}\nend',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'If bloğu'
+						},
+						{
+							label: 'for',
+							kind: monaco.languages.CompletionItemKind.Keyword,
+							insertText: 'for ${1:i}=${2:1},${3:10} do\n\t${4:-- body}\nend',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'For döngüsü'
+						}
+					];
+
+					return { suggestions: suggestions };
+				}
+			});
+		}
+
+		// Java için özel ayarlar
+		if (monaco && monaco.languages) {
+			monaco.languages.registerDocumentFormattingEditProvider('java', {
+				provideDocumentFormattingEdits: function (model: any) {
+					const text = model.getValue();
+					// Java formatlaması
+					return [
+						{
+							range: model.getFullModelRange(),
+							text: text // Formatlanmış metin
+						}
+					];
+				}
+			});
+
+			// Java için özel öneriler
+			monaco.languages.registerCompletionItemProvider('java', {
+				provideCompletionItems: function (model: any, position: any) {
+					const suggestions = [
+						{
+							label: 'class',
+							kind: monaco.languages.CompletionItemKind.Keyword,
+							insertText: 'public class ${1:ClassName} {\n\t${2}\n}',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'Sınıf tanımlama'
+						},
+						{
+							label: 'main',
+							kind: monaco.languages.CompletionItemKind.Snippet,
+							insertText: 'public static void main(String[] args) {\n\t${1}\n}',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'Main metodu'
+						},
+						{
+							label: 'sout',
+							kind: monaco.languages.CompletionItemKind.Snippet,
+							insertText: 'System.out.println(${1});',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'Konsola yazdırma'
+						}
+					];
+
+					return { suggestions: suggestions };
+				}
+			});
+		}
+
+		// HTML için özel ayarlar
+		if (monaco && monaco.languages) {
+			monaco.languages.registerCompletionItemProvider('html', {
+				provideCompletionItems: function (model: any, position: any) {
+					const suggestions = [
+						{
+							label: 'html5',
+							kind: monaco.languages.CompletionItemKind.Snippet,
+							insertText:
+								'<!DOCTYPE html>\n<html lang="en">\n<head>\n\t<meta charset="UTF-8">\n\t<meta name="viewport" content="width=device-width, initial-scale=1.0">\n\t<title>${1:Document}</title>\n</head>\n<body>\n\t${2}\n</body>\n</html>',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'HTML5 taslağı'
+						},
+						{
+							label: 'div',
+							kind: monaco.languages.CompletionItemKind.Snippet,
+							insertText: '<div class="${1:className}">\n\t${2}\n</div>',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'Div elementi'
+						}
+					];
+
+					return { suggestions: suggestions };
+				}
+			});
+		}
+
+		// XML için özel ayarlar
+		if (monaco && monaco.languages) {
+			monaco.languages.registerCompletionItemProvider('xml', {
+				provideCompletionItems: function (model: any, position: any) {
+					const suggestions = [
+						{
+							label: 'xml',
+							kind: monaco.languages.CompletionItemKind.Snippet,
+							insertText: '<?xml version="1.0" encoding="UTF-8"?>\n<${1:root}>\n\t${2}\n</${1:root}>',
+							insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+							documentation: 'XML taslağı'
+						}
+					];
+
+					return { suggestions: suggestions };
+				}
+			});
+		}
+
+		// JSON için özel ayarlar ve şema doğrulama
+		if (monaco && monaco.languages && monaco.languages.json) {
+			monaco.languages.json.jsonDefaults.setDiagnosticsOptions({
+				validate: true,
+				allowComments: false,
+				schemas: [
+					{
+						uri: 'http://myserver/schema/package.schema.json',
+						fileMatch: ['package.json'],
+						schema: {
+							type: 'object',
+							properties: {
+								name: { type: 'string' },
+								version: { type: 'string' },
+								dependencies: {
+									type: 'object'
+								}
+							}
+						}
+					}
+				]
+			});
+		}
+	}
+};

package/boot/ng-package.json

@@ -0,0 +1,6 @@
+{
+	"$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+	"lib": {
+		"entryFile": "./index.ts"
+	}
+}

package/http/index.ts

@@ -0,0 +1,13 @@
+/* lib */
+export * from './lib/enums';
+export * from './lib/interfaces';
+
+/* src */
+export * from './src/httpBackend';
+export * from './src/httpClient';
+export * from './src/serviceBase';
+export * from './src/serviceMockBase';
+export * from './src/serviceStateMethods';
+
+/* interceptor */
+export * from './src/interceptor/accept-language.interceptor';

package/http/lib/enums.ts

@@ -0,0 +1,31 @@
+export enum HTTPMethods {
+	GET = 'GET',
+	GETBYPARAMS = 'GETBYPARAMS',
+	GETBYDYNAMICPATH = 'GETBYDYNAMICPATH',
+	GETBYPARAMSANDDYNAMICPATH = 'GETBYPARAMSANDDYNAMICPATH',
+	POST = 'POST',
+	POSTBYPARAMS = 'POSTBYPARAMS',
+	POSTBYDYNAMICPATH = 'POSTBYDYNAMICPATH',
+	PUT = 'PUT',
+	PUTBYPARAMS = 'PUTBYPARAMS',
+	PUTBYDYNAMICPATH = 'PUTBYDYNAMICPATH',
+	DELETE = 'DELETE',
+	DELETEBYPARAMS = 'DELETEBYPARAMS',
+	DELETEBYDYNAMICPATH = 'DELETEBYDYNAMICPATH'
+}
+export enum ProxyTypes {
+	Native,
+	ServerSide,
+	ClientSide
+}
+export enum HTTPStatusCodes {
+	OK = 200,
+	CREATED = 201,
+	ACCEPTED = 202,
+	NO_CONTENT = 204,
+	BAD_REQUEST = 400,
+	UNAUTHORIZED = 401,
+	FORBIDDEN = 403,
+	NOT_FOUND = 404,
+	INTERNAL_SERVER_ERROR = 500
+}

package/http/lib/interfaces.ts

@@ -0,0 +1,46 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/* eslint-disable @typescript-eslint/ban-types */
+import { HttpErrorResponse } from '@angular/common/http';
+
+import { ProxyTypes } from './enums';
+
+export interface ServiceCallStates {
+	serviceCalled: boolean;
+	waitingForResponse: boolean;
+	responseIsRecieved: boolean;
+	serviceCallFailed: boolean;
+}
+
+export type ServiceCallStateMap<T> = {
+	[K in keyof T]?: T[K] extends Function ? ServiceCallStates : never;
+};
+
+export class ErrorResponse {
+	error: HttpErrorResponse | undefined;
+
+	constructor(err: HttpErrorResponse | undefined) {
+		this.error = err;
+	}
+}
+
+export class ServiceResponse<T> extends ErrorResponse {
+	request: any;
+	response: T;
+	proxy: ProxyTypes;
+	statusCode?: number;
+
+	constructor(request: any, response: T, proxy: ProxyTypes, statusCode?: number) {
+		super(undefined);
+		this.request = request;
+		this.response = response;
+		this.proxy = proxy;
+		this.statusCode = statusCode;
+	}
+}
+
+export interface ErrorDetail {
+	fieldName: string;
+	reason: string;
+	description: string;
+}

package/http/ng-package.json

@@ -0,0 +1,6 @@
+{
+	"$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+	"lib": {
+		"entryFile": "./index.ts"
+	}
+}

package/http/src/httpBackend.ts

@@ -0,0 +1,12 @@
+import { HttpBackend, HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+
+// WithoutInterceptorHttpClient
+@Injectable({ providedIn: 'root' })
+export class HttpBackendService {
+	public httpClient: HttpClient;
+
+	constructor(handler: HttpBackend) {
+		this.httpClient = new HttpClient(handler);
+	}
+}

package/http/src/httpClient.ts

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpClient } from '@angular/common/http';
+import { Injector, inject } from '@angular/core';
+
+import { MessageService } from 'primeng/api';
+
+import { TranslocoService } from '@ngneat/transloco';
+import { KeycloakService } from 'keycloak-angular';
+
+import { ServiceCallStateMap } from '../lib/interfaces';
+
+export abstract class RestClient {
+	private readonly httpClient = inject(HttpClient);
+	private readonly injector = inject(Injector);
+	private readonly messageService = inject(MessageService);
+	private readonly translocoService = inject(TranslocoService);
+	private readonly keycloak = inject(KeycloakService);
+
+	abstract states: ServiceCallStateMap<any>;
+}

package/http/src/interceptor/accept-language.interceptor.ts

@@ -0,0 +1,32 @@
+import { HttpHandlerFn, HttpInterceptorFn, HttpRequest } from '@angular/common/http';
+import { inject } from '@angular/core';
+import { TranslocoService } from '@ngneat/transloco';
+
+const DEFAULT_LANGUAGE = 'tr' as const;
+const STORAGE_KEY = 'lang' as const;
+
+const resolveLanguage = (translocoService: TranslocoService | null): string => {
+  return (
+    translocoService?.getActiveLang?.() ||
+    localStorage.getItem(STORAGE_KEY) ||
+    translocoService?.getDefaultLang?.() ||
+    DEFAULT_LANGUAGE
+  );
+};
+
+export const acceptLanguageInterceptor: HttpInterceptorFn = (
+  req: HttpRequest<unknown>,
+  next: HttpHandlerFn
+) => {
+  const translocoService = inject(TranslocoService, { optional: true }) ?? null;
+  const language = resolveLanguage(translocoService);
+
+  const updatedReq = req.clone({
+    setHeaders: {
+      'Accept-Language': language
+    }
+  });
+
+  return next(updatedReq);
+};
+

package/http/src/serviceBase.ts

@@ -0,0 +1,175 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpClient, HttpErrorResponse, HttpParams, HttpStatusCode } from '@angular/common/http';
+import { runInInjectionContext } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+
+import { Observable, of } from 'rxjs';
+import { catchError, map, tap } from 'rxjs/operators';
+
+import { API_CONFIGS } from 'aril/boot/config/api';
+import { Apps } from 'aril/boot/config/apps';
+
+import { HTTPMethods, HTTPStatusCodes, ProxyTypes } from '../lib/enums';
+import { ErrorResponse, ServiceCallStateMap, ServiceResponse } from '../lib/interfaces';
+import { getRequest } from './serviceRequest';
+import { callState, errorState, successState, warningState } from './serviceStateMethods';
+
+export function ServiceCall(
+	httpMethod: HTTPMethods,
+	proxy: ProxyTypes,
+	serviceURL: string,
+	message?: { success?: string; error?: string; ignoredStatusCodes?: HttpStatusCode[] },
+	remoteAPI?: Apps,
+	isMockAPI = false
+): MethodDecorator {
+	return function (serviceClass: object, serviceName: string | symbol, descriptor: PropertyDescriptor) {
+		// const originalFunction = descriptor.value;
+
+		descriptor.value = function (...args: any[]) {
+			return runInInjectionContext((<any>this).injector, () => {
+				const httpClient: HttpClient = (<any>this).httpClient;
+
+				let api = '';
+				if (isMockAPI) api = <string>remoteAPI;
+				else if (remoteAPI) {
+					const url = new URL(API_CONFIGS.api);
+					api = url.origin + '/' + API_CONFIGS.prefixMap[remoteAPI];
+				} else api = API_CONFIGS.api;
+
+				const endPoint = api + '/' + serviceURL;
+				const request = getRequest(httpMethod, args);
+				const states: ServiceCallStateMap<any> = (<any>this).states;
+
+				callState(states, serviceName);
+
+				let observable: Observable<any> = new Observable<any>();
+				let getDynamicServiceUrl: string;
+
+				switch (httpMethod) {
+					case HTTPMethods.GET:
+						let getReq = args.length ? '/' + args[0] : '';
+						observable = httpClient.get<any>(endPoint + getReq, {observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.GETBYPARAMS:
+						observable = httpClient.get<any>(endPoint, { params: request as HttpParams, observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.GETBYDYNAMICPATH:
+						getDynamicServiceUrl = serviceURL;
+						args.forEach((arg) => {
+							getDynamicServiceUrl = getDynamicServiceUrl.replace('$', arg);
+						});
+						observable = httpClient.get<any>(api + '/' + getDynamicServiceUrl, {observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.GETBYPARAMSANDDYNAMICPATH:
+						let getParams = {};
+						let getDynamicServiceUrlWithParams = serviceURL;
+						
+						args.forEach((arg) => {
+							if (typeof arg === 'object') getParams = arg;
+							else getDynamicServiceUrlWithParams = getDynamicServiceUrlWithParams.replace('$', arg);
+						});
+						
+						observable = httpClient.get<any>(api + '/' + getDynamicServiceUrlWithParams, {
+							params: getParams as HttpParams,
+							observe: 'response',
+							responseType: 'json'
+						});
+						break;
+					case HTTPMethods.POST:
+						observable = httpClient.post<any>(endPoint, args[0], {observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.POSTBYPARAMS:
+						observable = httpClient.post<any>(endPoint, args[0].body, { params: request, observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.POSTBYDYNAMICPATH:
+						let body = {};
+						let dynamicServiceUrl = serviceURL;
+
+						args.forEach((arg) => {
+							if (typeof arg === 'object') body = arg;
+							else dynamicServiceUrl = dynamicServiceUrl.replace('$', arg);
+						});
+						observable = httpClient.post<any>(api + '/' + dynamicServiceUrl, body, { observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.PUT:
+						observable = httpClient.put<any>(endPoint + '/' + args[0], request, { observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.PUTBYPARAMS:
+						observable = httpClient.put<any>(endPoint, args[0], { observe: 'response', responseType: 'json' });
+						break;
+
+					case HTTPMethods.PUTBYDYNAMICPATH:
+						let putBody = {};
+						let putDynamicServiceUrl = serviceURL;
+
+						args.forEach((arg) => {
+							if (typeof arg === 'object') putBody = arg;
+							else putDynamicServiceUrl = putDynamicServiceUrl.replace('$', arg);
+						});
+						observable = httpClient.put<any>(api + '/' + putDynamicServiceUrl, putBody, {observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.DELETE:
+						observable = httpClient.delete<any>(endPoint + '/' + args[0], {observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.DELETEBYPARAMS:
+						observable = httpClient.delete<any>(endPoint, { params: request as HttpParams, observe: 'response', responseType: 'json' });
+						break;
+					case HTTPMethods.DELETEBYDYNAMICPATH:
+						let deleteParams = {};
+						let deleteDynamicServiceUrl = serviceURL;
+
+						args.forEach((arg) => {
+							if (typeof arg === 'object') deleteParams = arg;
+							else deleteDynamicServiceUrl = deleteDynamicServiceUrl.replace('$', arg);
+						});
+
+						observable = httpClient.delete<any>(api + '/' + deleteDynamicServiceUrl, {
+							params: deleteParams,
+							observe: 'response',
+							responseType: 'json'
+						});
+				}
+
+				observable = observable.pipe(
+					map((response) => new ServiceResponse(request, response?.body, proxy, response?.status)),
+					tap((serviceRes) => {
+						if (serviceRes?.statusCode === HTTPStatusCodes.NO_CONTENT) {
+							(<any>this).messageService.add({
+								key: 'toast-root',
+								severity: 'success',
+								summary: (<any>this).translocoService.translate('messages.successMessageHeader'),
+								detail: (<any>this).translocoService.translate('messages.successMessage')
+							});
+						} else if (serviceRes.response.type === 'ValidationWarningException') {
+							warningState(states, serviceName, serviceRes.response, (<any>this).messageService);
+						} else {
+							successState(
+								states,
+								serviceName,
+								(<any>this).translocoService,
+								(<any>this).messageService,
+								message,
+								serviceRes
+							);
+						}
+					}),
+					catchError((error: HttpErrorResponse) => {
+						errorState(
+							states,
+							serviceName,
+							error,
+							(<any>this).translocoService,
+							(<any>this).messageService,
+							(<any>this).keycloak,
+							message
+						);
+						return of(new ErrorResponse(error));
+					}),
+					takeUntilDestroyed()
+				);
+
+				return observable;
+			});
+		};
+	};
+}

package/http/src/serviceMockBase.ts

@@ -0,0 +1,12 @@
+import { HTTPMethods, ProxyTypes } from '../lib/enums';
+import { ServiceCall } from './serviceBase';
+
+export function ServiceCallMock(
+	httpMethod: HTTPMethods,
+	proxy: ProxyTypes,
+	serviceURL: string,
+	mockAPI: string,
+	message?: { success?: string; error?: string; useDefault: boolean }
+) {
+	// return ServiceCall(httpMethod, proxy, serviceURL, message, mockAPI, true);
+}

package/http/src/serviceRequest.ts

@@ -0,0 +1,28 @@
+import { HttpParams } from '@angular/common/http';
+
+import { Interfaces } from 'aril/util/lib';
+
+import { HTTPMethods } from '../lib/enums';
+
+export function getRequest(httpMethod: HTTPMethods, args: any[]): HttpParams | Interfaces.MapStringAny | undefined {
+	if (!args.length) return undefined;
+
+	switch (httpMethod) {
+		case HTTPMethods.PUT:
+			return args[1];
+		case HTTPMethods.POSTBYPARAMS:
+		case HTTPMethods.GETBYPARAMS:
+		case HTTPMethods.GETBYPARAMSANDDYNAMICPATH:
+		case HTTPMethods.DELETEBYPARAMS:
+			const dto = httpMethod === HTTPMethods.POSTBYPARAMS ? args[0].queryParams : args[0];
+			let queryParams = new HttpParams();
+
+			for (const [key, value] of Object.entries(dto)) {
+				queryParams = queryParams.append(key, value as any);
+			}
+
+			return queryParams;
+		default:
+			return args[0];
+	}
+}