@urga-panel/ur-panels-core 1.0.0

package/dist/services/abstract/authServices/AuthService.js

@@ -0,0 +1,275 @@
+import { Service } from "../../../types/Service.js";
+import { RegisterServiceInfo } from "../../../types/ServiceRegisterInfo.js";
+// import bcrypt from 'bcryptjs';
+// import jwt from 'jsonwebtoken';
+const JWT_SECRET = 'gizliAnahtar'; // .env dosyasına taşıman önerilir
+const JWT_REFRESH_SECRET = 'gizliRefreshAnahtar'; // refresh için ayrı bir secret önerilir
+export class AuthService extends Service {
+    ots;
+    static serviceInfo = {
+        name: "AuthService",
+        requiredServices: ["RequestHandlerService"],
+    };
+    async onSetup(options) {
+        return { status: "success", message: "setup complete" };
+    }
+    async onStart() {
+        // Object.keys(this.pages).forEach(async tag => {
+        //     const service = this.ots.abilities.createChildService?.("ProjectPage-"+tag);
+        //     await service.start();
+        // });
+        const requestHandlerService = this.ots.usedService.RequestHandlerService();
+        // requestHandlerService.addHandler("deneme",this.loginHandler.bind(this));
+        requestHandlerService.addHandler("login", this.loginRequest.bind(this));
+        requestHandlerService.addHandler("deneme", this.deneme.bind(this), {
+            auth: true,
+            role: "guest" // Örnek olarak admin rolü
+        });
+        requestHandlerService.addHandler("getUserInfo", this.getUserInfo_REQUEST.bind(this), {
+            auth: true,
+            role: "guest" // Örnek olarak admin rolü
+        });
+        // requestHandlerService.addHandler("deneme",this.loginHandler.bind(this));
+        return { status: "success", message: "started" };
+    }
+    async onStop() {
+        return { status: "success", message: "stopped" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "destroyed" };
+    }
+    constructor(ots) {
+        super(ots);
+        this.ots = ots;
+    }
+    // protected abstract authenticateUser(username: string, password: string):
+    //     Promise<{
+    //         success: boolean; user?: {
+    //             id: number;
+    //             username: string;
+    //             password: string; // Optional password field for internal use
+    //             role?: string; // Optional role field
+    //         };
+    //     }>;
+    // Define methods specific to AuthService here
+    async loginRequest({ username, password, params, request, url }) {
+        //const { username, password } = params;
+        // Kullanıcı adı veya şifre eksikse
+        //debugger;
+        try {
+            // const formData = await request.formData();
+            // const username = formData.get('username');
+            // const password = formData.get('password');
+            //debugger;
+            if (!username || !password) {
+                return this.resposeHandler({ status: "fail", message: "Kullanıcı adı ve şifre gereklidir" });
+            }
+            const result = await this.getUserInfo({ userName: username });
+            if (result.success) {
+                let jwt;
+                if (typeof window === "undefined") {
+                    jwt = (await import("jsonwebtoken")).default;
+                }
+                let bcrypt;
+                if (typeof window === "undefined") {
+                    bcrypt = await import("bcryptjs");
+                }
+                console.log("User authenticated:", result.user);
+                const match = await bcrypt.compare(password, result.user.password);
+                if (!match) {
+                    return this.resposeHandler({ success: false });
+                }
+                const accessToken = jwt.sign({
+                    id: result.user.id,
+                    username: result.user.username,
+                    role: result.user.role,
+                    databaseId: result.user.databaseId // databaseId eklendi
+                }, JWT_SECRET, { expiresIn: '15m' });
+                // 5. Refresh Token üret
+                const refreshToken = jwt.sign({
+                    id: result.user.id,
+                    username: result.user.username,
+                    role: result.user.role,
+                    databaseId: result.user.databaseId // databaseId eklendi
+                }, JWT_REFRESH_SECRET, { expiresIn: '7d' });
+                // return { status: "success", accessToken: accessToken, 
+                //     refreshToken: refreshToken };
+                //     // ...tokenları ürettikten sonra...
+                return new Response(JSON.stringify({ status: "success", message: "valid credentials", data: { user: result.user } }), {
+                    status: 200,
+                    headers: {
+                        "Set-Cookie": `accessToken=${accessToken}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=900, refreshToken=${refreshToken}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=604800`,
+                        'Content-Type': 'application/json'
+                    }
+                });
+            }
+            return this.resposeHandler({ status: "fail", message: "Invalid credentials" });
+        }
+        catch (error) {
+            this.log.ERROR("Error during login:", error);
+            return this.resposeHandler({ status: "error", message: "An error occurred during login" });
+        }
+    }
+    async checkToken({ accessToken, refreshToken, options }) {
+        this.log.OK("Access Token:", accessToken);
+        this.log.OK("Refresh Token:", refreshToken);
+        //debugger;
+        try {
+            // 1. Access token'ı doğrula
+            let jwt;
+            if (typeof window === "undefined") {
+                jwt = (await import("jsonwebtoken")).default;
+            }
+            const decoded = jwt.verify(accessToken, JWT_SECRET);
+            const res = await this.getUserInfo({
+                userId: decoded.id,
+                userName: decoded.username,
+                userRole: decoded.role || "user" // Varsayılan rol
+            });
+            //debugger;
+            if (!res.success) {
+                return { valid: false, user: res.user };
+            }
+            // Admin ise onay ver
+            if (options?.role && res.user?.role == 'admin') {
+                return { valid: true, user: res.user };
+            }
+            //Check role here
+            if (options?.role && res.user?.role !== options.role) {
+                return { valid: false };
+            }
+            return { valid: true, user: res.user };
+        }
+        catch (err) {
+            // Access token geçersiz veya süresi dolmuşsa
+            try {
+                let jwt;
+                if (typeof window === "undefined") {
+                    jwt = (await import("jsonwebtoken")).default;
+                }
+                // 2. Refresh token'ı doğrula
+                const decodedRefresh = jwt.verify(refreshToken, JWT_REFRESH_SECRET);
+                //debugger;
+                const res = await this.getUserInfo({
+                    userId: decodedRefresh.id,
+                    userName: decodedRefresh.username,
+                    userRole: decodedRefresh.role || "user" // Varsayılan rol
+                });
+                if (!res.success) {
+                    return { valid: false };
+                }
+                //Check role here
+                // Admin ise onay ver
+                // Admin ise devam etsin
+                if (options?.role && res.user?.role === 'admin') {
+                    // admin ise role kontrolü atlanır, devam edilir
+                }
+                else if (options?.role && res.user?.role !== options.role) {
+                    return { valid: false };
+                }
+                // Refresh token geçerli, yeni access token üret
+                const newAccessToken = jwt.sign({
+                    id: decodedRefresh.id,
+                    username: decodedRefresh.username,
+                    role: decodedRefresh.role,
+                    databaseId: decodedRefresh.databaseId // databaseId eklendi
+                }, JWT_SECRET, { expiresIn: '15m' });
+                const newRefreshToken = jwt.sign({
+                    id: decodedRefresh.id,
+                    username: decodedRefresh.username,
+                    role: decodedRefresh.role,
+                    databaseId: decodedRefresh.databaseId // databaseId eklendi
+                }, JWT_REFRESH_SECRET, { expiresIn: '7d' });
+                return { valid: true, newAccessToken, newRefreshToken, user: res.user };
+            }
+            catch (refreshErr) {
+                // Refresh token da geçersiz
+                return { valid: false };
+            }
+        }
+    }
+    // async checkToken(accessToken: string, refreshToken): Promise<boolean> {
+    //     // try {
+    //     //     const decoded = jwt.verify(token, 'gizliAnahtar');
+    //     //     return !!decoded;
+    //     // } catch (error) {
+    //     //     console.error('Token verification failed:', error);
+    //     //     return false;
+    //     // }
+    // }
+    async deneme({ params, request, url }) {
+        this.log.OK("RequestHandlerService deneme", params);
+        const cookieHeader = request.headers.get('cookie');
+        const accessToken = this.getCookie(cookieHeader, 'accessToken');
+        const refreshToken = this.getCookie(cookieHeader, 'refreshToken');
+        this.log.OK("Access Token:", accessToken);
+        this.log.OK("Refresh Token:", refreshToken);
+        return this.resposeHandler({ status: "success", message: "Deneme successful" });
+    }
+    async getUserInfo_REQUEST({ params, request, url, user }) {
+        this.log.OK("RequestHandlerService deneme", params);
+        //debugger;
+        // const cookieHeader = request.headers.get('cookie');
+        // const accessToken = this.getCookie(cookieHeader, 'accessToken');
+        // const refreshToken = this.getCookie(cookieHeader, 'refreshToken');
+        // this.log.OK("Access Token:", accessToken);
+        // this.log.OK("Refresh Token:", refreshToken);
+        //const result = await this.getUserInfo({userName:username});
+        //debugger;
+        return this.resposeHandler({
+            status: "success",
+            message: "getUserInfo_REQUEST successful",
+            data: {
+                user: {
+                    id: user?.id || null,
+                    username: user?.username || null,
+                    role: user?.role || null,
+                    databaseId: user?.databaseId || null // databaseId eklendi
+                }
+            }
+        });
+    }
+    resposeHandler(response) {
+        if (response.status === "success") {
+            return new Response(JSON.stringify(response), {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        return new Response(JSON.stringify(response), {
+            status: 400,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+    getCookie(cookieHeader, name) {
+        if (!cookieHeader)
+            return undefined;
+        const cookies = cookieHeader.split(';').map(c => c.trim());
+        for (const cookie of cookies) {
+            const [key, ...val] = cookie.split('=');
+            if (key === name)
+                return val.join('=');
+        }
+        return undefined;
+    }
+    async logout() {
+        await this.clearToken();
+    }
+    async register(username, password) {
+        // Implement registration logic (platform-specific)
+        // You may want to add an abstract method for registration as well
+        return true; // Placeholder
+    }
+}
+export const registerServiceInfo = new RegisterServiceInfo({
+    serviceName: "RequestHandlerService",
+    tag: "RequestHandlerService",
+    dynamicTag: false,
+    requiredServices: [],
+    isAbstract: true,
+    abstractService: AuthService,
+});

package/dist/services/abstract/extensionServices/ExtensionService.d.ts

@@ -0,0 +1,25 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+export type ExtensionOts = ServiceOts & {
+    usedService: {};
+};
+export declare abstract class ExtensionService extends Service {
+    constructor(ots: ExtensionOts);
+    abstract extensionInfo: {
+        showLeftMenu: boolean;
+        name: string;
+        showName: string;
+        icon: string;
+        slug: string;
+        description: string;
+        version: string;
+    };
+    abstract svelteComponent: any;
+    protected abstract onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected abstract onStart(): Promise<ServiceResponse>;
+    protected abstract onStop(): Promise<ServiceResponse>;
+    protected abstract onDestroy(): Promise<ServiceResponse>;
+    denemeYazi(): string;
+}

package/dist/services/abstract/extensionServices/ExtensionService.js

@@ -0,0 +1,21 @@
+import { Service } from "../../../types/Service.js";
+export class ExtensionService extends Service {
+    constructor(ots) {
+        super({ ...ots });
+    }
+    // protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+    //     return { status: "success", message: "setup complete" };
+    // }
+    // protected async onStart(): Promise<ServiceResponse> {
+    //     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" };
+    // }
+    denemeYazi() {
+        return "deneme";
+    }
+}

package/dist/services/abstract/pageServices/LayoutPageService.d.ts

@@ -0,0 +1,17 @@
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { PageService } from "./PageServices.js";
+export type RightMenuItem = {
+    icon: string;
+    label: string;
+    action: () => void;
+};
+export type LayoutOts = ServiceOts & {
+    usedService: {};
+};
+export declare class LayoutPageService extends PageService {
+    rightMenuItem: RightMenuItem[];
+    s_onMount?: () => Promise<void>;
+    s_onDestroy?: () => Promise<void>;
+    constructor(ots: LayoutOts);
+    denemeYazi(): string;
+}

package/dist/services/abstract/pageServices/LayoutPageService.js

@@ -0,0 +1,32 @@
+import { PageService } from "./PageServices.js";
+export class LayoutPageService extends PageService {
+    rightMenuItem;
+    // svelte_onMount?: () => void;
+    // svelte_onDestroy?: () => void;
+    s_onMount;
+    s_onDestroy;
+    constructor(ots) {
+        super({ ...ots });
+    }
+    /*
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+        super.onSetup(options);
+        return { status: "success", message: "LayoutService setup complete" };
+    }
+
+    protected async onStart(): Promise<ServiceResponse> {
+        super.onStart();
+        return { status: "success", message: "LayoutService started" };
+    }
+
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "LayoutService stopped" };
+    }
+
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "LayoutService destroyed" };
+    }*/
+    denemeYazi() {
+        return "deneme";
+    }
+}

package/dist/services/abstract/pageServices/PageServices.d.ts

@@ -0,0 +1,20 @@
+import { Service } from "../../../types/Service.js";
+import { ServiceOts } from "../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions.js";
+export type PageOts = ServiceOts & {
+    usedService: {};
+};
+export declare class PageService extends Service {
+    serviceInfo: {
+        name: string;
+        requiredServices: string[];
+    };
+    svelteComponent: any;
+    constructor(ots: PageOts);
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    denemeYazi(): string;
+}

package/dist/services/abstract/pageServices/PageServices.js

@@ -0,0 +1,23 @@
+import { Service } from "../../../types/Service.js";
+export class PageService extends Service {
+    serviceInfo;
+    svelteComponent; // Optional Svelte component reference
+    constructor(ots) {
+        super({ ...ots });
+    }
+    async onSetup(options) {
+        return { status: "success", message: "setup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "started" };
+    }
+    async onStop() {
+        return { status: "success", message: "stopped" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "destroyed" };
+    }
+    denemeYazi() {
+        return "deneme";
+    }
+}

package/dist/services/abstract/pageServices/controllers/NSPageControllerService.d.ts

@@ -0,0 +1,10 @@
+import { NSPageService } from "../pages/NsPageService.js";
+import { PageControllerService } from "./PageControllerService.js";
+export declare class NSPageControllerService extends PageControllerService {
+    serviceInfo: {
+        name: string;
+        requiredServices: string[];
+    };
+    registerPage(tag: string, opt: object): NSPageService;
+    onLoaded(): void;
+}

package/dist/services/abstract/pageServices/controllers/NSPageControllerService.js

@@ -0,0 +1,18 @@
+import { PageControllerService } from "./PageControllerService.js";
+export class NSPageControllerService extends PageControllerService {
+    serviceInfo;
+    registerPage(tag, opt) {
+        console.log(`Registering page with tag: ${tag}`);
+        const service = this.ots.abilities.createChildService?.(tag);
+        // await service.setup();
+        this.pages[tag] = {
+            status: "setup",
+            service: service
+        };
+        return service;
+    }
+    onLoaded() {
+        console.log("NSPageControllerService onLoaded called");
+        // Implement any additional logic needed when the page is loaded
+    }
+}

package/dist/services/abstract/pageServices/controllers/PageControllerService.d.ts

@@ -0,0 +1,27 @@
+import { Service } from "../../../../types/Service.js";
+import { ServiceOts } from "../../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../../types/ServiceSetupOptions.js";
+import { PageService } from "../PageServices.js";
+export type PageControllerOts = ServiceOts & {
+    usedService: {};
+    abilities?: {
+        createChildService?: (tag: string) => any;
+    };
+};
+export declare abstract class PageControllerService extends Service {
+    ots: PageControllerOts;
+    abstract registerPage(tag: string, opt: object): any;
+    pages: {
+        [key: string]: {
+            service: PageService;
+            status: "setup" | "started" | "stopped" | "destroyed";
+        };
+    };
+    constructor(ots: PageControllerOts);
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    denemeYazi(): string;
+}

package/dist/services/abstract/pageServices/controllers/PageControllerService.js

@@ -0,0 +1,24 @@
+import { Service } from "../../../../types/Service.js";
+export class PageControllerService extends Service {
+    ots;
+    pages = {};
+    constructor(ots) {
+        super({ ...ots });
+        this.ots = ots;
+    }
+    async onSetup(options) {
+        return { status: "success", message: "setup complete" };
+    }
+    async onStart() {
+        return { status: "success", message: "started" };
+    }
+    async onStop() {
+        return { status: "success", message: "stopped" };
+    }
+    async onDestroy() {
+        return { status: "success", message: "destroyed" };
+    }
+    denemeYazi() {
+        return "deneme";
+    }
+}

package/dist/services/abstract/pageServices/controllers/SVPageControllerService.d.ts

@@ -0,0 +1,34 @@
+import { PageControllerService } from "./PageControllerService.js";
+import { PageService } from "../PageServices.js";
+export type SveltePageProp = {
+    onMount: (callback: () => Promise<void>) => void;
+    onDestroy: (callback: () => Promise<void>) => void;
+};
+export declare class SVPageControllerService extends PageControllerService {
+    ots: any;
+    serviceInfo: {
+        name: string;
+        type: string;
+        requiredServices: any[];
+        description: string;
+        version: string;
+    };
+    registerPage(tag: string, opt: object): void;
+    pageServices: {
+        [key: string]: any;
+    };
+    constructor(ots: any);
+    createPageService(tag: string, callback: (service: PageService, obj?: {
+        params: any;
+        url: any;
+    }) => Promise<any>, options?: {
+        slug?: boolean;
+    }): ({ params, url }: {
+        params: any;
+        url: any;
+    }) => Promise<any>;
+    mountPageService(tag: string, page: SveltePageProp, options?: {
+        onMount?: () => Promise<void>;
+        onDestroy?: () => Promise<void>;
+    }): PageService;
+}

package/dist/services/abstract/pageServices/controllers/SVPageControllerService.js

@@ -0,0 +1,73 @@
+import { PageControllerService } from "./PageControllerService.js";
+export class SVPageControllerService extends PageControllerService {
+    ots;
+    serviceInfo = {
+        name: "SVPageControllerService",
+        type: "SVPageControllerService",
+        requiredServices: [],
+        description: "Service for handling Svelte page operations",
+        version: "1.0.0",
+    };
+    registerPage(tag, opt) {
+        throw new Error("Method not implemented.");
+    }
+    pageServices = {};
+    constructor(ots) {
+        super({ ...ots });
+        this.ots = ots;
+    }
+    createPageService(tag, callback, options) {
+        const $this = this;
+        return async ({ params, url }) => {
+            const slug = params.slug;
+            const device = params.device;
+            let tagWithSlug = tag;
+            if (options?.slug) {
+                tagWithSlug = `${tag}-${slug}`;
+            }
+            //console.warn("Slug:", slug,"tag:", tagWithSlug, "url:", url);
+            //console.warn('device:', device, 'params:', params);
+            let service = $this.pageServices[tagWithSlug];
+            if (service == undefined) {
+                service = this.ots.abilities.createChildService?.(tagWithSlug);
+                await service.setup();
+            }
+            $this.pageServices[tagWithSlug] = service;
+            //console.log("Available services:", Object.keys(this.pageServices));
+            const res = await callback(service, { params, url });
+            return {
+                ...res,
+                device: device,
+            };
+        };
+    }
+    mountPageService(tag, page, options) {
+        let key = tag;
+        const $this = this;
+        console.log("Available services:", Object.keys(this.pageServices));
+        const service = this.pageServices[key];
+        this.log.OK("Mounting page service for tag:", tag, "Service:", service);
+        page.onMount(async () => {
+            this.log.OK("PageService", "onMount", key);
+            console.log("Available services:", Object.keys($this.pageServices));
+            await service.start();
+            if (options?.onMount) {
+                await options.onMount();
+            }
+            // await service.start();
+            // if(options?.onMount){
+            //     await options.onMount();
+            // }
+            // (this.pageServices["MainLayoutService"] as MainLayoutService).loading = false;
+            // (this.pageServices["MainLayoutService"] as MainLayoutService).mobileMenuOpen = false;
+        });
+        page.onDestroy(async () => {
+            this.log.OK("PageService", "onDestroy", key);
+            await service.stop();
+            if (options?.onDestroy) {
+                await options.onDestroy();
+            }
+        });
+        return service;
+    }
+}

package/dist/services/abstract/pageServices/pages/NsPageService.d.ts

@@ -0,0 +1,26 @@
+import { Service } from "../../../../types/Service.js";
+import { ServiceOts } from "../../../../types/ServiceOts.js";
+import { ServiceResponse } from "../../../../types/ServiceResponse.js";
+import { ServiceSetupOptions } from "../../../../types/ServiceSetupOptions.js";
+export type PageOts = ServiceOts & {
+    usedService: {};
+};
+export declare class NSPageService extends Service {
+    serviceInfo: {
+        name: string;
+        requiredServices: string[];
+    };
+    model: any;
+    page: any;
+    constructor(ots: PageOts);
+    protected onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse>;
+    protected onStart(): Promise<ServiceResponse>;
+    protected onStop(): Promise<ServiceResponse>;
+    protected onDestroy(): Promise<ServiceResponse>;
+    navigatingTo(callback: (args?: any) => void, model: any, args?: any): void;
+    navigatedTo(callback: (args?: any) => void, args?: any): void;
+    onLoaded(callback: (args?: any) => void, args?: any): void;
+    onUnloaded(callback: (args?: any) => void, args?: any): void;
+    navigatingFrom(callback: (args?: any) => void, args?: any): void;
+    navigatedFrom(callback: (args?: any) => void, args?: any): void;
+}