@lcap/nasl 2.16.1 → 2.16.2

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/GetPermissionResourceWithPermissionId.ts

@@ -0,0 +1,36 @@
+namespace app.logics {
+    export function GetPermissionResourceWithPermissionId(    id:     nasl.core.Long,
+,  __defaultValues?: { 
+id: ""}): nasl.collection.List<app.structures.ResourceRelate>{
+        let variable1:     nasl.collection.PageOf<app.structures.GetPermissionResourceWithPermissionIdStructure>;
+        let ResourceItem:     app.structures.ResourceRelate;
+        let ResourceList:     nasl.collection.List<app.structures.ResourceRelate>;
+        let listnull:     nasl.collection.List<app.structures.ResourceRelate>;
+        let result:     nasl.collection.List<app.structures.ResourceRelate>;
+        
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.GetPermissionResourceWithPermissionIdStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPPerResMapping]>()
+                .LEFT_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPResource]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPPerResMapping().resourceId,new app.dataSources.defaultDS.entities.LCAPResource().id))
+            )
+            .WHERE(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPPerResMapping().permissionId,id))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(5000)])
+
+            return;
+        })();
+;
+        if (nasl.core.ensureBoolean(nasl.core.notEqual(variable1.content.length,new nasl.core.Integer(0)))) {
+            variable1.content.__slice(            new nasl.core.Integer(0),             variable1.content.length).__forEach((item, index) => {
+                ResourceItem.text = item.lCAPRES.name;
+                ResourceItem.value = item.lCAPRES.id;
+                nasl.util.Add(ResourceList, nasl.util.Clone(ResourceItem))
+            })
+
+            result = ResourceList;
+        } else {
+            result = nasl.util.Clone(listnull);
+        }
+
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPGetMappingByPermissionIdAndResourceId.ts

@@ -0,0 +1,25 @@
+namespace app.logics {
+    export function LCAPGetMappingByPermissionIdAndResourceId(    permissionId:     nasl.core.Long,    resourceId:     nasl.core.Long,
+,  __defaultValues?: { 
+permissionId: "",
+resourceId: ""}): nasl.collection.List<nasl.core.Long>{
+        let variable1:     nasl.collection.PageOf<app.structures.LCAPGetMappingByPermissionIdAndResourceIdStructure>;
+        let variable2:     nasl.core.Long;
+        let mappingIdList:     nasl.collection.List<nasl.core.Long>;
+        
+        nasl.util.Clear(mappingIdList)
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.LCAPGetMappingByPermissionIdAndResourceIdStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPPerResMapping]>()            )
+            .WHERE(() => nasl.core.and(nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPPerResMapping().permissionId,permissionId),nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPPerResMapping().resourceId,resourceId)))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(20)])
+
+            return;
+        })();
+;
+        variable1.content.__slice(        new nasl.core.Integer(0),         variable1.content.length).__forEach((item, i) => {
+            nasl.util.Add(mappingIdList, item.lCAPPRM.id)
+        })
+
+        return mappingIdList;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPGetMappingIdByRoleIdAndUserId.ts

@@ -0,0 +1,28 @@
+namespace app.logics {
+    export function LCAPGetMappingIdByRoleIdAndUserId(    roleId:     nasl.core.Long,    userId:     nasl.core.String,
+,  __defaultValues?: { 
+roleId: "",
+userId: ""}): nasl.core.Long{
+        let variable1:     nasl.collection.PageOf<app.structures.GetMappingIdByRoleIdAndUserIdStructure>;
+        let variable2:     app.structures.GetMappingIdByRoleIdAndUserIdStructure;
+        let result:     nasl.core.Long;
+        
+        result = new nasl.core.Integer(0);
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.GetMappingIdByRoleIdAndUserIdStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPUserRoleMapping]>()            )
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(2000)])
+
+            return;
+        })();
+;
+        variable1.content.__slice(        new nasl.core.Integer(0),         variable1.content.length).__forEach((item, i) => {
+            if (nasl.core.ensureBoolean(nasl.core.and(nasl.core.equal(item.lCAPURM.roleId,roleId),nasl.core.equal(item.lCAPURM.userId,userId)))) {
+                result = item.lCAPURM.id;
+            } else {
+            }
+
+        })
+
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPGetPermissionByRoleId.ts

@@ -0,0 +1,33 @@
+namespace app.logics {
+    export function LCAPGetPermissionByRoleId(    roleId:     nasl.core.Long,
+,  __defaultValues?: { 
+roleId: ""}): nasl.collection.List<app.dataSources.defaultDS.entities.LCAPPermission>{
+        let variable1:     nasl.collection.PageOf<app.structures.GetPermissionByRoleIdStructure>;
+        let permissionId:     nasl.core.Long;
+        let rolePermissionMappingList:     nasl.collection.List<app.structures.GetPermissionByRoleIdStructure>;
+        let permissionInfo:     app.dataSources.defaultDS.entities.LCAPPermission;
+        let permissionList:     nasl.collection.List<app.dataSources.defaultDS.entities.LCAPPermission>;
+        
+        if (nasl.core.ensureBoolean(nasl.core.equal(roleId,null))) {
+            return permissionList;
+        } else {
+        }
+
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.GetPermissionByRoleIdStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPRolePerMapping]>()            )
+            .WHERE(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPRolePerMapping().roleId,roleId))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(20)])
+
+            return;
+        })();
+;
+        rolePermissionMappingList = variable1.content;
+        rolePermissionMappingList.__slice(        new nasl.core.Integer(0),         rolePermissionMappingList.length).__forEach((item, i) => {
+            permissionId = item.lCAPRPM.permissionId;
+            permissionInfo = app.dataSources.defaultDS.entities.LCAPPermission.logics.get(                        permissionId);;
+            nasl.util.Add(permissionList, permissionInfo)
+        })
+
+        return permissionList;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPGetResourceListByRoleId.ts

@@ -0,0 +1,33 @@
+namespace app.logics {
+    export function LCAPGetResourceListByRoleId(    roleId:     nasl.core.Long,
+,  __defaultValues?: { 
+roleId: ""}): nasl.collection.List<app.dataSources.defaultDS.entities.LCAPResource>{
+        let variable1:     nasl.collection.PageOf<app.structures.LCAPGetResourceListByRoleIdStructure>;
+        let variable3:     app.dataSources.defaultDS.entities.LCAPResource;
+        let resultResourceList:     nasl.collection.List<app.dataSources.defaultDS.entities.LCAPResource>;
+        
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.LCAPGetResourceListByRoleIdStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPRolePerMapping]>()
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPPermission]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPRolePerMapping().permissionId,new app.dataSources.defaultDS.entities.LCAPPermission().id))
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPPerResMapping]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPPermission().id,new app.dataSources.defaultDS.entities.LCAPPerResMapping().permissionId))
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPResource]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPPerResMapping().resourceId,new app.dataSources.defaultDS.entities.LCAPResource().id))
+            )
+            .WHERE(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPRolePerMapping().roleId,roleId))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(2000)])
+
+            return;
+        })();
+;
+        variable1.content.__slice(        new nasl.core.Integer(0),         variable1.content.length).__forEach((item, i) => {
+            variable3.id = item.lCAPRES.id;
+            variable3.name = item.lCAPRES.name;
+            variable3.description = item.lCAPRES.description;
+            nasl.util.Add(resultResourceList, variable3)
+        })
+
+        return resultResourceList;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPGetRoleBindUserList.ts

@@ -0,0 +1,19 @@
+namespace app.logics {
+    export function LCAPGetRoleBindUserList(    inputRoleId:     nasl.core.Long,
+,  __defaultValues?: { 
+inputRoleId: ""}): nasl.collection.List<app.structures.GetRoleBindUserListStructure>{
+        let variable1:     nasl.collection.PageOf<app.structures.GetRoleBindUserListStructure>;
+        let result:     nasl.collection.List<app.structures.GetRoleBindUserListStructure>;
+        
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.GetRoleBindUserListStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPUserRoleMapping]>()            )
+            .WHERE(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPUserRoleMapping().roleId,inputRoleId))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(2000)])
+
+            return;
+        })();
+;
+        result = variable1.content;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPGetRolePermissionList.ts

@@ -0,0 +1,20 @@
+namespace app.logics {
+    export function LCAPGetRolePermissionList(    inputRoleId:     nasl.core.Long,
+,  __defaultValues?: { 
+inputRoleId: ""}): nasl.collection.PageOf<app.structures.LCAPGetRolePermissionListStructure>{
+        let result:     nasl.collection.PageOf<app.structures.LCAPGetRolePermissionListStructure>;
+        
+        result = (function(): nasl.collection.PageOf<        app.structures.LCAPGetRolePermissionListStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPRolePerMapping]>()
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPPermission]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPRolePerMapping().permissionId,new app.dataSources.defaultDS.entities.LCAPPermission().id))
+            )
+            .WHERE(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPRolePerMapping().roleId,inputRoleId))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(2000)])
+
+            return;
+        })();
+;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPGetScopeResourceByRoleId.ts

@@ -0,0 +1,24 @@
+namespace app.logics {
+    export function LCAPGetScopeResourceByRoleId(    roleId:     nasl.core.Long,
+,  __defaultValues?: { 
+roleId: ""}): nasl.collection.PageOf<app.structures.LCAPGetScopeResourceByRoleIdStructure>{
+        let result:     nasl.collection.PageOf<app.structures.LCAPGetScopeResourceByRoleIdStructure>;
+        
+        result = (function(): nasl.collection.PageOf<        app.structures.LCAPGetScopeResourceByRoleIdStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPRolePerMapping]>()
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPPermission]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPRolePerMapping().permissionId,new app.dataSources.defaultDS.entities.LCAPPermission().id))
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPPerResMapping]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPPermission().id,new app.dataSources.defaultDS.entities.LCAPPerResMapping().permissionId))
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPResource]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPPerResMapping().resourceId,new app.dataSources.defaultDS.entities.LCAPResource().id))
+            )
+            .WHERE(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPRolePerMapping().roleId,roleId))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(2000)])
+
+            return;
+        })();
+;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPGetUserResources.ts

@@ -0,0 +1,42 @@
+namespace app.logics {
+    export function LCAPGetUserResources(    userId:     nasl.core.String,
+,  __defaultValues?: { 
+userId: ""}): nasl.collection.List<app.structures.ResourceResult>{
+        let variable1:     nasl.collection.PageOf<app.structures.LCAPGetUserResourcesStructure>;
+        let variable2:     nasl.collection.List<nasl.core.String>;
+        let variable3:     app.structures.ResourceResult;
+        let variable4:     nasl.collection.List<app.structures.ResourceResult>;
+        let variable5:     app.structures.ResourceResult;
+        let result:     nasl.collection.List<app.structures.ResourceResult>;
+        
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.LCAPGetUserResourcesStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPUserRoleMapping]>()
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPRolePerMapping]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPUserRoleMapping().roleId,new app.dataSources.defaultDS.entities.LCAPRolePerMapping().roleId))
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPPerResMapping]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPRolePerMapping().permissionId,new app.dataSources.defaultDS.entities.LCAPPerResMapping().permissionId))
+                .INNER_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPResource]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPPerResMapping().resourceId,new app.dataSources.defaultDS.entities.LCAPResource().id))
+            )
+            .WHERE(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPUserRoleMapping().userId,userId))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(2000)])
+
+            return;
+        })();
+;
+        variable1.content.__slice(        new nasl.core.Integer(0),         variable1.content.length).__forEach((item, i) => {
+            if (nasl.core.ensureBoolean(nasl.util.Contains(variable2, item.lCAPRES.name))) {
+            } else {
+                nasl.util.Add(variable2, item.lCAPRES.name)
+                variable3.resourceValue = item.lCAPRES.name;
+                variable3.resourceType = item.lCAPRES.type;
+                variable5 = nasl.util.Clone(variable3);
+                nasl.util.Add(variable4, variable5)
+            }
+
+        })
+
+        result = variable4;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPIsAlreadBindUserIdList.ts

@@ -0,0 +1,23 @@
+namespace app.logics {
+    export function LCAPIsAlreadBindUserIdList(    newUserId:     nasl.core.String,    inputRoleId:     nasl.core.Long,
+,  __defaultValues?: { 
+newUserId: "",
+inputRoleId: ""}): nasl.core.Boolean{
+        let userIdList:     nasl.collection.List<nasl.core.String>;
+        let userList:     nasl.collection.List<app.structures.GetRoleBindUserListStructure>;
+        let result:     nasl.core.Boolean;
+        
+        userList = app.logics.LCAPGetRoleBindUserList(                inputRoleId);;
+        userList.__slice(        new nasl.core.Integer(0),         userList.length).__forEach((item, i) => {
+            nasl.util.Add(userIdList, item.lCAPURM.userId)
+        })
+
+        if (nasl.core.ensureBoolean(nasl.util.Contains(userIdList, newUserId))) {
+            result = true;
+        } else {
+            result = false;
+        }
+
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPIsRoleNameRepeated.ts

@@ -0,0 +1,24 @@
+namespace app.logics {
+    export function LCAPIsRoleNameRepeated(    roleName:     nasl.core.String,
+,  __defaultValues?: { 
+roleName: ""}): nasl.core.Boolean{
+        let variable1:     nasl.collection.PageOf<app.structures.LCAPGetRoleListByNameStructure>;
+        let isExist:     nasl.core.Boolean;
+        
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.LCAPGetRoleListByNameStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPRole]>()            )
+            .WHERE(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPRole().name,roleName))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(2000)])
+
+            return;
+        })();
+;
+        if (nasl.core.ensureBoolean(nasl.core.greaterThan(variable1.content.length,new nasl.core.Integer(0)))) {
+            isExist = true;
+        } else {
+            isExist = false;
+        }
+
+        return isExist;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPLoadAddRoleUserSelectLCAPROL.ts

@@ -0,0 +1,17 @@
+namespace app.logics {
+    export function LCAPLoadAddRoleUserSelectLCAPROL(    page:     nasl.core.Integer,    size:     nasl.core.Integer,
+,  __defaultValues?: { 
+page: "",
+size: ""}): nasl.collection.PageOf<app.structures.LoadAddRoleUserSelectLCAPROLStructure>{
+        let result:     nasl.collection.PageOf<app.structures.LoadAddRoleUserSelectLCAPROLStructure>;
+        
+        result = (function(): nasl.collection.PageOf<        app.structures.LoadAddRoleUserSelectLCAPROLStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPRole]>()            )
+            .LIMIT(() => [page, size])
+
+            return;
+        })();
+;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPLoadPermissionManagementTableView.ts

@@ -0,0 +1,22 @@
+namespace app.logics {
+    export function LCAPLoadPermissionManagementTableView(    page:     nasl.core.Integer,    size:     nasl.core.Integer,    sort:     nasl.core.String,    order:     nasl.core.String,    filter:     app.dataSources.defaultDS.entities.LCAPPermission,
+,  __defaultValues?: { 
+page: "",
+size: "",
+sort: "",
+order: "",
+filter: ""}): nasl.collection.PageOf<app.structures.LoadPermissionManagementTableViewStructure>{
+        let result:     nasl.collection.PageOf<app.structures.LoadPermissionManagementTableViewStructure>;
+        
+        result = (function(): nasl.collection.PageOf<        app.structures.LoadPermissionManagementTableViewStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPPermission]>()            )
+            .WHERE(() => nasl.langUtil.LIKE(new app.dataSources.defaultDS.entities.LCAPPermission().name, filter.name))
+            .ORDER_BY(() => [sort, order])
+            .LIMIT(() => [page, size])
+
+            return;
+        })();
+;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPLoadPermissionResourceListView.ts

@@ -0,0 +1,17 @@
+namespace app.logics {
+    export function LCAPLoadPermissionResourceListView(    page:     nasl.core.Integer,    size:     nasl.core.Integer,
+,  __defaultValues?: { 
+page: "",
+size: ""}): nasl.collection.PageOf<app.structures.LoadPermissionResourceListViewStructure>{
+        let result:     nasl.collection.PageOf<app.structures.LoadPermissionResourceListViewStructure>;
+        
+        result = (function(): nasl.collection.PageOf<        app.structures.LoadPermissionResourceListViewStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPResource]>()            )
+            .LIMIT(() => [page, size])
+
+            return;
+        })();
+;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPLoadPermissionResourceTableView.ts

@@ -0,0 +1,20 @@
+namespace app.logics {
+    export function LCAPLoadPermissionResourceTableView(    page:     nasl.core.Integer,    size:     nasl.core.Integer,    sort:     nasl.core.String,    order:     nasl.core.String,
+,  __defaultValues?: { 
+page: "",
+size: "",
+sort: "",
+order: ""}): nasl.collection.PageOf<app.structures.LoadPermissionResourceTableViewStructure>{
+        let result:     nasl.collection.PageOf<app.structures.LoadPermissionResourceTableViewStructure>;
+        
+        result = (function(): nasl.collection.PageOf<        app.structures.LoadPermissionResourceTableViewStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPResource]>()            )
+            .ORDER_BY(() => [sort, order])
+            .LIMIT(() => [page, size])
+
+            return;
+        })();
+;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPLoadRoleManagementTableView.ts

@@ -0,0 +1,22 @@
+namespace app.logics {
+    export function LCAPLoadRoleManagementTableView(    page:     nasl.core.Integer,    size:     nasl.core.Integer,    sort:     nasl.core.String,    order:     nasl.core.String,    filter:     app.dataSources.defaultDS.entities.LCAPRole,
+,  __defaultValues?: { 
+page: "",
+size: "",
+sort: "",
+order: "",
+filter: ""}): nasl.collection.PageOf<app.structures.LoadRoleManagementTableViewStructure>{
+        let result:     nasl.collection.PageOf<app.structures.LoadRoleManagementTableViewStructure>;
+        
+        result = (function(): nasl.collection.PageOf<        app.structures.LoadRoleManagementTableViewStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPRole]>()            )
+            .WHERE(() => nasl.langUtil.LIKE(new app.dataSources.defaultDS.entities.LCAPRole().name, filter.name))
+            .ORDER_BY(() => [sort, order])
+            .LIMIT(() => [page, size])
+
+            return;
+        })();
+;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPLoadUserRoleMappingTableView.ts

@@ -0,0 +1,25 @@
+namespace app.logics {
+    export function LCAPLoadUserRoleMappingTableView(    page:     nasl.core.Integer,    size:     nasl.core.Integer,    sort:     nasl.core.String,    order:     nasl.core.String,    filter:     app.dataSources.defaultDS.entities.LCAPUserRoleMapping,
+,  __defaultValues?: { 
+page: "",
+size: "",
+sort: "",
+order: "",
+filter: ""}): nasl.collection.PageOf<app.structures.LoadURMTableViewStructure>{
+        let result:     nasl.collection.PageOf<app.structures.LoadURMTableViewStructure>;
+        
+        result = (function(): nasl.collection.PageOf<        app.structures.LoadURMTableViewStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPUserRoleMapping]>()
+                .LEFT_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.LCAPRole]>())
+                .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPUserRoleMapping().roleId,new app.dataSources.defaultDS.entities.LCAPRole().id))
+            )
+            .WHERE(() => nasl.core.and(nasl.core.equal(new app.dataSources.defaultDS.entities.LCAPUserRoleMapping().roleId,filter.roleId),nasl.langUtil.LIKE(new app.dataSources.defaultDS.entities.LCAPUserRoleMapping().userName, filter.userName)))
+            .ORDER_BY(() => [sort, order])
+            .LIMIT(() => [page, size])
+
+            return;
+        })();
+;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/LCAPROLBindUsers.ts

@@ -0,0 +1,47 @@
+namespace app.logics {
+    export function LCAPROLBindUsers(    roleBindUsersBody:     app.structures.LCAPROLBindUsersBody,
+,  __defaultValues?: { 
+roleBindUsersBody: ""}): nasl.core.Long{
+        let roleAndUserMappingBody:     app.dataSources.defaultDS.entities.LCAPUserRoleMapping;
+        let roleIdVariable:     nasl.core.Long;
+        let userIdListVariable:     nasl.collection.List<nasl.core.String>;
+        let roleAlreadyBindUsers:     nasl.collection.List<app.structures.GetRoleBindUserListStructure>;
+        let isAlreadyBind:     nasl.core.Boolean;
+        let isExistRoleId:     nasl.core.Boolean;
+        let resultBindNum:     nasl.core.Long;
+        
+        roleIdVariable = roleBindUsersBody.roleId;
+        isExistRoleId = app.logics.isExistRoleId(                roleIdVariable);;
+        if (nasl.core.ensureBoolean(nasl.core.equal(isExistRoleId,true))) {
+        } else {
+            return resultBindNum;
+        }
+
+        userIdListVariable = roleBindUsersBody.userIdList;
+        if (nasl.core.ensureBoolean(nasl.core.equal(roleIdVariable,null))) {
+            return resultBindNum;
+        } else {
+        }
+
+        if (nasl.core.ensureBoolean(nasl.core.equal(userIdListVariable,null))) {
+            return resultBindNum;
+        } else {
+        }
+
+        resultBindNum = userIdListVariable.length;
+        userIdListVariable.__slice(        new nasl.core.Integer(0),         userIdListVariable.length).__forEach((item, i) => {
+            roleAndUserMappingBody.userId = item;
+            roleAndUserMappingBody.roleId = roleIdVariable;
+            isAlreadyBind = app.logics.LCAPIsAlreadBindUserIdList(                        item, 
+                        roleIdVariable);;
+            if (nasl.core.ensureBoolean(nasl.core.equal(isAlreadyBind,true))) {
+                resultBindNum = nasl.core.minus(resultBindNum,new nasl.core.Integer(1));
+            } else {
+                app.dataSources.defaultDS.entities.LCAPUserRoleMapping.logics.create(                                roleAndUserMappingBody);
+            }
+
+        })
+
+        return resultBindNum;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/autoUpdateOpeExamStatus.ts

@@ -0,0 +1,54 @@
+namespace app.logics {
+    export function autoUpdateOpeExamStatus(){
+        let getRule:     nasl.collection.PageOf<app.structures.AutoUpdateShicaoStatusStructure>;
+        let variable2:     app.structures.AutoUpdateShicaoStatusStructure;
+        let shicaoPaper:     app.dataSources.defaultDS.entities.PaperInfo;
+        let variable1:     nasl.collection.PageOf<app.structures.AutoUpdateShicaoStatusStructure1>;
+        let variable3:     app.dataSources.defaultDS.entities.ExaminerPaper;
+        let variable4:     nasl.collection.PageOf<app.structures.AutoUpdateShicaoStatusStructure2>;
+        let variable5:     app.structures.AutoUpdateShicaoStatusStructure2;
+        
+        getRule = (function(): nasl.collection.PageOf<        app.structures.AutoUpdateShicaoStatusStructure> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.RecruitmentExam]>()            )
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(20)])
+
+            return;
+        })();
+;
+        variable2 = nasl.util.Get(getRule.content, new nasl.core.Integer(0));
+        shicaoPaper = app.dataSources.defaultDS.entities.PaperInfo.logics.get(                variable2.recruitmentExam.operationPaper);;
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.AutoUpdateShicaoStatusStructure1> {
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.ExaminerPaper]>()            )
+            .WHERE(() => nasl.core.and(nasl.core.equal(new app.dataSources.defaultDS.entities.ExaminerPaper().paperid,shicaoPaper.id),nasl.core.equal(new app.dataSources.defaultDS.entities.ExaminerPaper().status,app.enums.ExaminerPaperStatus['todo'])))
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(2000)])
+
+            return;
+        })();
+;
+        variable1.content.__slice(        new nasl.core.Integer(0),         variable1.content.length).__forEach((item, index) => {
+            if (nasl.core.ensureBoolean(nasl.core.greaterThanOrEqual(nasl.util.DateDiff(item.examinerPaper.createdTime, nasl.util.CurrDateTime(), 'StringLiteral'),new nasl.core.Integer(4)))) {
+                item.examinerPaper.status = app.enums.ExaminerPaperStatus['givingup'];
+                variable3 = nasl.util.Clone(item.examinerPaper);
+                variable4 = (function(): nasl.collection.PageOf<                app.structures.AutoUpdateShicaoStatusStructure2> {
+                    nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.ResumeInfo]>()
+                        .LEFT_JOIN(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.Userinfo]>())
+                        .ON(() => nasl.core.equal(new app.dataSources.defaultDS.entities.ResumeInfo().email,new app.dataSources.defaultDS.entities.Userinfo().username))
+                    )
+                    .WHERE(() => nasl.core.equal(new app.dataSources.defaultDS.entities.Userinfo().userid,variable3.userid))
+                    .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(20)])
+
+                    return;
+                })();
+;
+                variable5 = nasl.util.Get(variable4.content, new nasl.core.Integer(0));
+                variable5.resumeInfo.status = app.enums.ResumeStatus['10'];
+                app.dataSources.defaultDS.entities.ResumeInfo.logics.update(                                variable5.resumeInfo);
+                app.dataSources.defaultDS.entities.ExaminerPaper.logics.update(                                item.examinerPaper);
+            } else {
+            }
+
+        })
+
+        return;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/countquestion.ts

@@ -0,0 +1,24 @@
+namespace app.logics {
+    export function countquestion(    librarylist:     nasl.collection.List<nasl.core.Long>,
+,  __defaultValues?: { 
+librarylist: ""}): nasl.core.Integer{
+        let variable1:     nasl.collection.PageOf<app.structures.CountquestionStructure>;
+        let variable2:     app.structures.CountquestionStructure;
+        let result:     nasl.core.Integer;
+        
+        variable1 = (function(): nasl.collection.PageOf<        app.structures.CountquestionStructure> {
+            const __count = nasl.langUtil.COUNT(new app.dataSources.defaultDS.entities.QuestionInfo().id);
+
+            nasl.langUtil.FROM(new nasl.langUtil.Collection<[app.dataSources.defaultDS.entities.QuestionInfo]>()            )
+            .WHERE(() => nasl.langUtil.IN(new app.dataSources.defaultDS.entities.QuestionInfo().libraryid, librarylist))
+            .SELECT(() => __count)
+            .LIMIT(() => [new nasl.core.Integer(1), new nasl.core.Integer(20)])
+
+            return;
+        })();
+;
+        variable2 = nasl.util.Get(variable1.content, new nasl.core.Integer(0));
+        result = variable2.count;
+        return result;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/createCustomerStatusRecord.ts

@@ -0,0 +1,15 @@
+namespace app.logics {
+    export function createCustomerStatusRecord(    userid:     nasl.core.String,    customerid:     nasl.core.Long,    statusnumber:     nasl.core.Integer,
+,  __defaultValues?: { 
+userid: "",
+customerid: "",
+statusnumber: ""}){
+        let customerstatus:     app.dataSources.defaultDS.entities.CustomerStatusRecord;
+        
+        customerstatus.createdBy = userid;
+        customerstatus.customerid = customerid;
+        customerstatus.statusnumber = statusnumber;
+        app.dataSources.defaultDS.entities.CustomerStatusRecord.logics.create(                customerstatus);
+        return;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/createResumeRecord.ts

@@ -0,0 +1,13 @@
+namespace app.logics {
+    export function createResumeRecord(    resumeid:     nasl.core.Long,    remark:     nasl.core.String,
+,  __defaultValues?: { 
+resumeid: "",
+remark: ""}){
+        let variable1:     app.dataSources.defaultDS.entities.ResumeRecord;
+        
+        variable1.resumeid = resumeid;
+        variable1.remark = remark;
+        app.dataSources.defaultDS.entities.ResumeRecord.logics.create(                variable1);
+        return;
+    }
+}

package/out/debug/apps/e6010227-5156-4788-84a8-da284582cf6f/embedded/demo/logics/createWorkHourRecord.ts

@@ -0,0 +1,9 @@
+namespace app.logics {
+    export function createWorkHourRecord(    workHourRecord:     app.dataSources.defaultDS.entities.WorkhourRecord,
+,  __defaultValues?: { 
+workHourRecord: ""}){
+        
+        app.dataSources.defaultDS.entities.WorkhourRecord.logics.create(                workHourRecord);
+        return;
+    }
+}