npm - @lcap/nasl - Versions diffs - 2.17.2 → 2.17.3 - Mend

@lcap/nasl 2.17.2 → 2.17.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1726) hide show

package/sandbox/apps/1d920790-f71b-404f-ab7b-330aee3fc08e/embedded/qzbusstest/views/dashboard/NewPOCDetails.ts ADDED Viewed

@@ -0,0 +1,3010 @@
+namespace app.views.dashboard.views {
+    export namespace NewPOCDetails {
+        export let __bindRoles = [
+        app.roles.DEV_AdminRole.DEV_AdminRole,
+        app.roles.解决方案架构师.解决方案架构师,
+        app.roles.技术支持工程师.技术支持工程师,
+        app.roles.交付项目经理.交付项目经理,
+        app.roles.研发工程师.研发工程师,
+        app.roles.实施工程师.实施工程师,
+        app.roles.客户经理.客户经理,
+        app.roles.项目经理卡点.项目经理卡点,
+        app.roles.sre卡点.sre卡点,
+        app.roles.QA卡点.QA卡点,
+        app.roles.SRE.SRE,
+        app.roles.销售.销售,
+        app.roles.研发项目经理.研发项目经理,
+        app.roles.组件负责人.组件负责人,
+        app.roles.售前.售前,
+        app.roles.环境管理员.环境管理员,
+        app.roles.技术支持卡点.技术支持卡点,
+        app.roles.交付项目经理卡点.交付项目经理卡点,
+        app.roles.版本经理卡点.版本经理卡点,
+        app.roles.QA.QA,
+        ];
+        let jump:     nasl.core.Integer;
+        let id:     nasl.core.Long;
+        let input:     app.dataSources.defaultDS.entities.DeliverInfo;
+        let userInfos:     apis.nuims.structures.ApiReturnOfGetUser;
+        let workOrderNumber:     nasl.core.String;
+        let workOrderOperatingData:     app.dataSources.defaultDS.entities.WorkingOperatingData;
+        let check:     nasl.core.Boolean;
+        let inputProcess:     app.dataSources.defaultDS.entities.WorkingOperatingData;
+        let environmentName:     nasl.core.String;
+        let enInput:     app.dataSources.defaultDS.entities.EnvironmentInfo;
+        let codes:     nasl.core.Long;
+        let projectInfo:     app.dataSources.defaultDS.entities.ProjectInfo;
+        let environInfo:     app.dataSources.defaultDS.entities.EnvironmentInfo;
+        let pocState:     nasl.core.Integer;
+        let environcode:     nasl.core.String;
+interface __elements {
+        lRoot1: nasl.ui.lRoot<any>;
+        uRouterView1: nasl.ui.uRouterView<any>;
+        linear_layout1: nasl.ui.uLinearLayout<any>;
+        linear_layout2: nasl.ui.uLinearLayout<any>;
+        crumb1: nasl.ui.uCrumb<any>;
+        crumb_item1: nasl.ui.uCrumbItem<any>;
+        crumb_item2: nasl.ui.uCrumbItem<any>;
+        panel1: nasl.ui.uPanel<any>;
+        linear_layout9: nasl.ui.uLinearLayout<any>;
+        linear_layout10: nasl.ui.uLinearLayout<any>;
+        text1: nasl.ui.uText<any>;
+        text2: nasl.ui.uText<any>;
+        linear_layout11: nasl.ui.uLinearLayout<any>;
+        button1: nasl.ui.uButton<any>;
+        button2: nasl.ui.uButton<any>;
+        linear_layout13: nasl.ui.uLinearLayout<any>;
+        panel6: nasl.ui.uPanel<any>;
+        linear_layout12: nasl.ui.uLinearLayout<any>;
+        selectable_steps1: nasl.ui.uSelectableSteps<any>;
+        selectable_step1: nasl.ui.uSelectableStep<any>;
+        selectable_step2: nasl.ui.uSelectableStep<any>;
+        selectable_step3: nasl.ui.uSelectableStep<any>;
+        selectable_step4: nasl.ui.uSelectableStep<any>;
+        selectable_step5: nasl.ui.uSelectableStep<any>;
+        selectable_step6: nasl.ui.uSelectableStep<any>;
+        linear_layout3: nasl.ui.uLinearLayout<any>;
+        grid_layout1: nasl.ui.uGridLayout<any>;
+        grid_layout_row2: nasl.ui.uGridLayoutRow<any>;
+        grid_layout_column7: nasl.ui.uGridLayoutColumn<any>;
+        linear_layout21: nasl.ui.uLinearLayout<any>;
+        linear_layout23: nasl.ui.uLinearLayout<any>;
+        panel3: nasl.ui.uPanel<any>;
+        form1: nasl.ui.uForm<any>;
+        form_group1: nasl.ui.uFormGroup<any>;
+        form_item1: nasl.ui.uFormItem<any>;
+        input1: nasl.ui.uInput<any>;
+        form_item6: nasl.ui.uFormItem<any>;
+        input2: nasl.ui.uInput<any>;
+        form_item5: nasl.ui.uFormItem<any>;
+        select5: nasl.ui.uSelect<nasl.ui.GetItemTypeFromDataSource<typeof loadProjects>>;
+        form_item4: nasl.ui.uFormItem<any>;
+        select6: nasl.ui.uSelect<nasl.ui.GetItemTypeFromDataSource<typeof loadEnvironment>>;
+        link2: nasl.ui.uLink<any>;
+        form_item25: nasl.ui.uFormItem<any>;
+        input6: nasl.ui.uInput<any>;
+        copy1: nasl.ui.uCopy<any>;
+        link3: nasl.ui.uLink<any>;
+        form_item24: nasl.ui.uFormItem<any>;
+        input3: nasl.ui.uInput<any>;
+        form_item3: nasl.ui.uFormItem<any>;
+        date_picker2: nasl.ui.uDatePicker<any>;
+        form_item2: nasl.ui.uFormItem<any>;
+        date_picker1: nasl.ui.uDatePicker<any>;
+        form_item10: nasl.ui.uFormItem<any>;
+        date_picker3: nasl.ui.uDatePicker<any>;
+        form_item9: nasl.ui.uFormItem<any>;
+        date_picker4: nasl.ui.uDatePicker<any>;
+        form_item8: nasl.ui.uFormItem<any>;
+        date_picker5: nasl.ui.uDatePicker<any>;
+        form_item7: nasl.ui.uFormItem<any>;
+        date_picker7: nasl.ui.uDatePicker<any>;
+        form_item12: nasl.ui.uFormItem<any>;
+        select4: nasl.ui.uSelect<nasl.ui.GetItemTypeFromDataSource<typeof app.enums.POCState.toList>>;
+        form_item11: nasl.ui.uFormItem<any>;
+        date_time_picker1: nasl.ui.uDateTimePicker<any>;
+        form_item14: nasl.ui.uFormItem<any>;
+        input4: nasl.ui.uInput<any>;
+        form_item13: nasl.ui.uFormItem<any>;
+        date_time_picker2: nasl.ui.uDateTimePicker<any>;
+        form_group2: nasl.ui.uFormGroup<any>;
+        form_item15: nasl.ui.uFormItem<any>;
+        select3: nasl.ui.uSelect<nasl.ui.GetItemTypeFromDataSource<typeof loadPreSale>>;
+        form_item16: nasl.ui.uFormItem<any>;
+        select1: nasl.ui.uSelect<nasl.ui.GetItemTypeFromDataSource<typeof loadSolution>>;
+        form_item19: nasl.ui.uFormItem<any>;
+        select2: nasl.ui.uSelect<nasl.ui.GetItemTypeFromDataSource<typeof loadImplement>>;
+        grid_layout_column8: nasl.ui.uGridLayoutColumn<any>;
+        linear_layout41: nasl.ui.uLinearLayout<any>;
+        linear_layout42: nasl.ui.uLinearLayout<any>;
+        panel2: nasl.ui.uPanel<any>;
+        linear_layout16: nasl.ui.uLinearLayout<any>;
+        linear_layout35: nasl.ui.uLinearLayout<any>;
+        text6: nasl.ui.uText<any>;
+        form5: nasl.ui.uForm<any>;
+        form_item23: nasl.ui.uFormItem<any>;
+        textarea5: nasl.ui.uTextarea<any>;
+        linear_layout33: nasl.ui.uLinearLayout<any>;
+        text8: nasl.ui.uText<any>;
+        form6: nasl.ui.uForm<any>;
+        form_item26: nasl.ui.uFormItem<any>;
+        textarea3: nasl.ui.uTextarea<any>;
+        linear_layout43: nasl.ui.uLinearLayout<any>;
+        panel5: nasl.ui.uPanel<any>;
+        linear_layout14: nasl.ui.uLinearLayout<any>;
+        linear_layout25: nasl.ui.uLinearLayout<any>;
+        text17: nasl.ui.uText<any>;
+        form4: nasl.ui.uForm<any>;
+        form_item21: nasl.ui.uFormItem<any>;
+        textarea2: nasl.ui.uTextarea<any>;
+        linear_layout39: nasl.ui.uLinearLayout<any>;
+        text21: nasl.ui.uText<any>;
+        form7: nasl.ui.uForm<any>;
+        form_item27: nasl.ui.uFormItem<any>;
+        input5: nasl.ui.uInput<any>;
+        linear_layout40: nasl.ui.uLinearLayout<any>;
+        link1: nasl.ui.uLink<any>;
+        linear_layout8: nasl.ui.uLinearLayout<any>;
+        submitModal: nasl.ui.uModal<any>;
+        template1: nasl.ui.template<any>;
+        linear_layout17: nasl.ui.uLinearLayout<any>;
+        button3: nasl.ui.uButton<any>;
+        button4: nasl.ui.uButton<any>;
+        template2: nasl.ui.template<any>;
+        linear_layout18: nasl.ui.uLinearLayout<any>;
+        text3: nasl.ui.uText<any>;
+        template3: nasl.ui.template<any>;
+        processModal: nasl.ui.uModal<any>;
+        template8: nasl.ui.template<any>;
+        linear_layout15: nasl.ui.uLinearLayout<any>;
+        button10: nasl.ui.uButton<any>;
+        button11: nasl.ui.uButton<any>;
+        template18: nasl.ui.template<any>;
+        linear_layout24: nasl.ui.uLinearLayout<any>;
+        text4: nasl.ui.uText<any>;
+        template19: nasl.ui.template<any>;
+        updateModel: nasl.ui.uModal<any>;
+        template4: nasl.ui.template<any>;
+        linear_layout19: nasl.ui.uLinearLayout<any>;
+        button5: nasl.ui.uButton<any>;
+        button6: nasl.ui.uButton<any>;
+        template5: nasl.ui.template<any>;
+        linear_layout20: nasl.ui.uLinearLayout<any>;
+        form2: nasl.ui.uForm<any>;
+        form_item17: nasl.ui.uFormItem<any>;
+        radios1: nasl.ui.uRadios<any>;
+        radio1: nasl.ui.uRadio<any>;
+        radio2: nasl.ui.uRadio<any>;
+        form_item18: nasl.ui.uFormItem<any>;
+        textarea1: nasl.ui.uTextarea<any>;
+        template6: nasl.ui.template<any>;
+        text5: nasl.ui.uText<any>;
+        createEnvironModal: nasl.ui.uModal<any>;
+        template9: nasl.ui.template<any>;
+        linear_layout37: nasl.ui.uLinearLayout<any>;
+        button7: nasl.ui.uButton<any>;
+        button8: nasl.ui.uButton<any>;
+        template10: nasl.ui.template<any>;
+        linear_layout38: nasl.ui.uLinearLayout<any>;
+        form3: nasl.ui.uForm<any>;
+        form_item28: nasl.ui.uFormItem<any>;
+        select8: nasl.ui.uSelect<nasl.ui.GetItemTypeFromDataSource<typeof loadProjects>>;
+        form_item20: nasl.ui.uFormItem<any>;
+        select7: nasl.ui.uSelect<nasl.ui.GetItemTypeFromDataSource<typeof app.enums.EnvironmentType.toList>>;
+        form_item22: nasl.ui.uFormItem<any>;
+        input7: nasl.ui.uInput<any>;
+        template17: nasl.ui.template<any>;
+        text18: nasl.ui.uText<any>;
+        linear_layout7: nasl.ui.uLinearLayout<any>;
+        panel4: nasl.ui.uPanel<any>;
+        tableView: nasl.ui.uTableView<nasl.ui.GetItemTypeFromDataSource<typeof load>>;
+        table_view_column1: nasl.ui.uTableViewColumn<any>;
+        table_view_column5: nasl.ui.uTableViewColumn<any>;
+        template7: nasl.ui.template<any>;
+        linear_layout22: nasl.ui.uLinearLayout<any>;
+        text7: nasl.ui.uText<any>;
+        table_view_column10: nasl.ui.uTableViewColumn<any>;
+        template12: nasl.ui.template<any>;
+        linear_layout27: nasl.ui.uLinearLayout<any>;
+        text12: nasl.ui.uText<any>;
+        table_view_column11: nasl.ui.uTableViewColumn<any>;
+        template13: nasl.ui.template<any>;
+        linear_layout28: nasl.ui.uLinearLayout<any>;
+        text13: nasl.ui.uText<any>;
+        table_view_column9: nasl.ui.uTableViewColumn<any>;
+        template11: nasl.ui.template<any>;
+        linear_layout26: nasl.ui.uLinearLayout<any>;
+        text11: nasl.ui.uText<any>;
+        table_view_column12: nasl.ui.uTableViewColumn<any>;
+        template14: nasl.ui.template<any>;
+        linear_layout29: nasl.ui.uLinearLayout<any>;
+        text14: nasl.ui.uText<any>;
+        table_view_column13: nasl.ui.uTableViewColumn<any>;
+        template15: nasl.ui.template<any>;
+        linear_layout30: nasl.ui.uLinearLayout<any>;
+        text15: nasl.ui.uText<any>;
+        table_view_column14: nasl.ui.uTableViewColumn<any>;
+        template16: nasl.ui.template<any>;
+        linear_layout31: nasl.ui.uLinearLayout<any>;
+        text16: nasl.ui.uText<any>;
+        linear_layout6: nasl.ui.uLinearLayout<any>;
+        panel7: nasl.ui.uPanel<any>;
+        table_view1: nasl.ui.uTableView<nasl.ui.GetItemTypeFromDataSource<typeof loadWorking>>;
+        table_view_column2: nasl.ui.uTableViewColumn<any>;
+        template20: nasl.ui.template<any>;
+        table_view_column3: nasl.ui.uTableViewColumn<any>;
+        template21: nasl.ui.template<any>;
+        linear_layout32: nasl.ui.uLinearLayout<any>;
+        text9: nasl.ui.uText<any>;
+        table_view_column4: nasl.ui.uTableViewColumn<any>;
+        template22: nasl.ui.template<any>;
+        linear_layout34: nasl.ui.uLinearLayout<any>;
+        text10: nasl.ui.uText<any>;
+        table_view_column6: nasl.ui.uTableViewColumn<any>;
+        template23: nasl.ui.template<any>;
+        linear_layout36: nasl.ui.uLinearLayout<any>;
+        text19: nasl.ui.uText<any>;
+        table_view_column7: nasl.ui.uTableViewColumn<any>;
+        template24: nasl.ui.template<any>;
+        linear_layout44: nasl.ui.uLinearLayout<any>;
+        text20: nasl.ui.uText<any>;
+        table_view_column8: nasl.ui.uTableViewColumn<any>;
+        template25: nasl.ui.template<any>;
+        linear_layout45: nasl.ui.uLinearLayout<any>;
+        text22: nasl.ui.uText<any>;
+        table_view_column15: nasl.ui.uTableViewColumn<any>;
+        template26: nasl.ui.template<any>;
+        linear_layout46: nasl.ui.uLinearLayout<any>;
+        text23: nasl.ui.uText<any>;
+        table_view_column16: nasl.ui.uTableViewColumn<any>;
+        template27: nasl.ui.template<any>;
+        linear_layout47: nasl.ui.uLinearLayout<any>;
+        text24: nasl.ui.uText<any>;
+        table_view_column17: nasl.ui.uTableViewColumn<any>;
+        template28: nasl.ui.template<any>;
+        linear_layout48: nasl.ui.uLinearLayout<any>;
+        text25: nasl.ui.uText<any>;
+        table_view_column18: nasl.ui.uTableViewColumn<any>;
+        template29: nasl.ui.template<any>;
+        linear_layout49: nasl.ui.uLinearLayout<any>;
+        text26: nasl.ui.uText<any>;
+        linear_layout5: nasl.ui.uLinearLayout<any>;
+        linear_layout4: nasl.ui.uLinearLayout<any>;
+        }
+let __elements: __elements;
+                    function loadProjects(params:             nasl.ui.DataSourceParams): nasl.collection.PageOf<app.structures.LoadProjectsStructure>{
+                let name:             nasl.core.String;
+                let result:             nasl.collection.PageOf<app.structures.LoadProjectsStructure>;
+                name = params.filterText;
+                result = app.logics.loadProjects(                                params.page,                                 params.size,                                 app.enums.ProjectType['Normal'],                                 name,                                 app.enums.ProjectPhase['PreSale']);
+;
+                return result;
+            }
+            function loadUser(userId:             nasl.core.String, userName:             nasl.core.String){
+                userInfos = apis.nuims.interfaces.GetUser({                UserName:                userName,                 UserId:                userId});
+;
+                return;
+            }
+            function loadPage(){
+                let pageof:             nasl.collection.PageOf<app.structures.LoadOperatingDataForWorkOrderStructure>;
+                let variable1:             app.structures.LoadOperatingDataForWorkOrderStructure;
+if (nasl.core.ensureBoolean(                    jump == new nasl.core.Integer(0))) {
+                    loadUser(                                        nasl.auth.userInfo.UserId,                                         null);
+                    input.createdBy = userInfos.Data.UserId;
+                    input.createName = userInfos.Data.UserInfoExtend.NickName;
+                    input.workOrderType = app.enums.WorkOrderType['POCWorkOrder'];
+                    input.pocState = app.enums.POCState['NewCreate'];
+                    input.solutionEngagement = new nasl.core.Integer(1);
+                }
+if (nasl.core.ensureBoolean(                    jump == new nasl.core.Integer(1))) {
+                    input = app.dataSources.defaultDS.entities.DeliverInfo.logics.get(                                        id);
+;
+                    __elements.tableView.load();
+                    projectInfo = app.dataSources.defaultDS.entities.ProjectInfo.logics.get(                                        input.projectId);
+;
+                    __elements.table_view1.load();
+                    if (nasl.core.ensureBoolean(nasl.util.Convert(input.environmentid)<nasl.core.Boolean>())) {
+                        environInfo = app.dataSources.defaultDS.entities.EnvironmentInfo.logics.get(                                                input.environmentid);
+;
+                        environcode = environInfo.environcode;
+                    } else {
+                    }
+                    pageof = app.logics.loadOperatingDataForWorkOrder(                                        null,                                         null,                                         input.workOrderNumber,                                         null,                                         app.enums.ReviewState['NotAudit']);
+;
+                    if (nasl.core.ensureBoolean(pageof.empty)) {
+                    } else {
+                        variable1 = nasl.util.Get(pageof.content, new nasl.core.Integer(0));
+                        workOrderOperatingData = nasl.util.Clone(variable1.workingOperatingData);
+                    }
+                    loadCheck();
+if (nasl.core.ensureBoolean(                        input.pocState == app.enums.POCState['NewCreate'])) {
+                        pocState = new nasl.core.Integer(0);
+                    }
+if (nasl.core.ensureBoolean(                        input.pocState == app.enums.POCState['ManpowerScheduling'])) {
+                        pocState = new nasl.core.Integer(1);
+                    }
+if (nasl.core.ensureBoolean(                        input.pocState == app.enums.POCState['EnvironmentDeploy'])) {
+                        pocState = new nasl.core.Integer(2);
+                    }
+if (nasl.core.ensureBoolean(                        input.pocState == app.enums.POCState['OnGoing'])) {
+                        pocState = new nasl.core.Integer(3);
+                    }
+if (nasl.core.ensureBoolean(                        input.pocState == app.enums.POCState['Review'])) {
+                        pocState = new nasl.core.Integer(4);
+                    }
+else {
+                    }
+                }
+else {
+                }
+                nasl.util.consoleLog(                                input.pocState);
+                nasl.util.consoleLog(                                input.solutionEngagement);
+                return;
+            }
+            function loadPreSaleName(){
+                let apiReturn:             apis.nuims.structures.ApiReturnOfGetUser;
+                apiReturn = apis.nuims.interfaces.GetUser({                UserName:                null,                 UserId:                input.preSaleUserId});
+;
+                input.preSaleNickName = apiReturn.Data.UserInfoExtend.NickName;
+                return;
+            }
+            function loadSolutionName(){
+                let apiReturn:             apis.nuims.structures.ApiReturnOfGetUser;
+                apiReturn = apis.nuims.interfaces.GetUser({                UserName:                null,                 UserId:                input.solutionUserId});
+;
+                input.solutionNickName = apiReturn.Data.UserInfoExtend.NickName;
+                return;
+            }
+            function loadImplementName(){
+                let apiReturn:             apis.nuims.structures.ApiReturnOfGetUser;
+                apiReturn = apis.nuims.interfaces.GetUser({                UserName:                null,                 UserId:                input.implementUserId});
+;
+                input.implementnickname = apiReturn.Data.UserInfoExtend.NickName;
+                return;
+            }
+            function loadPreSale(): nasl.collection.List<apis.nuims.structures.LcpUserInfo>{
+                let apiReturn:             apis.nuims.structures.ApiReturnOfLcpGetUsersForRole;
+                let result:             nasl.collection.List<apis.nuims.structures.LcpUserInfo>;
+                apiReturn = apis.nuims.interfaces.LcpGetUsersForRole({                DomainName:                'StringLiteral',                 RoleName:                'StringLiteral',                 UserName:                null,                 Offset:                null,                 Limit:                null});
+;
+                result = apiReturn.Data;
+                return result;
+            }
+            function loadSolution(): nasl.collection.List<apis.nuims.structures.LcpUserInfo>{
+                let apiReturn:             apis.nuims.structures.ApiReturnOfLcpGetUsersForRole;
+                let result:             nasl.collection.List<apis.nuims.structures.LcpUserInfo>;
+                apiReturn = apis.nuims.interfaces.LcpGetUsersForRole({                DomainName:                'StringLiteral',                 RoleName:                'StringLiteral',                 UserName:                null,                 Offset:                null,                 Limit:                null});
+;
+                result = apiReturn.Data;
+                return result;
+            }
+            function loadImplement(): nasl.collection.List<apis.nuims.structures.LcpUserInfo>{
+                let apiReturn:             apis.nuims.structures.ApiReturnOfLcpGetUsersForRole;
+                let result:             nasl.collection.List<apis.nuims.structures.LcpUserInfo>;
+                apiReturn = apis.nuims.interfaces.LcpGetUsersForRole({                DomainName:                'StringLiteral',                 RoleName:                'StringLiteral',                 UserName:                null,                 Offset:                null,                 Limit:                null});
+;
+                result = apiReturn.Data;
+                return result;
+            }
+            function submit(){
+                let validateResult:             nasl.ui.ValidateEvent;
+                let apiReturn:             app.dataSources.defaultDS.entities.DeliverInfo;
+                validateResult = __elements.form1.validate(                                'StringLiteral',                 undefined);
+;
+                if (nasl.core.ensureBoolean(validateResult.valid)) {
+                    if (nasl.core.ensureBoolean(nasl.util.Convert(input.id)<nasl.core.Boolean>())) {
+                        app.dataSources.defaultDS.entities.DeliverInfo.logics.update(                                                input);
+                        nasl.ui.showMessage(                                                'StringLiteral');
+                    } else {
+                        nasl.util.consoleLog(                                                'StringLiteral');
+                        loadWorkOrderNumber();
+                        nasl.util.consoleLog(                                                'StringLiteral');
+                        input.workOrderNumber = workOrderNumber;
+                        nasl.util.consoleLog(                                                'StringLiteral');
+                        apiReturn = app.dataSources.defaultDS.entities.DeliverInfo.logics.create(                                                input);
+;
+                        nasl.util.consoleLog(                                                'StringLiteral');
+                        createProcess();
+                        nasl.util.consoleLog(                                                'StringLiteral');
+                        id = apiReturn.id;
+                        nasl.util.consoleLog(                                                'StringLiteral');
+                        jump = new nasl.core.Integer(1);
+                        nasl.ui.showMessage(                                                'StringLiteral');
+                    }
+                    __elements.submitModal.close();
+                    nasl.util.consoleLog(                                        'StringLiteral');
+                    loadPage();
+                    nasl.util.consoleLog(                                        'StringLiteral');
+                } else {
+                    __elements.submitModal.close();
+                }
+                return;
+            }
+            function loadWorkOrderNumber(){
+                let pageofDeliver:             nasl.collection.PageOf<app.structures.LoadDeliverStructure>;
+                let number:             nasl.core.Integer;
+                let numberString:             nasl.core.String;
+                pageofDeliver = app.logics.loadDeliver(                                null,                                 null,                                 null,                                 null,                                 null);
+;
+                number = nasl.core.add(pageofDeliver.totalElements,new nasl.core.Integer(1));
+                numberString = nasl.util.Convert(number)<nasl.core.String>();
+                while (nasl.core.ensureBoolean(nasl.util.Length(numberString) < new nasl.core.Integer(4))) {
+                    numberString = nasl.util.Concat('StringLiteral', numberString);
+                }
+                workOrderNumber = nasl.core.add('StringLiteral',nasl.util.Concat(nasl.util.FormatDate(nasl.util.CurrDate(), 'StringLiteral'), numberString));
+                return;
+            }
+            function loadEnvironment(params:             nasl.ui.DataSourceParams): nasl.collection.PageOf<app.structures.LoadEnvironmentInfoStructure>{
+                let code:             nasl.core.String;
+                let result:             nasl.collection.PageOf<app.structures.LoadEnvironmentInfoStructure>;
+                code = params.filterText;
+                result = app.logics.loadEnvironmentInfo(                                params.page,                                 params.size,                                 input.projectId,                                 code);
+;
+                return result;
+            }
+            function load(params:             nasl.ui.DataSourceParams): nasl.collection.PageOf<app.structures.LoadNewPOCDetailsTableViewStructure>{
+                let result:             nasl.collection.PageOf<app.structures.LoadNewPOCDetailsTableViewStructure>;
+                result = app.logics.loadNewPOCDetailsTableView(                                params.page,                                 params.size,                                 params.sort,                                 params.order,                                 input.workOrderNumber);
+;
+                nasl.util.consoleLog(                                input.workOrderNumber);
+                return result;
+            }
+            function createProcess(){
+                let processInfo:             app.dataSources.defaultDS.entities.WorkingOperatingData;
+                let sendEmail:             apis.nuims.structures.SendEmailBody;
+if (nasl.core.ensureBoolean(                    input.pocState == app.enums.POCState['NewCreate'])) {
+                    processInfo.operation = 'StringLiteral';
+                    loadUser(                                        input.createdBy,                                         null);
+                }
+if (nasl.core.ensureBoolean(                    input.pocState == app.enums.POCState['ManpowerScheduling'])) {
+                    processInfo.operation = 'StringLiteral';
+                    loadUser(                                        null,                                         'StringLiteral');
+                    sendEmail.Subject = 'StringLiteral';
+                    sendEmail.Content = nasl.core.add('StringLiteral',nasl.core.add(projectInfo.name,'StringLiteral'));
+                    nasl.util.Add(sendEmail.ReceiverList, userInfos.Data.Email)
+                    apis.nuims.interfaces.SendEmail({                    Body:                    sendEmail});
+                }
+if (nasl.core.ensureBoolean(                    input.pocState == app.enums.POCState['EnvironmentDeploy'])) {
+                    processInfo.operation = 'StringLiteral';
+                    loadUser(                                        input.implementUserId,                                         null);
+                    sendEmail.Subject = 'StringLiteral';
+                    sendEmail.Content = nasl.core.add('StringLiteral',nasl.core.add(projectInfo.name,nasl.core.add('StringLiteral',nasl.core.add(environInfo.environcode,nasl.core.add('StringLiteral',nasl.core.add(nasl.util.FormatDate(input.planstartDate, 'StringLiteral'),nasl.core.add('StringLiteral',nasl.core.add(nasl.util.FormatDate(input.planendDate, 'StringLiteral'),'StringLiteral'))))))));
+                    nasl.util.Add(sendEmail.ReceiverList, userInfos.Data.Email)
+                    apis.nuims.interfaces.SendEmail({                    Body:                    sendEmail});
+                }
+if (nasl.core.ensureBoolean(                    input.pocState == app.enums.POCState['OnGoing'])) {
+                    if (nasl.core.ensureBoolean(input.solutionEngagement == new nasl.core.Integer(1))) {
+                        processInfo.operation = 'StringLiteral';
+                        loadUser(                                                input.preSaleUserId,                                                 null);
+                        sendEmail.Subject = 'StringLiteral';
+                        sendEmail.Content = nasl.core.add(projectInfo.name,'StringLiteral');
+                        nasl.util.Add(sendEmail.ReceiverList, userInfos.Data.Email)
+                    } else {
+                        processInfo.operation = 'StringLiteral';
+                        loadUser(                                                input.solutionUserId,                                                 null);
+                        sendEmail.Subject = 'StringLiteral';
+                        sendEmail.Content = nasl.core.add(projectInfo.name,'StringLiteral');
+                        nasl.util.Add(sendEmail.ReceiverList, userInfos.Data.Email)
+                    }
+                    apis.nuims.interfaces.SendEmail({                    Body:                    sendEmail});
+                }
+if (nasl.core.ensureBoolean(                    input.pocState == app.enums.POCState['Review'])) {
+                    processInfo.operation = 'StringLiteral';
+                    loadUser(                                        input.createdBy,                                         null);
+                    sendEmail.Subject = 'StringLiteral';
+                    sendEmail.Content = nasl.core.add(projectInfo.name,'StringLiteral');
+                    nasl.util.Add(sendEmail.ReceiverList, userInfos.Data.Email)
+                    apis.nuims.interfaces.SendEmail({                    Body:                    sendEmail});
+                    loadSend();
+                }
+else {
+                }
+                processInfo.auditorId = userInfos.Data.UserId;
+                processInfo.auditorName = userInfos.Data.UserInfoExtend.NickName;
+                processInfo.operationDate = nasl.util.CurrDateTime();
+                processInfo.reviewState = app.enums.ReviewState['NotAudit'];
+                processInfo.workOrderNumber = input.workOrderNumber;
+                processInfo.correspondingTable = 'StringLiteral';
+                app.dataSources.defaultDS.entities.WorkingOperatingData.logics.create(                                processInfo);
+                return;
+            }
+            function updateProcess(){
+                let processInfo:             app.dataSources.defaultDS.entities.WorkingOperatingData;
+                let validateResult:             nasl.ui.ValidateEvent;
+                validateResult = __elements.form1.validate(                                'StringLiteral',                 undefined);
+;
+                if (nasl.core.ensureBoolean(validateResult.valid)) {
+                    validateResult = __elements.form2.validate(                                        'StringLiteral',                     undefined);
+;
+                    if (nasl.core.ensureBoolean(validateResult.valid)) {
+                        validateResult = __elements.form4.validate(                                                'StringLiteral',                         undefined);
+;
+                        if (nasl.core.ensureBoolean(validateResult.valid)) {
+                            validateResult = __elements.form5.validate(                                                        'StringLiteral',                             undefined);
+;
+                            if (nasl.core.ensureBoolean(validateResult.valid)) {
+                                validateResult = __elements.form6.validate(                                                                'StringLiteral',                                 undefined);
+;
+                                if (nasl.core.ensureBoolean(validateResult.valid)) {
+                                    validateResult = __elements.form7.validate(                                                                        'StringLiteral',                                     undefined);
+;
+                                    if (nasl.core.ensureBoolean(validateResult.valid)) {
+                                        inputProcess.reviewState = app.enums.ReviewState['Audited'];
+                                        inputProcess.reviewDate = nasl.util.CurrDateTime();
+                                        app.dataSources.defaultDS.entities.WorkingOperatingData.logics.update(                                                                                inputProcess);
+                                        __elements.updateModel.close();
+                                        ifProcess();
+                                    } else {
+                                        __elements.updateModel.close();
+                                    }
+                                } else {
+                                    __elements.updateModel.close();
+                                }
+                            } else {
+                                __elements.updateModel.close();
+                            }
+                        } else {
+                            __elements.updateModel.close();
+                        }
+                    } else {
+                        __elements.updateModel.close();
+                    }
+                } else {
+                    __elements.updateModel.close();
+                }
+                return;
+            }
+            function loadCheck(){
+                if (nasl.core.ensureBoolean(workOrderOperatingData.auditorId == nasl.auth.userInfo.UserId)) {
+                    check = true;
+                } else {
+                    check = false;
+                }
+                return;
+            }
+            function onClick(){
+                inputProcess = nasl.util.Clone(workOrderOperatingData);
+                if (nasl.core.ensureBoolean(input.pocState == app.enums.POCState['NewCreate'])) {
+                    __elements.processModal.open();
+                } else {
+                    __elements.updateModel.open();
+                }
+                return;
+            }
+            function ifProcess(){
+                let variable1:             nasl.core.String;
+                if (nasl.core.ensureBoolean(inputProcess.reviewResults == app.enums.ReviewResults['Pass'])) {
+                    if (nasl.core.ensureBoolean(input.pocState == app.enums.POCState['NewCreate'])) {
+                        input.pocState = app.enums.POCState['ManpowerScheduling'];
+                    } else {
+                        if (nasl.core.ensureBoolean(input.pocState == app.enums.POCState['ManpowerScheduling'])) {
+                            input.pocState = app.enums.POCState['EnvironmentDeploy'];
+                        } else {
+                            if (nasl.core.ensureBoolean(input.pocState == app.enums.POCState['EnvironmentDeploy'])) {
+                                input.pocState = app.enums.POCState['OnGoing'];
+                            } else {
+                                if (nasl.core.ensureBoolean(input.pocState == app.enums.POCState['OnGoing'])) {
+                                    if (nasl.core.ensureBoolean(input.solutionEngagement == new nasl.core.Integer(1))) {
+                                        if (nasl.core.ensureBoolean(input.solutionUserId == variable1)) {
+                                            input.pocState = app.enums.POCState['Review'];
+                                        } else {
+                                            input.solutionEngagement = new nasl.core.Integer(2);
+                                        }
+                                    } else {
+                                        input.pocState = app.enums.POCState['Review'];
+                                    }
+                                } else {
+                                    if (nasl.core.ensureBoolean(input.pocState == app.enums.POCState['Review'])) {
+                                    } else {
+                                        input.pocState = app.enums.POCState['Closure'];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    app.dataSources.defaultDS.entities.DeliverInfo.logics.update(                                        input);
+                } else {
+if (nasl.core.ensureBoolean(                        input.pocState == app.enums.POCState['ManpowerScheduling'])) {
+                        input.pocState = app.enums.POCState['NewCreate'];
+                    }
+if (nasl.core.ensureBoolean(                        input.pocState == app.enums.POCState['EnvironmentDeploy'])) {
+                        input.pocState = app.enums.POCState['ManpowerScheduling'];
+                    }
+if (nasl.core.ensureBoolean(                        input.pocState == app.enums.POCState['OnGoing'])) {
+                        if (nasl.core.ensureBoolean(input.solutionEngagement == new nasl.core.Integer(1))) {
+                            if (nasl.core.ensureBoolean(input.solutionUserId == variable1)) {
+                                input.pocState = app.enums.POCState['EnvironmentDeploy'];
+                            } else {
+                                input.solutionEngagement = new nasl.core.Integer(1);
+                            }
+                        } else {
+                            input.solutionEngagement = new nasl.core.Integer(1);
+                        }
+                    }
+if (nasl.core.ensureBoolean(                        input.pocState == app.enums.POCState['Review'])) {
+                        if (nasl.core.ensureBoolean(input.solutionEngagement == new nasl.core.Integer(1))) {
+                            if (nasl.core.ensureBoolean(input.solutionUserId == variable1)) {
+                                input.pocState = app.enums.POCState['OnGoing'];
+                            } else {
+                                input.pocState = app.enums.POCState['OnGoing'];
+                            }
+                        } else {
+                            input.pocState = app.enums.POCState['OnGoing'];
+                        }
+                    }
+else {
+                    }
+                    app.dataSources.defaultDS.entities.DeliverInfo.logics.update(                                        input);
+                }
+                createProcess();
+                loadPage();
+                return;
+            }
+            function createEnvironment(){
+                let environmentInfo:             app.dataSources.defaultDS.entities.EnvironmentInfo;
+                enInput = nasl.util.Clone(environmentInfo);
+                enInput.projectinfoid = input.projectId;
+                enInput.type = app.enums.EnvironmentType['POC'];
+                enInput.status = app.enums.EnvironmentStatus['TobeDeploy'];
+                __elements.createEnvironModal.open();
+                return;
+            }
+            function submitEnvironment(){
+                let validateResult:             nasl.ui.ValidateEvent;
+                let apireturn:             app.dataSources.defaultDS.entities.EnvironmentInfo;
+                validateResult = __elements.form3.validate();
+;
+                if (nasl.core.ensureBoolean(validateResult.valid)) {
+                    loadEnvironmentCode();
+                    apireturn = app.dataSources.defaultDS.entities.EnvironmentInfo.logics.create(                                        enInput);
+;
+                    input.environmentid = apireturn.id;
+                    __elements.select6.reload();
+                    __elements.createEnvironModal.close();
+                    nasl.ui.showMessage(                                        nasl.core.add('StringLiteral',nasl.core.add(apireturn.name,'StringLiteral')));
+                    logic1();
+                } else {
+                }
+                return;
+            }
+            function loadEnvironmentCode(){
+                let listStr:             nasl.collection.List<app.structures.StructureInfo>;
+                let strInfo:             app.structures.StructureInfo;
+                let num:             nasl.core.Integer;
+                let listNum:             nasl.collection.List<nasl.core.Integer>;
+                let listNumss:             nasl.collection.List<nasl.core.Integer>;
+                let boober:             nasl.core.Boolean;
+                listStr = app.logics.loadEnvironmentCode(                                app.enums.EnvironmentType['POC']);
+;
+                listStr.__slice(                new nasl.core.Integer(0),                 listStr.length).__forEach((item, index) => {
+                    strInfo.strings = nasl.util.Replace(item.strings, 'StringLiteral', 'StringLiteral');
+                    nasl.util.Add(listNum, nasl.util.Convert(strInfo.strings)<nasl.core.Integer>())
+                })
+                listNum.__slice(                new nasl.core.Integer(0),                 listNum.length).__forEach((item, index) => {
+                    if (nasl.core.ensureBoolean(listNumss.length == new nasl.core.Integer(0))) {
+                        nasl.util.Add(listNumss, item)
+                    } else {
+                        boober = true;
+                        listNumss.__slice(                        new nasl.core.Integer(0),                         listNumss.length).__forEach((item1, index1) => {
+                            if (nasl.core.ensureBoolean(boober == true)) {
+                                if (nasl.core.ensureBoolean(item >= item1)) {
+                                    nasl.util.Insert(listNumss, index1, item)
+                                    boober = false;
+                                } else {
+                                    boober = true;
+                                }
+                            } else {
+                            }
+                        })
+                        if (nasl.core.ensureBoolean(boober == true)) {
+                            nasl.util.Add(listNumss, item)
+                        } else {
+                        }
+                    }
+                })
+                num = nasl.util.Get(listNumss, new nasl.core.Integer(0));
+                if (nasl.core.ensureBoolean(nasl.core.add(num,new nasl.core.Integer(1)) == new nasl.core.Integer(92))) {
+                    num = nasl.core.add(num,new nasl.core.Integer(2));
+                } else {
+                    if (nasl.core.ensureBoolean(nasl.core.add(num,new nasl.core.Integer(1)) == new nasl.core.Integer(121))) {
+                        num = nasl.core.add(num,new nasl.core.Integer(2));
+                    } else {
+                        num = nasl.core.add(num,new nasl.core.Integer(1));
+                    }
+                }
+                enInput.environcode = nasl.core.add('StringLiteral',nasl.util.Convert(num)<nasl.core.String>());
+                return;
+            }
+            function logic1(){
+                input.environmentid = codes;
+                return;
+            }
+            function submitProcess(){
+                inputProcess.reviewResults = app.enums.ReviewResults['Pass'];
+                inputProcess.reviewState = app.enums.ReviewState['Audited'];
+                inputProcess.reviewDate = nasl.util.CurrDateTime();
+                app.dataSources.defaultDS.entities.WorkingOperatingData.logics.update(                                inputProcess);
+                __elements.processModal.close();
+                ifProcess();
+                return;
+            }
+            function loadSend(){
+                let sendBody:             apis.nuims.structures.SendEmailBody;
+                let userInfo:             apis.nuims.structures.ApiReturnOfLcpGetUsersForRole;
+                sendBody.Subject = nasl.core.add(projectInfo.name,'StringLiteral');
+                sendBody.Content = nasl.core.add(projectInfo.name,nasl.core.add('StringLiteral',nasl.core.add(input.createName,'StringLiteral')));
+                userInfo = apis.nuims.interfaces.LcpGetUsersForRole({                DomainName:                'StringLiteral',                 RoleName:                'StringLiteral',                 UserName:                null,                 Offset:                null,                 Limit:                null});
+;
+                userInfo.Data.__slice(                new nasl.core.Integer(0),                 userInfo.Data.length).__forEach((item, index) => {
+                    nasl.util.Add(sendBody.ReceiverList, item.Email)
+                })
+                apis.nuims.interfaces.SendEmail({                Body:                sendBody});
+                return;
+            }
+            function onSelect(){
+                let variable1:             app.dataSources.defaultDS.entities.EnvironmentInfo;
+                variable1 = app.dataSources.defaultDS.entities.EnvironmentInfo.logics.get(                                input.environmentid);
+;
+                environcode = variable1.environcode;
+                return;
+            }
+            function loadWorking(params:             nasl.ui.DataSourceParams): nasl.collection.PageOf<app.structures.LoadWorkingListStructure>{
+                let result:             nasl.collection.PageOf<app.structures.LoadWorkingListStructure>;
+                result = app.logics.loadWorkingList(                                params.page,                                 params.size,                                 input.workOrderNumber);
+;
+                return result;
+            }
+            loadPage();
+        export function __render(){
+                    __elements.lRoot1 = new nasl.ui.lRoot({
+                    bindAttr: () => [
+                        ],
+slotDefault: ()=> [
+                        __elements.uRouterView1 = new nasl.ui.uRouterView({
+                            bindAttr: () => [
+                                ],
+slotDefault: ()=> [
+                            ]
+                        }),
+                        __elements.linear_layout1 = new nasl.ui.uLinearLayout({
+                            bindAttr: () => [
+                                ],
+slotDefault: ()=> [
+                                __elements.linear_layout2 = new nasl.ui.uLinearLayout({
+                                    bindAttr: () => [
+                                        ],
+slotDefault: ()=> [
+                                        __elements.crumb1 = new nasl.ui.uCrumb({
+                                            bindAttr: () => [
+                                                ],
+slotDefault: ()=> [
+                                                __elements.crumb_item1 = new nasl.ui.uCrumbItem({
+                                                destination: () => {
+                                                        app.views.dashboard.views.NewPOCList.$destination({});
+                                                    },
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                    ]
+                                                }),
+                                                __elements.crumb_item2 = new nasl.ui.uCrumbItem({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                        __elements.panel1 = new nasl.ui.uPanel({
+                                            bindAttr: () => [
+                                                ],
+slotDefault: ()=> [
+                                                __elements.linear_layout9 = new nasl.ui.uLinearLayout({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.linear_layout10 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.text1 = new nasl.ui.uText({
+                                                                    bindAttr: () => [
+                                                                        jump == new nasl.core.Integer(0),
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.text2 = new nasl.ui.uText({
+                                                                    bindAttr: () => [
+                                                                        jump == new nasl.core.Integer(1),
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.linear_layout11 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.button1 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {__elements.submitModal.open()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        input.pocState == app.enums.POCState['NewCreate'],
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.button2 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {onClick()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        nasl.core.and(jump == new nasl.core.Integer(1),check == true),
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                    ]
+                                }),
+                                __elements.linear_layout13 = new nasl.ui.uLinearLayout({
+                                    bindAttr: () => [
+                                        ],
+slotDefault: ()=> [
+                                        __elements.panel6 = new nasl.ui.uPanel({
+                                            bindAttr: () => [
+                                                ],
+slotDefault: ()=> [
+                                                __elements.linear_layout12 = new nasl.ui.uLinearLayout({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.selectable_steps1 = new nasl.ui.uSelectableSteps({
+                                                            bindAttr: () => [
+                                                                pocState,
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.selectable_step1 = new nasl.ui.uSelectableStep({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.selectable_step2 = new nasl.ui.uSelectableStep({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.selectable_step3 = new nasl.ui.uSelectableStep({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.selectable_step4 = new nasl.ui.uSelectableStep({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.selectable_step5 = new nasl.ui.uSelectableStep({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.selectable_step6 = new nasl.ui.uSelectableStep({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                    ]
+                                }),
+                                __elements.linear_layout3 = new nasl.ui.uLinearLayout({
+                                    bindAttr: () => [
+                                        ],
+slotDefault: ()=> [
+                                        __elements.grid_layout1 = new nasl.ui.uGridLayout({
+                                            bindAttr: () => [
+                                                ],
+slotDefault: ()=> [
+                                                __elements.grid_layout_row2 = new nasl.ui.uGridLayoutRow({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.grid_layout_column7 = new nasl.ui.uGridLayoutColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.linear_layout21 = new nasl.ui.uLinearLayout({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout23 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.panel3 = new nasl.ui.uPanel({
+                                                                                    bindAttr: () => [
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                        __elements.form1 = new nasl.ui.uForm({
+                                                                                            bindAttr: () => [
+                                                                                                ],
+slotDefault: ()=> [
+                                                                                                __elements.form_group1 = new nasl.ui.uFormGroup({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.form_item1 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.input1 = new nasl.ui.uInput({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.workOrderNumber,
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item6 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.input2 = new nasl.ui.uInput({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.description,
+                                                                                                                        input.pocState != app.enums.POCState['NewCreate'],
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item5 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.select5 = new nasl.ui.uSelect({
+                                                                                                                        select: (event: any) => [
+                                                                                                                            () => {__elements.select6.reload()}
+                                                                                                                        ],
+                                                                                                                        change: (event: any) => [
+                                                                                                                            () => {__elements.select6.reload()}
+                                                                                                                        ],
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.projectId,
+                                                                                                                        loadProjects,
+                                                                                                                        input.pocState != app.enums.POCState['NewCreate'],
+                                                                                                                        ],
+slotDefault: (scope)=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item4 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.select6 = new nasl.ui.uSelect({
+                                                                                                                        select: (event: any) => [
+                                                                                                                            () => {onSelect()}
+                                                                                                                        ],
+                                                                                                                        change: (event: any) => [
+                                                                                                                            () => {onSelect()}
+                                                                                                                        ],
+                                                                                                                    bindAttr: () => [
+                                                                                                                        loadEnvironment,
+                                                                                                                        input.environmentid,
+                                                                                                                        input.pocState != app.enums.POCState['NewCreate'],
+                                                                                                                        ],
+slotDefault: (scope)=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                                __elements.link2 = new nasl.ui.uLink({
+                                                                                                                        click: (event: any) => [
+                                                                                                                            () => {createEnvironment()}
+                                                                                                                        ],
+                                                                                                                    bindAttr: () => [
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item25 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.input6 = new nasl.ui.uInput({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.pocInformation,
+                                                                                                                        input.pocState != app.enums.POCState['NewCreate'],
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                                __elements.copy1 = new nasl.ui.uCopy({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.pocInformation,
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                        __elements.link3 = new nasl.ui.uLink({
+                                                                                                                            bindAttr: () => [
+                                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                            ]
+                                                                                                                        }),
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item24 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.input3 = new nasl.ui.uInput({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        environcode,
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item3 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.date_picker2 = new nasl.ui.uDatePicker({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.expectStartDate,
+                                                                                                                        input.expectEndDate,
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item2 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.date_picker1 = new nasl.ui.uDatePicker({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.expectEndDate,
+                                                                                                                        input.expectStartDate,
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item10 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                input.pocState != app.enums.POCState['NewCreate'],
+                                                                                                        null,
+                                                                                                                input.pocState == app.enums.POCState['NewCreate'],
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.date_picker3 = new nasl.ui.uDatePicker({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.planstartDate,
+                                                                                                                        input.planendDate,
+                                                                                                                        input.pocState == app.enums.POCState['NewCreate'],
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item9 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                input.pocState != app.enums.POCState['NewCreate'],
+                                                                                                        null,
+                                                                                                                input.pocState == app.enums.POCState['NewCreate'],
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.date_picker4 = new nasl.ui.uDatePicker({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.planendDate,
+                                                                                                                        input.planstartDate,
+                                                                                                                        input.pocState == app.enums.POCState['NewCreate'],
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item8 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                nasl.core.and(input.pocState != app.enums.POCState['NewCreate'],input.pocState != app.enums.POCState['ManpowerScheduling']),
+                                                                                                        null,
+                                                                                                                nasl.core.or(input.pocState == app.enums.POCState['NewCreate'],input.pocState == app.enums.POCState['ManpowerScheduling']),
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.date_picker5 = new nasl.ui.uDatePicker({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.startDate,
+                                                                                                                        input.endDate,
+                                                                                                                        nasl.core.or(input.pocState == app.enums.POCState['NewCreate'],input.pocState == app.enums.POCState['ManpowerScheduling']),
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item7 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                nasl.core.and(input.pocState != app.enums.POCState['NewCreate'],input.pocState != app.enums.POCState['ManpowerScheduling']),
+                                                                                                        null,
+                                                                                                                nasl.core.or(input.pocState == app.enums.POCState['NewCreate'],input.pocState == app.enums.POCState['ManpowerScheduling']),
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.date_picker7 = new nasl.ui.uDatePicker({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.endDate,
+                                                                                                                        input.startDate,
+                                                                                                                        nasl.core.or(input.pocState == app.enums.POCState['NewCreate'],input.pocState == app.enums.POCState['ManpowerScheduling']),
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item12 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.select4 = new nasl.ui.uSelect({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        app.enums.POCState.toList,
+                                                                                                                        input.pocState,
+                                                                                                                        ],
+slotDefault: (scope)=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item11 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.date_time_picker1 = new nasl.ui.uDateTimePicker({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.updatedTime,
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item14 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.input4 = new nasl.ui.uInput({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.createName,
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item13 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.date_time_picker2 = new nasl.ui.uDateTimePicker({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.createdTime,
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                                __elements.form_group2 = new nasl.ui.uFormGroup({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.form_item15 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.select3 = new nasl.ui.uSelect({
+                                                                                                                        select: (event: any) => [
+                                                                                                                            () => {loadPreSaleName()}
+                                                                                                                        ],
+                                                                                                                        change: (event: any) => [
+                                                                                                                            () => {loadPreSaleName()}
+                                                                                                                        ],
+                                                                                                                    bindAttr: () => [
+                                                                                                                        loadPreSale,
+                                                                                                                        input.preSaleUserId,
+                                                                                                                        input.pocState != app.enums.POCState['NewCreate'],
+                                                                                                                        ],
+slotDefault: (scope)=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item16 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                nasl.core.or(input.pocState == app.enums.POCState['NewCreate'],input.solutionUserId != null),
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.select1 = new nasl.ui.uSelect({
+                                                                                                                        select: (event: any) => [
+                                                                                                                            () => {loadSolutionName()}
+                                                                                                                        ],
+                                                                                                                        change: (event: any) => [
+                                                                                                                            () => {loadSolutionName()}
+                                                                                                                        ],
+                                                                                                                    bindAttr: () => [
+                                                                                                                        loadSolution,
+                                                                                                                        input.solutionUserId,
+                                                                                                                        input.pocState != app.enums.POCState['NewCreate'],
+                                                                                                                        ],
+slotDefault: (scope)=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                        __elements.form_item19 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                                input.pocState != app.enums.POCState['NewCreate'],
+                                                                                                        null,
+                                                                                                                input.pocState == app.enums.POCState['NewCreate'],
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.select2 = new nasl.ui.uSelect({
+                                                                                                                        select: (event: any) => [
+                                                                                                                            () => {loadImplementName()}
+                                                                                                                        ],
+                                                                                                                        change: (event: any) => [
+                                                                                                                            () => {loadImplementName()}
+                                                                                                                        ],
+                                                                                                                    bindAttr: () => [
+                                                                                                                        loadImplement,
+                                                                                                                        input.implementUserId,
+                                                                                                                        input.pocState == app.enums.POCState['NewCreate'],
+                                                                                                                        ],
+slotDefault: (scope)=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                            ]
+                                                                                        }),
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.grid_layout_column8 = new nasl.ui.uGridLayoutColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.linear_layout41 = new nasl.ui.uLinearLayout({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout42 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.panel2 = new nasl.ui.uPanel({
+                                                                                    bindAttr: () => [
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                        __elements.linear_layout16 = new nasl.ui.uLinearLayout({
+                                                                                            bindAttr: () => [
+                                                                                                ],
+slotDefault: ()=> [
+                                                                                                __elements.linear_layout35 = new nasl.ui.uLinearLayout({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.text6 = new nasl.ui.uText({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                                __elements.form5 = new nasl.ui.uForm({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.form_item23 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                nasl.core.or(nasl.core.and(input.pocState != app.enums.POCState['OnGoing'],input.solutionEngagement == new nasl.core.Integer(1)),nasl.core.and(input.solutionEngagement == null,input.pocState == null)),
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.textarea5 = new nasl.ui.uTextarea({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.preSaleSummarize,
+                                                                                                                        nasl.core.and(input.pocState != app.enums.POCState['OnGoing'],input.solutionEngagement == new nasl.core.Integer(1)),
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                                __elements.linear_layout33 = new nasl.ui.uLinearLayout({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.text8 = new nasl.ui.uText({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                                __elements.form6 = new nasl.ui.uForm({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.form_item26 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                !(                                                                                                                nasl.core.and(input.pocState == app.enums.POCState['OnGoing'],input.solutionEngagement == new nasl.core.Integer(2))),
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.textarea3 = new nasl.ui.uTextarea({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.solutionSummarize,
+                                                                                                                        !(                                                                                                                        nasl.core.and(input.pocState == app.enums.POCState['OnGoing'],input.solutionEngagement == new nasl.core.Integer(2))),
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                            ]
+                                                                                        }),
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                        __elements.linear_layout43 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.panel5 = new nasl.ui.uPanel({
+                                                                                    bindAttr: () => [
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                        __elements.linear_layout14 = new nasl.ui.uLinearLayout({
+                                                                                            bindAttr: () => [
+                                                                                                ],
+slotDefault: ()=> [
+                                                                                                __elements.linear_layout25 = new nasl.ui.uLinearLayout({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.text17 = new nasl.ui.uText({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                                __elements.form4 = new nasl.ui.uForm({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.form_item21 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                input.pocState != app.enums.POCState['Review'],
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.textarea2 = new nasl.ui.uTextarea({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.pocSummarize,
+                                                                                                                        input.pocState != app.enums.POCState['Review'],
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                                __elements.linear_layout39 = new nasl.ui.uLinearLayout({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.text21 = new nasl.ui.uText({
+                                                                                                            bindAttr: () => [
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                                __elements.form7 = new nasl.ui.uForm({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.form_item27 = new nasl.ui.uFormItem({
+                                                                                                            bindAttr: () => [
+                                                                                                        null,
+                                                                                                                input.pocState != app.enums.POCState['Review'],
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                                __elements.input5 = new nasl.ui.uInput({
+                                                                                                                    bindAttr: () => [
+                                                                                                                        input.recoverFiles,
+                                                                                                                        input.pocState != app.enums.POCState['Review'],
+                                                                                                                        input.pocState == app.enums.POCState['Review'],
+                                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                                    ]
+                                                                                                                }),
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                                __elements.linear_layout40 = new nasl.ui.uLinearLayout({
+                                                                                                    bindAttr: () => [
+                                                                                                        ],
+slotDefault: ()=> [
+                                                                                                        __elements.link1 = new nasl.ui.uLink({
+                                                                                                            bindAttr: () => [
+                                                                                                                input.recoverFiles,
+                                                                                                                input.recoverFiles,
+                                                                                                                input.pocState != app.enums.POCState['Review'],
+                                                                                                                ],
+slotDefault: ()=> [
+                                                                                                            ]
+                                                                                                        }),
+                                                                                                    ]
+                                                                                                }),
+                                                                                            ]
+                                                                                        }),
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                    ]
+                                }),
+                                __elements.linear_layout8 = new nasl.ui.uLinearLayout({
+                                    bindAttr: () => [
+                                        ],
+slotDefault: ()=> [
+                                        __elements.submitModal = new nasl.ui.uModal({
+                                            bindAttr: () => [
+                                                ],
+slotDefault: ()=> [
+                                                __elements.template1 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.linear_layout17 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.button3 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {submit()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.button4 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {__elements.submitModal.close()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                                __elements.template2 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.linear_layout18 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.text3 = new nasl.ui.uText({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                                __elements.template3 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                        __elements.processModal = new nasl.ui.uModal({
+                                            bindAttr: () => [
+                                                ],
+slotDefault: ()=> [
+                                                __elements.template8 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.linear_layout15 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.button10 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {submitProcess()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.button11 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {__elements.processModal.close()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                                __elements.template18 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.linear_layout24 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.text4 = new nasl.ui.uText({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                                __elements.template19 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                        __elements.updateModel = new nasl.ui.uModal({
+                                            bindAttr: () => [
+                                                ],
+slotDefault: ()=> [
+                                                __elements.template4 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.linear_layout19 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.button5 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {updateProcess()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.button6 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {__elements.updateModel.close()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                                __elements.template5 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.linear_layout20 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.form2 = new nasl.ui.uForm({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.form_item17 = new nasl.ui.uFormItem({
+                                                                            bindAttr: () => [
+                                                                        null,
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.radios1 = new nasl.ui.uRadios({
+                                                                                    bindAttr: () => [
+                                                                                        inputProcess.reviewResults,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                        __elements.radio1 = new nasl.ui.uRadio({
+                                                                                            bindAttr: () => [
+                                                                                                app.enums.ReviewResults['Pass'],
+                                                                                                ],
+slotDefault: ()=> [
+                                                                                            ]
+                                                                                        }),
+                                                                                        __elements.radio2 = new nasl.ui.uRadio({
+                                                                                            bindAttr: () => [
+                                                                                                app.enums.ReviewResults['Rejected'],
+                                                                                                ],
+slotDefault: ()=> [
+                                                                                            ]
+                                                                                        }),
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                        __elements.form_item18 = new nasl.ui.uFormItem({
+                                                                            bindAttr: () => [
+                                                                                inputProcess.reviewResults == app.enums.ReviewResults['Rejected'],
+                                                                        null,
+                                                                                inputProcess.reviewResults == app.enums.ReviewResults['Pass'],
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.textarea1 = new nasl.ui.uTextarea({
+                                                                                    bindAttr: () => [
+                                                                                        inputProcess.auditOpinion,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                                __elements.template6 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.text5 = new nasl.ui.uText({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                        __elements.createEnvironModal = new nasl.ui.uModal({
+                                            bindAttr: () => [
+                                                ],
+slotDefault: ()=> [
+                                                __elements.template9 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.linear_layout37 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.button7 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {submitEnvironment()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                                __elements.button8 = new nasl.ui.uButton({
+                                                                        click: (event: any) => [
+                                                                            () => {__elements.createEnvironModal.close()}
+                                                                        ],
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                                __elements.template10 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.linear_layout38 = new nasl.ui.uLinearLayout({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.form3 = new nasl.ui.uForm({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.form_item28 = new nasl.ui.uFormItem({
+                                                                            bindAttr: () => [
+                                                                        null,
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.select8 = new nasl.ui.uSelect({
+                                                                                    bindAttr: () => [
+                                                                                        enInput.projectinfoid,
+                                                                                        loadProjects,
+                                                                                        ],
+slotDefault: (scope)=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                        __elements.form_item20 = new nasl.ui.uFormItem({
+                                                                            bindAttr: () => [
+                                                                        null,
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.select7 = new nasl.ui.uSelect({
+                                                                                    bindAttr: () => [
+                                                                                        app.enums.EnvironmentType.toList,
+                                                                                        enInput.type,
+                                                                                        ],
+slotDefault: (scope)=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                        __elements.form_item22 = new nasl.ui.uFormItem({
+                                                                            bindAttr: () => [
+                                                                        null,
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.input7 = new nasl.ui.uInput({
+                                                                                    bindAttr: () => [
+                                                                                        enInput.name,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                                __elements.template17 = new nasl.ui.template({
+                                                    bindAttr: () => [
+                                                        ],
+slotDefault: ()=> [
+                                                        __elements.text18 = new nasl.ui.uText({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                    ]
+                                }),
+                                __elements.linear_layout7 = new nasl.ui.uLinearLayout({
+                                    bindAttr: () => [
+                                        ],
+slotDefault: ()=> [
+                                        __elements.panel4 = new nasl.ui.uPanel({
+                                            bindAttr: () => [
+                                                jump != new nasl.core.Integer(0),
+                                                ],
+slotDefault: ()=> [
+                                                __elements.tableView = new nasl.ui.uTableView({
+                                                    bindAttr: () => [
+                                                        load,
+                                                        jump != new nasl.core.Integer(0),
+                                                        ],
+slotDefault: (scope)=> [
+                                                        __elements.table_view_column1 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column5 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template7 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout22 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text7 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        scope.item.workingOperatingData.operation,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column10 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template12 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout27 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text12 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        nasl.util.FormatDateTime(scope.item.workingOperatingData.operationDate, 'StringLiteral'),
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column11 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template13 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout28 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text13 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        nasl.util.Enum('StringLiteral', scope.item.workingOperatingData.reviewState),
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column9 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template11 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout26 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text11 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        scope.item.workingOperatingData.auditorName,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column12 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template14 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout29 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text14 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        nasl.util.Enum('StringLiteral', scope.item.workingOperatingData.reviewResults),
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column13 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template15 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout30 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text15 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        nasl.util.FormatDateTime(scope.item.workingOperatingData.reviewDate, 'StringLiteral'),
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column14 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template16 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout31 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text16 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        scope.item.workingOperatingData.auditOpinion,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                    ]
+                                }),
+                                __elements.linear_layout6 = new nasl.ui.uLinearLayout({
+                                    bindAttr: () => [
+                                        ],
+slotDefault: ()=> [
+                                        __elements.panel7 = new nasl.ui.uPanel({
+                                            bindAttr: () => [
+                                                jump != new nasl.core.Integer(0),
+                                                ],
+slotDefault: ()=> [
+                                                __elements.table_view1 = new nasl.ui.uTableView({
+                                                    bindAttr: () => [
+                                                        loadWorking,
+                                                        jump != new nasl.core.Integer(0),
+                                                        ],
+slotDefault: (scope)=> [
+                                                        __elements.table_view_column2 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template20 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column3 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template21 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout32 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text9 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        scope.item.working.workingCycle,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column4 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template22 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout34 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text10 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        nasl.util.Enum('StringLiteral', scope.item.working.workingType),
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column6 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template23 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout36 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text19 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        scope.item.working.normalWorking,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column7 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template24 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout44 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text20 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        scope.item.working.lossWorking,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column8 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template25 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout45 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text22 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        scope.item.working.workingDate,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column15 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template26 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout46 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text23 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        nasl.util.Enum('StringLiteral', scope.item.working.officeType),
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column16 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template27 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout47 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text24 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        scope.item.working.belongName,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column17 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template28 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout48 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text25 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        scope.item.working.submitName,
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                        __elements.table_view_column18 = new nasl.ui.uTableViewColumn({
+                                                            bindAttr: () => [
+                                                                ],
+slotDefault: ()=> [
+                                                                __elements.template29 = new nasl.ui.template({
+                                                                    bindAttr: () => [
+                                                                        ],
+slotDefault: ()=> [
+                                                                        __elements.linear_layout49 = new nasl.ui.uLinearLayout({
+                                                                            bindAttr: () => [
+                                                                                ],
+slotDefault: ()=> [
+                                                                                __elements.text26 = new nasl.ui.uText({
+                                                                                    bindAttr: () => [
+                                                                                        nasl.util.Enum('StringLiteral', scope.item.working.state),
+                                                                                        ],
+slotDefault: ()=> [
+                                                                                    ]
+                                                                                }),
+                                                                            ]
+                                                                        }),
+                                                                    ]
+                                                                }),
+                                                            ]
+                                                        }),
+                                                    ]
+                                                }),
+                                            ]
+                                        }),
+                                    ]
+                                }),
+                                __elements.linear_layout5 = new nasl.ui.uLinearLayout({
+                                    bindAttr: () => [
+                                        ],
+slotDefault: ()=> [
+                                    ]
+                                }),
+                                __elements.linear_layout4 = new nasl.ui.uLinearLayout({
+                                    bindAttr: () => [
+                                        ],
+slotDefault: ()=> [
+                                    ]
+                                }),
+                            ]
+                        }),
+                    ]
+                }),
+        }
+        export function $destination(options: {jump?:     nasl.core.Integer, id?:     nasl.core.Long}){}
+    }
+}