spread Workflow Action Buttons

//called by     NW_PayrollRequestsHelper::spreadWorkflowActionButtons(element);


using Microsoft.Dynamics.@Client.ServerForm.Contexts;
/// <summary>
/// this class is used for requests that should be used in the workspace, listpages
/// and created from NCA portals
/// </summary>
class NW_PayrollRequestsHelper
{
    public static boolean isPayrollAdmin()
    {
        SecurityRole role;
        SecurityUserRole userRole;
         
        select userRole where userRole.User == curUserId()
             join role where  userRole.SecurityRole == role.RecID &&
            (role.Name == "Payroll administrator" || role.Name == "HR Manager");
         
        if(userRole)
            return true;

        return false;
    }

    public static boolean userHasSecurityRole(SecurityRoleName _securityRoleName, UserId _userId = curUserId())
    {
        SecurityRole role;
        SecurityUserRole userRole;
         
        select userRole where userRole.User == curUserId()
             join role where  userRole.SecurityRole == role.RecID &&
            (role.Name == _securityRoleName);
         
        if(userRole)
            return true;

        return false;
    }

    public static str pendingWorkItemUsers(RefRecId _refRecId, RefTableId _refTableId)
    {
        WorkflowWorkItemTable workflowWorkItemTable;
        WorkflowTrackingStatus trackingStatus;
        WorkflowCorrelationId correlationId;
        str currentStepName, nextStepName;
        container users;
        ;

        // Find the next pending work item for the current user
        while select workflowWorkItemTable
                where  workflowWorkItemTable.RefRecId == _refRecId
                && workflowWorkItemTable.RefTableId == _refTableId
                && workflowWorkItemTable.Status == WorkflowWorkItemStatus::Pending
        {
            users += workflowWorkItemTable.userName();
        }
        return con2Str(users, ", ");
    }

    private static boolean canSeeAllrequestRecords()
    {
        SecurityRole role;
        SecurityUserRole userRole;

        if(isSystemAdministrator())
            return true;

        while select userRole where userRole.User == curUserId()
        join role where userRole.SecurityRole == role.RecId

            && (role.Name == "Netways Payroll admin"
            || role.Name == "Human resources assistant")
        {
            return true;
        }
        return false;
    }

    public static void applyNCAPolicy(FormDataSource _Ds, FieldName _workerFieldName = '',
                boolean _filterCreatedBy = true, boolean _filterAssignedBy = true)
    {
        // stopped now till tested
        //  return;

        QueryBuildDataSource qbdsWorkItem;
        FormRun fr = _Ds.formRun();
        container rangeExpressions;
        MenuFunction callerMenuItem=  new MenuFunction(fr.args().menuItemName(), fr.args().menuItemType());
     
        if(NW_PayrollRequestsHelper::canSeeAllrequestRecords())
            return;
    
        /// if the request is opened from a url with an encrypted query
        if(NW_PayrollRequestsHelper::formHasRecordContext())
            return;
         
        QueryBuildRange qbr = _ds.queryBuildDataSource()
                        .addRange(fieldNum(AbsenceRequestHeader, RecId));

        Name qbdsName = _Ds.queryBuildDataSource().name();
        DictTable dictTable = new DictTable(_Ds.table());
        FieldId recIdField = dictTable.fieldName2Id("RecId");
        FieldId tableIdField = dictTable.fieldName2Id("TableId");
        FieldId createdByField = dictTable.fieldName2Id("CreatedBy");

        if(_workerFieldName)
        {
            rangeExpressions += strFmt('(%1.%2 == %3)',
                                qbdsName, _workerFieldName, HcmWorker::userId2Worker(curUserId()));
        }
        if(_filterCreatedBy)
        {
            if(createdByField)
                                rangeExpressions += strFmt('(%1.%2 == "%3")',qbdsName, "CreatedBy", curUserId());
        }
        if(_filterAssignedBy)
        {
            qbdsWorkItem = _Ds.queryBuildDataSource().
                                addDataSource(tableNum(WorkflowWorkItemTable));

            qbdsWorkItem.addRange(fieldnum(WorkflowWorkItemTable, Status)).value(queryValue(WorkflowWorkItemStatus::Pending));
            qbdsWorkItem.joinMode(JoinMode::OuterJoin);

            qbdsWorkItem.addLink(recIdField, fieldNum(WorkflowWorkItemTable, RefRecId));
            qbdsWorkItem.addLink(tableIdField, fieldNum(WorkflowWorkItemTable, RefTableId));

            rangeExpressions += strFmt('(%1.%2 == "%3")',
                                qbdsWorkItem.name(), fieldStr(WorkflowWorkItemTable, UserId), curUserId());
        }
        str rangeValue = strFmt('(%1)', con2Str(rangeExpressions, " || "));

        qbr.value(rangeValue);
        qbr.status(RangeStatus::Hidden);
    
        if(rangeExpressions == conNull())
                        qbr.AOTdelete();
        //info(qbr.value());
        //info(_Ds.query().toString());
    }

    public void workflowMenuBtnclicked(FormFunctionButtonControl _btn)
    {
        _btn.clicked();
        NW_PayrollRequestsHelper::requestDataSourceOnDeletion(_btn.formRun());

        //#Task
        //_btn.formRun().task(#TaskRefresh);
    }

    public static void hideNonSpecificGender(FormComboBoxControl _genderComboBoxCtrl)
    {
        _genderComboBoxCtrl.delete(enum2Str(HcmPersonGender::NonSpecific));
    }

    /// <summary>
    /// this method spreads the workflow approve and reject buttons beside the workflow menu button
    /// use this method on the datasource active method
    /// </summary>
    /// <param name = "_fr"> the form run object</param>
    public static void spreadWorkflowActionButtons(FormRun _fr)
    {
        #Workflow
        #JmgIcons
        #define.NCAWorkflowBtnGrp("NCAWorkflowBtnGrp")

        FormMenuButtonControl workflowMenu = _fr.control(_fr.controlId(#WorkflowActionBarButtonGroup));
        FormButtonGroupControl NCAWorkflowBtnGrp = _fr.control(_fr.controlId(#NCAWorkflowBtnGrp));

        if(NCAWorkflowBtnGrp)
            _fr.design().removeControl(_fr.controlId(#NCAWorkflowBtnGrp));
     
        FormFunctionButtonControl duplicateActionButton;
        
        
        if(workflowMenu)
        {
           
            FormButtonGroupControl workflowActionPaneButtonGroup = _fr.control(_fr.controlId("workflowActionPaneButtonGroup"));
            FormActionPaneControl actionPaneCtrl = workflowActionPaneButtonGroup.parentControl();
            NCAWorkflowBtnGrp = actionPaneCtrl.addControl(FormControlType::ButtonGroup, "NCAWorkflowBtnGrp", workflowActionPaneButtonGroup);
            NCAWorkflowBtnGrp.frameType(2);
            NCAWorkflowBtnGrp.visible(false);
            For(int i = 1; i <= workflowMenu.controlCount(); i++)
            {
                
                FormFunctionButtonControl   actionButton = workflowMenu.controlNum(i);
               // info(strFmt('%1',actionButton));

                if(actionButton &&
                    (strScan(actionButton.menuItemName(), "Approve", 1, 90)
                    || strScan(actionButton.menuItemName(), "Reject", 1, 90)
                    || strScan(actionButton.menuItemName(), "tChange", 1, 90)))
                {
                   
                    duplicateActionButton = NCAWorkflowBtnGrp.addControl(FormControlType::MenuFunctionButton, "Net_" + #WorkflowActionMenuFunctionPrefix+int2str(i));
                    duplicateActionButton.menuItemType(MenuItemType::Action);
                    duplicateActionButton.dataSource(_fr.workflowDataSource().name());
                    duplicateActionButton.menuItemName(actionButton.menuItemName());

                    NW_PayrollRequestsHelper helper = new NW_PayrollRequestsHelper();
                    duplicateActionButton.registerOverrideMethod(methodStr(FormFunctionButtonControl, clicked),
                                                methodStr(NW_PayrollRequestsHelper, workflowMenuBtnclicked), helper);
          
                    //helper = new NW_PayrollRequestsHelper();
                    //actionButton.registerOverrideMethod(methodStr(FormFunctionButtonControl, clicked),
                    //    methodStr(NW_PayrollRequestsHelper, workflowMenuBtnclicked), helper);

                    if(strScan(actionButton.menuItemName(), "Approve", 1, 90))
                        duplicateActionButton.normalImage("GreenCheck");

                    if(strScan(actionButton.menuItemName(), "Reject", 1, 90))
                        duplicateActionButton.normalImage("RedX");

                    if(strScan(actionButton.menuItemName(), "tChange", 1, 90))
                        duplicateActionButton.normalImage("Return");

                    //if(strScan(actionButton.menuItemName(), "Resubmit", 1, 90))
                    //    actionButton.visible(false);

                    //if(strScan(actionButton.menuItemName(), "Cancel", 1, 90))
                    //    actionButton.visible(false);


                    NCAWorkflowBtnGrp.visible(true);
                }
            }
        }
    }

    /// <summary>
    /// use this method on forms run() method
    ///
    /// </summary>
    /// <param name = "_fr"> FormRun object</param>
    public static void requestOnRun(FormRun _fr)
    {
        if(_fr.args().openMode() == OpenMode::New && !_fr.args().caller())
        {
            #Task
            _fr.task(#taskNew);
        }
        //  if(_fr.args().record() || !_fr.args().caller())
        if(_fr.args().openMode() == OpenMode::New || _fr.args().openMode() == OpenMode::Edit)
        {
            #SysSystemDefinedButtons
            formcontrol filterBtn = _fr.control(_fr.controlId(#SystemDefinedShowFiltersButton));
            if(filterBtn)
                filterBtn.visible(false);
      
            formcontrol listBtn = _fr.control(_fr.controlId(#SystemDefinedShowListButton));
            if(listBtn)
                listBtn.visible(false);
        }
    }

    public static void lockRanges(FormDataSource _ds)
    {
        //if(_ds.formRun().args().record())
        //{
        for(int i = 1; i <= _ds.queryRunQueryBuildDataSource().rangeCount(); i ++)
        {
            _ds.queryRunQueryBuildDataSource().range(i).status(RangeStatus::Locked);
            // _ds.queryBuildDataSource().range(i).status(RangeStatus::Hidden);
        }
        //}
    }

    /// <summary>
    /// use this method on forms close() method
    /// </summary>
    /// <param name = "_fr"> FormRun object</param>
    public static void requestOnClosed(FormRun _fr)
    {
        FormRun caller = _fr.args().caller();
        if(caller)
        {
            #Task
            caller.task(#TaskRefresh);
        }
    }

    /// <summary>
    /// use this method in form task method as a condition
    /// example: if(NW_PayrollRequestsHelper::cannotSwitchToGridView(element, _p1))
    ///             return ret;
    /// </summary>
    /// <param name = "_fr"></param>
    /// <param name = "_task"></param>
    /// <returns></returns>
    public static boolean cannotSwitchToGridView(FormRun _fr, int _task)
    {
        #Task
        return _task == #TaskSwitchToGridView &&
                        (_fr.args().openMode() == OpenMode::New || _fr.args().openMode() == OpenMode::Edit);  // is opened from ess
    }

    /// <summary>
    /// used to pop out of the form details to previous screen
    /// use this method on the form datasource delete() method
    /// you can use it also in save and submit button
    /// </summary>
    /// <param name = "_fr"> FormRun object</param>
    public static void requestDataSourceOnDeletion(FormRun _fr)
    {
        #Task
    
        if(_fr.args().openMode() == OpenMode::New)
        {
            _fr.closeCancel();
        }
        else if (_fr.args().openMode() == OpenMode::Edit)
        {
            _fr.task(#taskEsc);
        }
        else
        {
            _fr.task(#taskSwitchToGridView);
        }
    }

    /// <summary>
    /// don't use, not ready
    /// </summary>
    /// <param name = "_ds"></param>
    /// <param name = "_allowEdit"></param>
    public static void dataSourceFieldsAllowEdit(FormDataSource _ds, boolean _allowEdit)
    {
        DictTable dictTable = DictTable::construct(tableId2Name(_ds.table()));

        FieldId fieldId = dictTable.fieldNext(0);
    
        while(fieldId)
        {
            _ds.object(fieldId).allowEdit(_allowEdit);
            fieldId = dictTable.fieldNext(fieldId);
        }
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    [FormEventHandler(formStr(DocumentUpload), FormEventType::Closing)]
    public static void DocumentUpload_OnClosing(xFormRun sender, FormEventArgs e)
    {
        FormControl ctrl = sender.args().caller();
        if(ctrl)
        {
            FormRun callerFr = ctrl.formRun();
            if(callerFr)
            {
                #Task
                callerFr.task(#TaskRefresh);
            }
        }
    }

    public static void refreshCallerForm(FormRun _formRun)
    {
        FormRun callerFr = _formRun.args().caller();
        if(callerFr)
        {
            #Task
            callerFr.task(#TaskRefresh);
        }
    }

    public static boolean formHasRecordContext()
    {
        SessionContext sessionContext = SessionContext::Get_Current();
        if(!sessionContext)
            return false;
        /// if the request is opened from a url with an encrypted query
        URLUtility urlUtil = new URLUtility();
        str q = urlUtil.getQueryParamValue('q');
        if(q)
            return true;

        return false;
    }

    public static void SubmitToWorkflow(container _parms)
    {
        workflowTypeName  workflowTemplateName;
        recId             recId;
        WorkflowComment   initialNote;
        NoYes             activatingFromWeb;
        WorkflowUser      submittingUser;

        [workflowTemplateName, recId, initialNote, activatingFromWeb, submittingUser] = _parms;

        Workflow::activateFromWorkflowType(workflowTemplateName,
                                           RecId,
                                           initialNote,
                                           NoYes::No,
                                           submittingUser);
    }

    static SysEmailItemId SendMailByDistributerBatch(
        SysEmailId _emailTemplate,
        Email _recipientMail,
        Map _placeHolderMap = null,
        str _origin = '')
    {
        SysOutgoingEmailTable outgoingEmailTable;
        SysEmailItemId nextEmailItemId;

        SysEmailTable        sysEmailTable        = SysEmailTable::find(_emailTemplate);
        SysEmailMessageTable sysEmailMessageTable = SysEmailMessageTable::find(sysEmailTable.EmailId, sysEmailTable.DefaultLanguage);
        str messageBody = sysEmailMessageTable.Mail;
        str subject = sysEmailMessageTable.Subject;

        //Map placeholderMap = new Map(Types::String, Types::String);
        //placeholderMap.insert("Startdate", date2Str(_SDate,123, DateDay::Digits2,DateSeparator::Slash,DateMonth::Digits2,DateSeparator::Slash,DateYear::Digits4));
        //placeholderMap.insert("Enddate", date2Str(_EDate,123, DateDay::Digits2,DateSeparator::Slash,DateMonth::Digits2,DateSeparator::Slash,DateYear::Digits4));
        //placeholderMap.insert("Task", _Tasks);
        Map placeHolderMap = _placeHolderMap;

        messageBody = SysEmailMessage::stringExpand(messageBody, placeholderMap);
        subject     = SysEmailMessage::stringExpand(subject, placeholderMap);
         
         
        nextEmailItemId = EventInbox::nextEventId();
        outgoingEmailTable.EmailItemId = nextEmailItemId;
        outgoingEmailTable.IsSystemEmail = NoYes::No;
        outgoingEmailTable.Origin = _origin;
        outgoingEmailTable.Sender = sysEmailTable.SenderAddr;
        outgoingEmailTable.SenderName = sysEmailTable.SenderName;
        outgoingEmailTable.Recipient = _recipientMail;
        outgoingEmailTable.Subject = subject;
        outgoingEmailTable.Priority = eMailPriority::Normal ;
        outgoingEmailTable.WithRetries = true;
        outgoingEmailTable.RetryNum = 10;
        outgoingEmailTable.UserId = curUserId();
        outgoingEmailTable.Status = SysEmailStatus::Unsent;
        outgoingEmailTable.Message = messageBody;
        outgoingEmailTable.LatestStatusChangeDateTime = DateTimeUtil::getSystemDateTime();
        outgoingEmailTable.insert();

        return outgoingEmailTable.EmailItemId ;
    }

}