chyz 1.0.12-rc.7 → 1.0.13-rc.2

package/Examples/Models/Customer.ts

@@ -0,0 +1,115 @@
+// @ts-ignore
+import {DataTypes, Model} from "../../base";
+
+export class CustomerClass extends Model {
+    [x: string]: any;
+
+    public tableName() {
+        return 'customer';
+    }
+
+    public attributes() {
+        return {
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false,
+                validate: {
+                    notEmpty: true,
+                    is: ["^[a-z0-9A-Z]+$", 'i'],
+                    len: [4, 255],
+                }
+            },
+            firstname: {
+                type: DataTypes.STRING,
+                validate: {
+                    is: ["^[a-z0-9A-Z]+$", 'i'],
+                    len: [4, 255],
+                }
+            },
+            lastname: {
+                type: DataTypes.STRING,
+                validate: {
+                    is: ["^[a-z0-9A-Z]+$", 'i'],
+                    len: [4, 255],
+                }
+            },
+            companyName: {
+                type: DataTypes.STRING,
+                allowNull: true,
+                validate: {
+                    is: /^[0-9A-Za-z =().:;+-şŞçÇöÖğĞıİüÜ]+$/i,
+                    len: [4, 255],
+                }
+            },
+            email: {
+                type: DataTypes.STRING,
+                validate: {
+                    isEmail: true
+                }
+            },
+            gsm_phone: {
+                type: DataTypes.STRING,
+                validate: {
+                    is: ["^[0-9 +]+$", 'i'],
+                }
+            },
+            country: {
+                type: DataTypes.STRING,
+                validate: {
+                    isAlpha: true,
+                }
+            },
+            address: {
+                type: DataTypes.STRING,
+                validate: {
+                    is: ["^[\\w'\\-,.[0-9_\\/\\\\+=\"()<>;:\\[\\] şŞçÇöÖğĞıİüÜ  ]{2,}$", "i"],
+                }
+            },
+            taxoffice: {
+                type: DataTypes.STRING,
+                validate: {
+                    is: ["^[\\w'\\-,.[0-9_\\/\\\\+=\"()<>;:\\[\\] şŞçÇöÖğĞıİüÜ  ]{2,}$", "i"],
+                }
+            },
+            taxnumber: {
+                unique: true,
+                type: DataTypes.STRING,
+                validate: {
+                    is: ["^[0-9]+$", 'i'],
+                }
+            },
+            username: {
+                unique: true,
+                type: DataTypes.STRING,
+                validate: {
+                    isEmail: true
+                }
+            },
+            password: {
+                type: DataTypes.STRING,
+                validate: {
+                    is: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?\.#&])[A-Za-z\d$@$!%*\.?&]{8,12}/
+                }
+            },
+            "2fa": {
+                type: DataTypes.BOOLEAN,
+                validate: {
+                    isBoolean: true
+                }
+            },
+            status: {
+                type: DataTypes.BOOLEAN,
+                validate: {
+                    isBoolean: true
+                }
+            }
+        }
+    }
+
+}
+
+const Customer = new CustomerClass();
+export {Customer};
+
+
+

package/Examples/Models/KeycloakUser.ts

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2021. Chy Bilgisayar Bilisim
+ * Author: Cihan Ozturk
+ * E-mail: cihan@chy.com.tr
+ * Github:https://github.com/cihan53/
+ */
+
+import {IdentityInterface} from "../../web/IdentityInterface";
+import {DataTypes, Model} from "../../base";
+import BaseChyz from "../../BaseChyz";
+
+const JsonWebToken = require("jsonwebtoken");
+
+export class KeycloakUser implements IdentityInterface {
+
+    [x: string]: any;
+
+
+    findIdentity(id: number) {
+        throw new Error("Method not implemented.");
+    }
+
+    getId(): number {
+        throw new Error("Method not implemented.");
+    }
+
+    getAuthKey(): string {
+        throw new Error("Method not implemented.");
+    }
+
+    validateAuthKey(authKey: string): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    public attributes() {
+        return {
+            // Model attributes are defined here
+            username: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            password: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            user_role: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            salt_text: {
+                type: DataTypes.STRING
+                // allowNull defaults to true
+            }
+        }
+    }
+
+    async findIdentityByAccessToken(token, type) {
+        console.log(token,type)
+        // console.log(this)
+        // console.log(BaseChyz)
+        return null;
+        // return keycloak.protect('realm:user');
+    }
+}
+
+

package/Examples/Models/Order.ts

@@ -0,0 +1,64 @@
+import {DataTypes, Model, Relation} from "../../base";
+import {OrderItem} from "./OrderItem";
+
+export class OrderClass extends Model {
+    [x: string]: any;
+
+    tableName() {
+        return 'order';
+    }
+
+
+    attributes() {
+
+        return {
+            customer_id: {
+                allowNull: false,
+                type: DataTypes.INTEGER,
+            },
+
+            crm_order_id: {
+                allowNull: false,
+                type: DataTypes.INTEGER,
+            },
+
+            total: {
+                allowNull: false,
+                type: DataTypes.FLOAT,
+            },
+
+            created_date: {
+                allowNull: false,
+                type: DataTypes.DATE,
+                // @ts-ignore
+                defaultValue: Model.NOW
+            },
+            status: {
+                type: DataTypes.BOOLEAN,
+                allowNull: false,
+                validate: {
+                    isBoolean: true
+                }
+            }
+        }
+    }
+
+
+    relation(): Relation[] {
+        return [
+            {
+                type: "hasOne",
+                sourceKey: "order_id",
+                foreignKey: "id",
+                model: OrderItem.model()
+            }
+        ]
+    }
+}
+
+const Order = new OrderClass()
+export {Order};
+
+
+
+

package/Examples/Models/OrderItem.ts

@@ -0,0 +1,27 @@
+import {DataTypes, Model} from "../../base";
+
+export class OrderItemClass extends Model {
+    [x: string]: any;
+
+    public tableName() {
+        return 'order_items';
+    }
+
+    public attributes() {
+        return {
+
+            status: {
+                type: DataTypes.BOOLEAN,
+                validate: {
+                    isBoolean: true
+                }
+            }
+        }
+    }
+
+}
+const OrderItem = new OrderItemClass()
+export { OrderItem };
+
+
+

package/Examples/Models/ProductModels.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2021. Chy Bilgisayar Bilisim
+ * Author: Cihan Ozturk
+ * E-mail: cihan@chy.com.tr
+ * Github:https://github.com/cihan53/
+ */
+import {DataTypes, Model, Relation} from "../../base";
+import {Products} from "./Products";
+
+export class ProductModelsClass extends Model {
+    [x: string]: any;
+
+    tableName() {
+        return 'models';
+    }
+
+
+    attributes() {
+        return {
+            // Model attributes are defined here
+            title: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            stock_code: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            properties: {
+                type: DataTypes.STRING,
+                allowNull: false
+            }
+
+        }
+    }
+
+    relation(): Relation[] {
+        return [
+            {
+                type: "hasOne",
+                foreignKey: "id",
+                sourceKey: "category_id",
+                model: Products.model()
+            }
+        ]
+    }
+}
+
+const ProductModels = new ProductModelsClass();
+export {ProductModels}

package/Examples/Models/ProductToCategories.ts

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2021. Chy Bilgisayar Bilisim
+ * Author: Cihan Ozturk
+ * E-mail: cihan@chy.com.tr
+ * Github:https://github.com/cihan53/
+ */
+import {DataTypes, Model} from "../../base";
+
+export class ProductToCategoriesClass extends Model {
+    [x: string]: any;
+
+    tableName() {
+        return 'product_to_categories';
+    }
+
+
+    attributes() {
+        return {
+            // Model attributes are defined here
+            product_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            categories_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            }
+
+        }
+    }
+
+}
+
+const ProductToCategories = new ProductToCategoriesClass()
+export {ProductToCategories}

package/Examples/Models/Products.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2021. Chy Bilgisayar Bilisim
+ * Author: Cihan Ozturk
+ * E-mail: cihan@chy.com.tr
+ * Github:https://github.com/cihan53/
+ */
+import {DataTypes, Model, Relation} from "../../base";
+import {ProductModels} from "./ProductModels";
+
+export class ProductsClass extends Model {
+    [x: string]: any;
+
+    tableName() {
+        return 'products';
+    }
+
+    attributes() {
+        return {
+            // Model attributes are defined here
+            title: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            model_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            properties: {
+                type: DataTypes.STRING,
+                allowNull: false
+            }
+
+        }
+    }
+
+    relations(): Relation[] {
+        return [
+            {
+                type: "hasOne",
+                foreignKey: "id",
+                sourceKey: "model_id",
+                model: ProductModels.model()
+            }
+        ]
+    }
+}
+
+const Products = new ProductsClass()
+export {Products}

package/Examples/Models/Stocks.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2021. Chy Bilgisayar Bilisim
+ * Author: Cihan Ozturk
+ * E-mail: cihan@chy.com.tr
+ * Github:https://github.com/cihan53/
+ */
+import {DataTypes, Model} from "../../base";
+
+export class StocksClass extends Model {
+    [x: string]: any;
+
+    public tableName() {
+        return 'stock';
+    }
+
+    /**
+     * product_id int4
+     * properties jsonb
+     * status int2
+     * barcode string(20)
+     * stock_code string(20)
+     * model_id int4
+     */
+    public attributes() {
+        return {
+            // Model attributes are defined here
+            product_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+
+            barcode: {
+                type: DataTypes.STRING,
+                allowNull: false,
+                validate: {
+                    len: 20
+                }
+            },
+            stock_code: {
+                type: DataTypes.STRING,
+                allowNull: false,
+                validate: {
+                    len: 20
+                }
+            },
+            model_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            status: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            }
+
+        }
+    }
+}
+
+const Stocks = new StocksClass();
+export {Stocks}

package/Examples/Models/User.ts

@@ -4,20 +4,45 @@
  * E-mail: cihan@chy.com.tr
  * Github:https://github.com/cihan53/
  */
+// @ts-ignore
+
 
 import {IdentityInterface} from "../../web/IdentityInterface";
-// @ts-ignore
-import {DataTypes, Model} from "sequelize";
-import BaseChyz from "../../BaseChyz";
+import {DataTypes, Model} from "../../base";
+import {BaseChyz} from "../../index";
+
+const JsonWebToken = require("jsonwebtoken");
+
+export class User extends Model implements IdentityInterface {
+    [x: string]: any;
+
+    public tableName() {
+        return 'users';
+    }
+
+    findIdentity(id: number) {
+        throw new Error("Method not implemented.");
+    }
 
-export class User implements IdentityInterface {
+    getId(): number {
+        throw new Error("Method not implemented.");
+    }
 
-    private _model  ;
+    getAuthKey(): string {
+        throw new Error("Method not implemented.");
+    }
 
-    constructor() {
-        const sequelize = BaseChyz.getComponent("db").db;
-        this._model = sequelize.define('User', {
+    validateAuthKey(authKey: string): boolean {
+        throw new Error("Method not implemented.");
+    }
+
+    public attributes() {
+        return {
             // Model attributes are defined here
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
             username: {
                 type: DataTypes.STRING,
                 allowNull: false
@@ -26,44 +51,50 @@ export class User implements IdentityInterface {
                 type: DataTypes.STRING,
                 allowNull: false
             },
-            user_role: {
+            email: {
                 type: DataTypes.STRING,
                 allowNull: false
             },
-            salt_text: {
+            permissions_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false
+            },
+            authkey: {
+                type: DataTypes.STRING
+                // allowNull defaults to true
+            },
+            status: {
                 type: DataTypes.STRING
                 // allowNull defaults to true
             }
-        }, {
-            tableName: 'users',
-            timestamps: false
-        });
-    }
-
-
-    get model(): any {
-        return this._model;
-    }
-
-    findIdentity(id) {
+        }
     }
 
     async findIdentityByAccessToken(token, type) {
-         let identity = await this._model.findOne({where: {salt_text: token.signature}});
-         return identity;
-    }
-
-    getAuthKey(): string {
-        return "";
-    }
+        let decoded = JsonWebToken.decode(token, {complete: true})
 
-    getId(): number {
-        return 0;
-    }
+        if(!decoded.payload.user) {
+            return null;
+        }
 
-    validateAuthKey(authKey: string): boolean | null {
-        return undefined;
+        let identity = await this.findOne({where: {id: parseInt(decoded.payload.user)}});
+        if (identity) {
+            BaseChyz.debug("Find Identity By AccessToken: User Found", decoded.payload)
+            try {
+                JsonWebToken.verify(token, identity.authkey);
+                BaseChyz.debug("Find Identity By AccessToken: User Verify Success")
+                return identity;
+            } catch (err) {
+                if (err.name == "TokenExpiredError")
+                    BaseChyz.debug("Find Identity By AccessToken: Token Expired")
+                else
+                    BaseChyz.debug("Find Identity By AccessToken: User Verify Failed")
+                return null;
+            }
+        }
+        BaseChyz.debug("Find Identity By AccessToken: User Verify Failed")
+        return null;
     }
-}
 
 
+}

package/Examples/Models/UserPermission.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021. Chy Bilgisayar Bilisim
+ * Author: Cihan Ozturk
+ * E-mail: cihan@chy.com.tr
+ * Github:https://github.com/cihan53/
+ */
+// @ts-ignore
+
+
+import {DataTypes, Model} from "../../base";
+
+export class UserPermissionClass extends Model {
+    [x: string]: any;
+
+    public tableName() {
+        return 'user_permissions';
+    }
+
+
+    public attributes() {
+        return {
+            // Model attributes are defined here
+            object_type: {
+                type: DataTypes.STRING,
+                allowNull: false
+            },
+            object_value: {
+                type: DataTypes.STRING,
+                allowNull: false
+            }
+
+        }
+    }
+}
+
+const UserPermission = new UserPermissionClass();
+export {UserPermission}