@urga-panel/ur-panels-core 1.0.0

package/src/services/abstract/authServices/AuthService.ts

@@ -0,0 +1,364 @@
+import { Service } from "../../../types/Service";
+import { ServiceOts } from "../../../types/ServiceOts";
+import { RegisterServiceInfo } from "../../../types/ServiceRegisterInfo";
+import { ServiceResponse } from "../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../types/ServiceSetupOptions";
+import { RequestHandlerService } from "../../main/httpServices/RequestHandlerService";
+// 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 type AuthOts = ServiceOts & {
+    usedService: {
+        RequestHandlerService: () => RequestHandlerService; // Replace with actual type if available
+    }
+}
+
+
+export abstract class AuthService extends Service {
+    static serviceInfo = {
+        name: "AuthService",
+        requiredServices: ["RequestHandlerService"],
+    }
+    protected async onSetup(options?: ServiceSetupOptions): Promise<ServiceResponse> {
+
+        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();
+        // });
+
+        const requestHandlerService = this.ots.usedService.RequestHandlerService() as 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" };
+    }
+
+    protected async onStop(): Promise<ServiceResponse> {
+        return { status: "success", message: "stopped" };
+    }
+
+    protected async onDestroy(): Promise<ServiceResponse> {
+        return { status: "success", message: "destroyed" };
+    }
+
+    constructor(public ots: AuthOts) {
+        super(ots);
+    }
+
+    // Abstract methods for platform-specific logic
+    protected abstract saveToken(token: string): Promise<void>;
+    protected abstract clearToken(): Promise<void>;
+    protected abstract getUserInfo({ userId, userName, userRole }: {
+        userId?: string;
+        userName?: string;
+        userRole?: string;
+    }): Promise<{
+        success: boolean;
+        message?: string;
+        user?: {
+            id: number;
+            username: string;
+            password: string; // Optional password field for internal use
+            role?: string; // Optional role field
+            databaseId?: string; // Optional database ID field
+        };
+    }>;
+
+    // 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 }): Promise<any> {
+        //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: typeof import("jsonwebtoken") | undefined;
+                if (typeof window === "undefined") {
+                    jwt = (await import("jsonwebtoken")).default;
+                }
+                let bcrypt: typeof import("bcryptjs") | undefined;
+                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 }: {
+        accessToken: string; refreshToken: string, options?: {
+            role?: string;
+        }
+    }): Promise<{ valid: boolean; newAccessToken?: string, newRefreshToken?: string, user?: any }> {
+        this.log.OK("Access Token:", accessToken);
+        this.log.OK("Refresh Token:", refreshToken);
+        //debugger;
+        try {
+            // 1. Access token'ı doğrula
+            let jwt: typeof import("jsonwebtoken") | undefined;
+            if (typeof window === "undefined") {
+                jwt = (await import("jsonwebtoken")).default;
+            }
+            const decoded = jwt.verify(accessToken, JWT_SECRET);
+            const res = await this.getUserInfo({
+                userId: (decoded as any).id,
+                userName: (decoded as any).username,
+                userRole: (decoded as any).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: typeof import("jsonwebtoken") | undefined;
+                if (typeof window === "undefined") {
+                    jwt = (await import("jsonwebtoken")).default;
+                }
+                // 2. Refresh token'ı doğrula
+                const decodedRefresh: {
+                    id: number;
+                    username: string;
+                    role: string; // Refresh token'da rol bilgisi varsa
+                    databaseId?: string;
+                } = jwt.verify(refreshToken, JWT_REFRESH_SECRET) as unknown as any;
+                //debugger;
+
+                const res = await this.getUserInfo({
+                    userId: (decodedRefresh as any).id,
+                    userName: (decodedRefresh as any).username,
+                    userRole: (decodedRefresh as any).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 }): Promise<any> {
+        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 }): Promise<any> {
+        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: any): 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: string | null, name: string): string | undefined {
+        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(): Promise<void> {
+        await this.clearToken();
+    }
+
+    async register(username: string, password: string): Promise<boolean> {
+        // 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/src/services/abstract/extensionServices/ExtensionService.ts

@@ -0,0 +1,50 @@
+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 abstract class ExtensionService extends Service {
+    constructor(ots:ExtensionOts) {
+        super({...ots});
+    }
+
+    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>;
+
+    // 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/src/services/abstract/pageServices/LayoutPageService.ts

@@ -0,0 +1,49 @@
+import { ServiceOts } from "../../../types/ServiceOts";
+import { PageService } from "./PageServices";
+
+export type RightMenuItem = {
+    icon: string;
+    label: string;
+    action: () => void;
+}   
+
+
+export type LayoutOts = ServiceOts & {
+    usedService: {
+    }
+}
+
+export class LayoutPageService extends PageService {
+    rightMenuItem:RightMenuItem[];
+    // svelte_onMount?: () => void;
+    // svelte_onDestroy?: () => void;
+    s_onMount?:()=>Promise<void>;
+    s_onDestroy?:()=>Promise<void>;
+    
+    constructor(ots:LayoutOts) {
+        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/src/services/abstract/pageServices/PageServices.ts

@@ -0,0 +1,37 @@
+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 PageService extends Service {
+    serviceInfo: { name: string; requiredServices: string[]; };
+    public svelteComponent: any; // Optional Svelte component reference
+    constructor(ots:PageOts) {
+        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/src/services/abstract/pageServices/controllers/NSPageControllerService.ts

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

package/src/services/abstract/pageServices/controllers/PageControllerService.ts

@@ -0,0 +1,56 @@
+import { Service } from "../../../../types/Service";
+import { ServiceOts } from "../../../../types/ServiceOts";
+import { ServiceResponse } from "../../../../types/ServiceResponse";
+import { ServiceSetupOptions } from "../../../../types/ServiceSetupOptions";
+import { PageService } from "../PageServices";
+
+
+
+export type PageControllerOts = ServiceOts & {
+    usedService: {
+    },
+    abilities?: {
+        createChildService?: (tag:string)=> any,
+    }
+}
+
+export abstract class PageControllerService extends Service {
+
+    abstract registerPage(tag: string, opt: object): any;
+
+    public pages: {
+        [key: string]: {
+            service: PageService,
+            status: "setup" | "started" | "stopped" | "destroyed",
+        }
+    } = {};
+
+    constructor(public ots:PageControllerOts) {
+        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/src/services/abstract/pageServices/controllers/SVPageControllerService.ts

@@ -0,0 +1,104 @@
+import { PageControllerService } from "./PageControllerService";
+import { PageService } from "../PageServices";
+
+export type SveltePageProp = {
+    onMount: (callback: () => Promise<void>) => void;
+    onDestroy: (callback: () => Promise<void>) => void;
+}
+
+export class SVPageControllerService extends PageControllerService {
+    serviceInfo = {
+        name: "SVPageControllerService",
+        type: "SVPageControllerService",
+        requiredServices: [],
+        description: "Service for handling Svelte page operations",
+        version: "1.0.0",
+    }
+    registerPage(tag: string, opt: object) {
+        throw new Error("Method not implemented.");
+    }
+    public pageServices: {
+        [key: string]: any // PageService
+    } = {};
+
+    constructor(public ots: any) { // PageControllerOts
+        super({...ots});
+    }
+
+     createPageService(
+        tag:string, 
+        callback: (service:PageService, obj?:{ params,url} ) => Promise<any>,
+        options?: {
+            slug?: boolean
+        }
+    ) {
+        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 as PageService;
+            //console.log("Available services:", Object.keys(this.pageServices));
+           
+            const res = await callback(service as PageService, { params, url });
+
+            return {
+                ...res,
+                device: device,
+            }
+        }
+    }
+
+
+   
+
+    mountPageService(tag:string, page:SveltePageProp, options?:{
+        onMount?:()=>Promise<void>,
+        onDestroy?:()=>Promise<void>
+    }){
+        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 as PageService;
+    }
+    
+   
+}