@urga-panel/ur-panels-core 1.0.0

package/src/services/abstract/pageServices/pages/NSPageService.ts

@@ -0,0 +1,82 @@
+import { Service } from "../../../../types/Service";
+import { ServiceOts } from "../../../../types/ServiceOts";
+import { ServiceResponse } from "../../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../../types/ServiceSetupOptions";
+
+export type PageOts = ServiceOts & {
+    usedService: {
+    }
+}
+
+export class NSPageService extends Service {
+    serviceInfo: { name: string; requiredServices: string[]; };
+
+    model: any;
+    page: any;
+
+    constructor(ots: PageOts) {
+        super({ ...ots });
+    }
+
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        this.log.OK("onSetup called", options);
+        return { status: "success", message: "setup complete" };
+    }
+
+    protected async onStart(): Promise<ServiceResponse> {
+        this.log.OK("onStart called");
+        return { status: "success", message: "started" };
+    }
+
+    protected async onStop(): Promise<ServiceResponse> {
+        this.log.OK("onStop called");
+        return { status: "success", message: "stopped" };
+    }
+
+    protected async onDestroy(): Promise<ServiceResponse> {
+        this.log.OK("onDestroy called");
+        return { status: "success", message: "destroyed" };
+    }
+
+    navigatingTo(callback: (args?: any) => void,
+        model:any ,args?: any) {
+        this.log.OK("navigatingTo called");
+        if (callback) callback(args);
+
+        if (model) {
+            this.model = model;
+            //ts-ignore
+            const page = args.object;
+            page.bindingContext = model;
+            this.page = page;
+            this.log.OK("Model set:", model);
+        } else {
+            this.log.WARN("No model provided");
+        }
+    }
+
+    navigatedTo(callback: (args?: any) => void, args?: any) {
+        this.log.OK("navigatedTo called");
+        if (callback) callback(args);
+    }
+
+    onLoaded(callback: (args?: any) => void, args?: any) {
+        this.log.OK("onLoaded called");
+        if (callback) callback(args);
+    }
+
+    onUnloaded(callback: (args?: any) => void, args?: any) {
+        this.log.OK("onUnloaded called");
+        if (callback) callback(args);
+    }
+
+    navigatingFrom(callback: (args?: any) => void, args?: any) {
+        this.log.OK("navigatingFrom called");
+        if (callback) callback(args);
+    }
+
+    navigatedFrom(callback: (args?: any) => void, args?: any) {
+        this.log.OK("navigatedFrom called");
+        if (callback) callback(args);
+    }
+}

package/src/services/abstract/project/ProjectInfoService.ts

@@ -0,0 +1,108 @@
+import { Service } from "../../../types/Service";
+import { ServiceOts } from "../../../types/ServiceOts";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions";
+import { PageService } from "../pageServices/PageServices";
+
+export type ProjectsPages = {
+    [key: string]: {
+        icon: string; // Optional icon for the page
+        title: string;
+        slug: string;
+        description: string;
+        showInMenu: boolean;
+        showInMobile: boolean;
+        order: number;
+        group?: string;
+        service?: PageService; // Optional service name for custom handling
+        serviceRef: any;
+        userGroup?: string; // Optional user group for access control
+    };
+}
+
+export type ProjectInfoOts = ServiceOts & {
+    usedService: {
+    }
+}
+
+
+export abstract class ProjectInfoService extends Service {
+
+    static serviceInfo = {
+        name: "ProjectInfoService",
+        requiredServices: [],
+    }
+
+    abstract pages: ProjectsPages;
+
+    constructor(public ots: ProjectInfoOts) {
+        super({ ...ots });
+    }
+
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        // Create a service for each page
+        Object.keys(this.pages).forEach(async tag => {
+            const service = this.ots.abilities.createChildService?.("ProjectPage-" + tag,
+                this.pages[tag].serviceRef || PageService
+            );
+            if (service) {
+                this.pages[tag].service = service as PageService;
+            }
+            await service.setup();
+        });
+        return { status: "success", message: "setup complete" };
+    }
+
+    protected async onStart(): Promise<ServiceResponse> {
+        // Object.keys(this.pages).forEach(async tag => {
+        //     const service = this.ots.abilities.createChildService?.("ProjectPage-"+tag);
+        //     await service.start();
+        // });
+        return { status: "success", message: "started" };
+    }
+
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "stopped" };
+    }
+
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "destroyed" };
+    }
+
+    getMenuPages(userGroup?: string): { [key: string]: ProjectsPages[string] } {
+        const result: { [key: string]: ProjectsPages[string] } = {};
+        Object.entries(this.pages).forEach(([key, page]) => {
+            if (page.showInMenu) {
+                if (userGroup && userGroup == 'admin') {
+                    result[key] = page;
+                }
+                else {
+                    if (userGroup) {
+                        // Check if the page is accessible by the user group
+                        if (page.userGroup === userGroup) {
+                            result[key] = page;
+                        }
+                    } else {
+                        result[key] = page;
+                    }
+                }
+
+            }
+        });
+        return result;
+    }
+
+    getMobilePages(limit: number = 4): { [key: string]: ProjectsPages[string] } {
+        const result: { [key: string]: ProjectsPages[string] } = {};
+        let count = 0;
+        for (const [key, page] of Object.entries(this.pages)) {
+            if (page.showInMobile) {
+                result[key] = page;
+                count++;
+                if (count >= limit) break;
+            }
+        }
+        return result;
+    }
+
+}

package/src/services/abstract/webviewServices/WVBackService.ts

@@ -0,0 +1,34 @@
+import { Service } from "../../../types/Service";
+import { ServiceOts } from "../../../types/ServiceOts";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions";
+
+export type WVBackServiceOts = ServiceOts & {
+    usedService: {
+    }
+}
+
+export class WVBackService extends Service {
+    static serviceInfo = {
+        name: "WVBackService",
+        requiredServices: [],
+    }
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        
+        return { status: "success", message: "onSetup complete" };
+    }
+    protected async onStart(): Promise<ServiceResponse> {
+        return { status: "success", message: "onStart complete" };
+    }
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "onStop complete" };
+    }
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "onDestroy complete" };
+    }
+    constructor(ots: WVBackServiceOts) {
+        super({ ...ots });
+    }
+
+}
+

package/src/services/abstract/webviewServices/WVFrontService.ts

@@ -0,0 +1,71 @@
+import { Service } from "../../../types/Service";
+import { ServiceOts } from "../../../types/ServiceOts";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions";
+import { NSWebViewinterface } from "./nv";
+export type WVFrontServiceOts = ServiceOts & {
+    usedService: {
+    }
+}
+
+export class WVFrontService extends Service {
+    static serviceInfo = {
+        name: "WVFrontService",
+        requiredServices: [],
+    }
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+
+        this.oWebViewInterface = new NSWebViewinterface();
+        //@ts-ignore
+        window.nsWebViewInterface = this.oWebViewInterface;
+        this.oWebViewInterface.emit("loadFinished", "");
+
+        return { status: "success", message: "onSetup complete" };
+    }
+    protected async onStart(): Promise<ServiceResponse> {
+        return { status: "success", message: "onStart complete" };
+    }
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "onStop complete" };
+    }
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "onDestroy complete" };
+    }
+    public oWebViewInterface: NSWebViewinterface;
+
+    constructor(ots: WVFrontServiceOts) {
+        super({ ...ots });
+
+    }
+
+    public async sendFetchRequest(url: string, options?: RequestInit): Promise<any> {
+        console.log("sendFetchRequest", url, options);
+
+        return new Promise((resolve) => {
+            const callback = (args: any) => {
+                const param = args as unknown;
+                // Convert param to a Response object
+                debugger;
+                   //@ts-ignore
+                const byteArray = Object.values(param._bodyBlob._buffer);
+                //@ts-ignore
+                const uint8 = new Uint8Array(byteArray);
+                 //@ts-ignore
+                const text = new TextDecoder().decode(uint8);
+                const response = new Response(text,                    
+                    {
+                        status: 200,
+                        headers: { "Content-Type": "application/json" }
+                    }
+                );
+                debugger;
+                console.log("sendFetchRequest received", param);
+                this.oWebViewInterface.removeListener('sendFetchRequest', callback);
+                resolve(response);
+            };
+            this.oWebViewInterface.on('sendFetchRequest', callback);
+            this.oWebViewInterface.emit("sendFetchRequest", { url, options });
+        });
+    }
+
+}

package/src/services/abstract/webviewServices/nv.js

@@ -0,0 +1,112 @@
+class NSWebViewinterface {
+    constructor() {
+        this.eventListenerMap = {};
+        this._iosResponseMap = {};
+        this._iosCntResponseId = 0;
+    }
+    
+    _onNativeEvent(eventName, data) {
+        var lstEvtListeners = this.eventListenerMap[eventName] || [];
+        for (var _i = 0; _i < lstEvtListeners.length; _i++) {
+            var listener = lstEvtListeners[_i];
+            var retnVal = listener && listener(data);
+            if (retnVal === false) {
+                break;
+            }
+        }
+    }
+
+    _callJSFunction(reqId, functionName, args) {
+        var _this = this;
+        var resolvedFn = _this._getResolvedFunction(functionName);
+        if(resolvedFn){
+            var retnVal = resolvedFn.apply(window, args);
+            if (retnVal && retnVal.then) {
+                retnVal.then(function (value) {
+                    _this._sendJSCallResponse(reqId, value);
+                }, function(error){
+                    _this._sendJSCallResponse(reqId, error, true);
+                });
+            }
+            else {
+                this._sendJSCallResponse(reqId, retnVal);
+            }
+        }
+    }
+
+    _getResolvedFunction(functionName) {
+        if(functionName && (functionName = functionName.trim()).length){
+            functionName = functionName.indexOf('window.') === 0 ? functionName.replace('window.', '') : functionName;
+            var arrFnPath = functionName.split('.');
+            var fn = window;
+            for(var i = 0; i < arrFnPath.length; i++){
+                if(!fn[arrFnPath[i]]){
+                    fn = null;
+                    break;
+                }
+                fn = fn[arrFnPath[i]]; 
+            }
+            return fn;
+        }
+    }
+
+    _sendJSCallResponse(reqId, response, isError) {
+        var oResponse = {
+            reqId: reqId,
+            response: response || null,
+            isError: !!isError
+        };
+        this.emit('_jsCallResponse', oResponse);
+    }
+
+    _createIFrame(src) {
+        var rootElm = document.documentElement;
+        var newFrameElm = document.createElement("IFRAME");
+        newFrameElm.setAttribute("src", src);
+        rootElm.appendChild(newFrameElm);
+        return newFrameElm;
+    }
+
+    _emitEventToIOS(eventName, data) {
+        this._iosResponseMap[++this._iosCntResponseId] = data;
+        var metadata = { eventName: eventName, resId: this._iosCntResponseId };
+        var url = 'js2ios:' + JSON.stringify(metadata);
+        var iFrame = this._createIFrame(url);
+        iFrame.parentNode.removeChild(iFrame);
+    }
+
+    _getIOSResponse(resId) {
+        var response = this._iosResponseMap[resId];
+        delete this._iosResponseMap[resId];
+        return response;
+    }
+
+    _emitEventToAndroid(eventName, data) {
+        window.androidWebViewInterface.handleEventFromWebView(eventName, data);
+    }
+
+    on(eventName, callback) {
+        var lstListeners = this.eventListenerMap[eventName] || (this.eventListenerMap[eventName] = []);
+        lstListeners.push(callback);
+    }
+    removeListener(eventName, callback) {
+        const listeners = this.eventListenerMap[eventName];
+        if (listeners) {
+            // Belirtilen geri çağırma işlevini kaldır
+            this.eventListenerMap[eventName] = listeners.filter(listener => listener !== callback);
+        }
+    }
+
+    emit(eventName, data) {
+        var strData = typeof data === 'object' ? JSON.stringify(data) : data;
+        if (window.androidWebViewInterface) {
+            this._emitEventToAndroid(eventName, strData);
+        }
+        else {
+            this._emitEventToIOS(eventName, strData);
+        }
+    }
+}
+
+// NSWebViewinterface'i dışa aktar
+export { NSWebViewinterface };

package/src/services/abstract/webviewServices/nv.ts

@@ -0,0 +1,125 @@
+type EventCallback = (data: any) => any;
+
+declare global {
+    interface Window {
+        androidWebViewInterface?: {
+            handleEventFromWebView: (eventName: string, data: any) => void;
+        };
+    }
+}
+
+class NSWebViewinterface {
+    private eventListenerMap: { [eventName: string]: EventCallback[] };
+    private _iosResponseMap: { [resId: number]: any };
+    private _iosCntResponseId: number;
+
+    constructor() {
+        this.eventListenerMap = {};
+        this._iosResponseMap = {};
+        this._iosCntResponseId = 0;
+    }
+    
+    private _onNativeEvent(eventName: string, data: any): void {
+        const lstEvtListeners = this.eventListenerMap[eventName] || [];
+        for (let _i = 0; _i < lstEvtListeners.length; _i++) {
+            const listener = lstEvtListeners[_i];
+            const retnVal = listener && listener(data);
+            if (retnVal === false) {
+                break;
+            }
+        }
+    }
+
+    private _callJSFunction(reqId: number, functionName: string, args: any[]): void {
+        const resolvedFn = this._getResolvedFunction(functionName);
+        if(resolvedFn){
+            const retnVal = resolvedFn.apply(window, args);
+            if (retnVal && retnVal.then) {
+                retnVal.then(
+                    (value: any) => this._sendJSCallResponse(reqId, value),
+                    (error: any) => this._sendJSCallResponse(reqId, error, true)
+                );
+            }
+            else {
+                this._sendJSCallResponse(reqId, retnVal);
+            }
+        }
+    }
+
+    private _getResolvedFunction(functionName: string): Function | null {
+        if(functionName && (functionName = functionName.trim()).length){
+            functionName = functionName.indexOf('window.') === 0 ? functionName.replace('window.', '') : functionName;
+            const arrFnPath = functionName.split('.');
+            let fn: any = window;
+            for(let i = 0; i < arrFnPath.length; i++){
+                if(!fn[arrFnPath[i]]){
+                    fn = null;
+                    break;
+                }
+                fn = fn[arrFnPath[i]]; 
+            }
+            return typeof fn === 'function' ? fn : null;
+        }
+        return null;
+    }
+
+    private _sendJSCallResponse(reqId: number, response: any, isError?: boolean): void {
+        const oResponse = {
+            reqId: reqId,
+            response: response ?? null,
+            isError: !!isError
+        };
+        this.emit('_jsCallResponse', oResponse);
+    }
+
+    private _createIFrame(src: string): HTMLIFrameElement {
+        const rootElm = document.documentElement;
+        const newFrameElm = document.createElement("IFRAME") as HTMLIFrameElement;
+        newFrameElm.setAttribute("src", src);
+        rootElm.appendChild(newFrameElm);
+        return newFrameElm;
+    }
+
+    private _emitEventToIOS(eventName: string, data: any): void {
+        this._iosResponseMap[++this._iosCntResponseId] = data;
+        const metadata = { eventName: eventName, resId: this._iosCntResponseId };
+        const url = 'js2ios:' + JSON.stringify(metadata);
+        const iFrame = this._createIFrame(url);
+        iFrame.parentNode?.removeChild(iFrame);
+    }
+
+    private _getIOSResponse(resId: number): any {
+        const response = this._iosResponseMap[resId];
+        delete this._iosResponseMap[resId];
+        return response;
+    }
+
+    private _emitEventToAndroid(eventName: string, data: any): void {
+        window.androidWebViewInterface?.handleEventFromWebView(eventName, data);
+    }
+
+    public on(eventName: string, callback: EventCallback): void {
+        const lstListeners = this.eventListenerMap[eventName] || (this.eventListenerMap[eventName] = []);
+        lstListeners.push(callback);
+    }
+
+    public removeListener(eventName: string, callback: EventCallback): void {
+        const listeners = this.eventListenerMap[eventName];
+        if (listeners) {
+            // Belirtilen geri çağırma işlevini kaldır
+            this.eventListenerMap[eventName] = listeners.filter(listener => listener !== callback);
+        }
+    }
+
+    public emit(eventName: string, data: any): void {
+        const strData = typeof data === 'object' ? JSON.stringify(data) : data;
+        if (window.androidWebViewInterface) {
+            this._emitEventToAndroid(eventName, strData);
+        }
+        else {
+            this._emitEventToIOS(eventName, strData);
+        }
+    }
+}
+
+export { NSWebViewinterface };

package/src/services/main/fetchServices/FetchBrowserService.ts

@@ -0,0 +1,40 @@
+import { Service } from "../../../types/Service";
+import { ServiceOts } from "../../../types/ServiceOts";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions";
+
+export type FetchBrowserServiceOts = ServiceOts & {
+    usedService: {
+    }
+}
+
+export class FetchBrowserService extends Service {
+    static serviceInfo = {
+        name: "FetchBrowserService",
+        requiredServices: [],
+    }
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        
+        return { status: "success", message: "onSetup complete" };
+    }
+    protected async onStart(): Promise<ServiceResponse> {
+        return { status: "success", message: "onStart complete" };
+    }
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "onStop complete" };
+    }
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "onDestroy complete" };
+    }
+    constructor(ots: FetchBrowserServiceOts) {
+        super({ ...ots });
+    }
+
+    public async sendFetchRequest(url: string, options?: RequestInit) {
+        const response = await fetch(url, options);
+        return response;
+    }
+
+}
+
+