Exemple #1
0
        private static void ExecuteActionConversion(bool addNewActivity, bool isDefaultTargetApp, string strTargetApp,
                                                    bool convertToPOMAction = false, Guid selectedPOM = default(Guid))
        {
            ActionConversionUtils utils = new ActionConversionUtils();
            ObservableList <ConvertableActionDetails> lst = utils.GetConvertableActivityActions(mBF.Activities.ToList());
            ObservableList <Guid> poms = new ObservableList <Guid>()
            {
                selectedPOM
            };

            foreach (var item in lst)
            {
                item.Selected = true;
            }


            ObservableList <ConvertableTargetApplicationDetails> convertableTargetApplications = new ObservableList <ConvertableTargetApplicationDetails>();

            foreach (var act in mBF.Activities)
            {
                ConvertableTargetApplicationDetails tas = new ConvertableTargetApplicationDetails();
                tas.SourceTargetApplicationName = act.TargetApplication;
                tas.TargetTargetApplicationName = act.TargetApplication;
                convertableTargetApplications.Add(tas);
            }

            BusinessFlowToConvert statusLst = new BusinessFlowToConvert()
            {
                ConversionStatus            = eConversionStatus.Pending,
                BusinessFlow                = mBF,
                TotalProcessingActionsCount = mBF.Activities[0].Acts.Count
            };

            utils.ConvertToActions(statusLst, addNewActivity, lst, convertableTargetApplications, convertToPOMAction, poms);
        }
        /// <summary>
        /// This method is used to ge the businessflows to convert
        /// </summary>
        /// <param name="businessFlows"></param>
        /// <returns></returns>
        private ObservableList <BusinessFlowToConvert> GetBusinessFlowsToConvert(ObservableList <BusinessFlow> businessFlows)
        {
            ObservableList <BusinessFlowToConvert> lst = new ObservableList <BusinessFlowToConvert>();

            Parallel.ForEach(businessFlows, bf =>
            {
                BusinessFlowToConvert flowToConvert       = new BusinessFlowToConvert();
                flowToConvert.BusinessFlow                = bf;
                flowToConvert.TotalProcessingActionsCount = mConversionUtils.GetConvertibleActionsCountFromBusinessFlow(bf);
                lst.Add(flowToConvert);
            });
            return(lst);
        }
Exemple #3
0
        private static void ExecuteActionConversionForMultipleBF(bool addNewActivity, bool convertoSameTA = true,
                                                                 bool convertToPOMAction = false, Guid selectedPOM = default(Guid))
        {
            ObservableList <BusinessFlowToConvert> ListOfBusinessFlowToConvert = new ObservableList <BusinessFlowToConvert>();
            ActionConversionUtils utils = new ActionConversionUtils();
            ObservableList <ConvertableActionDetails> lstCad = new ObservableList <ConvertableActionDetails>();

            foreach (var bf in mListBF)
            {
                ObservableList <ConvertableActionDetails> lst = utils.GetConvertableActivityActions(bf.Activities.ToList());

                foreach (ConvertableActionDetails cad in lst)
                {
                    cad.Selected = true;
                    lstCad.Add(cad);
                }

                BusinessFlowToConvert flowConversion = new BusinessFlowToConvert();
                flowConversion.BusinessFlow                = bf;
                flowConversion.ConversionStatus            = eConversionStatus.Pending;
                flowConversion.TotalProcessingActionsCount = lst.Count;
                ListOfBusinessFlowToConvert.Add(flowConversion);
            }
            ObservableList <Guid> poms = new ObservableList <Guid>()
            {
                selectedPOM
            };

            ObservableList <ConvertableTargetApplicationDetails> convertableTargetApplications = new ObservableList <ConvertableTargetApplicationDetails>();

            foreach (var bf in mListBF)
            {
                foreach (var act in bf.Activities)
                {
                    ConvertableTargetApplicationDetails tas = new ConvertableTargetApplicationDetails();
                    tas.SourceTargetApplicationName = act.TargetApplication;
                    if (convertoSameTA)
                    {
                        tas.TargetTargetApplicationName = act.TargetApplication;
                    }
                    else
                    {
                        tas.TargetTargetApplicationName = MAPPED_TA_FOR_CONVERSION;
                    }
                    convertableTargetApplications.Add(tas);
                }
            }

            utils.ListOfBusinessFlowsToConvert = ListOfBusinessFlowToConvert;
            utils.ConvertActionsOfMultipleBusinessFlows(lstCad, addNewActivity, convertableTargetApplications, convertToPOMAction, poms);
        }
Exemple #4
0
        /// <summary>
        /// This method helps to execute the funcationality of removeing the legacy actions from the businessflow
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void LegacyActionsRemoveHandler(object sender, System.Windows.RoutedEventArgs e)
        {
            ObservableList <BusinessFlowToConvert> lstBFToConvert = new ObservableList <BusinessFlowToConvert>();

            if (((ITreeViewItem)this).NodeObject().GetType().Equals(typeof(GingerCore.BusinessFlow)))
            {
                BusinessFlowToConvert flowToConvert = new BusinessFlowToConvert();
                flowToConvert.BusinessFlow = (GingerCore.BusinessFlow)((ITreeViewItem)this).NodeObject();
                lstBFToConvert.Add(flowToConvert);
            }

            ActionConversionUtils utils = new ActionConversionUtils();
            await Task.Run(() => utils.RemoveLegacyActionsHandler(lstBFToConvert));
        }
        /// <summary>
        /// This method helps to execute the funcationality of removeing the legacy actions from the businessflow
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void LegacyActionsRemoveHandler(object sender, System.Windows.RoutedEventArgs e)
        {
            ObservableList <BusinessFlowToConvert> lstBFToConvert = new ObservableList <BusinessFlowToConvert>();
            var items = ((Amdocs.Ginger.Repository.RepositoryFolder <GingerCore.BusinessFlow>)((ITreeViewItem)this).NodeObject()).GetFolderItemsRecursive();

            foreach (var bf in items)
            {
                BusinessFlowToConvert flowToConvert = new BusinessFlowToConvert();
                flowToConvert.BusinessFlow = (GingerCore.BusinessFlow)bf;
                lstBFToConvert.Add(flowToConvert);
            }
            ActionConversionUtils utils = new ActionConversionUtils();

            await Task.Run(() => utils.RemoveLegacyActionsHandler(lstBFToConvert));
        }
 /// <summary>
 /// This method is used to get the businessFlowList
 /// </summary>
 /// <returns></returns>
 private ObservableList <BusinessFlowToConvert> GetBusinessFlowList()
 {
     ListOfBusinessFlow = new ObservableList <BusinessFlowToConvert>();
     foreach (BusinessFlowToConvert bf in mWizard.ListOfBusinessFlow)
     {
         if (bf.IsSelected)
         {
             BusinessFlowToConvert flowConversion = new BusinessFlowToConvert();
             flowConversion.BusinessFlow                = bf.BusinessFlow;
             flowConversion.IsSelected                  = true;
             flowConversion.ConversionStatus            = eConversionStatus.Pending;
             flowConversion.TotalProcessingActionsCount = bf.TotalProcessingActionsCount;
             ListOfBusinessFlow.Add(flowConversion);
         }
     }
     return(ListOfBusinessFlow);
 }
 /// <summary>
 /// This method is used to add the selected businessflow list which adds to grid
 /// </summary>
 /// <param name="selectedBFs"></param>
 private void AddSelectedBF(List <object> selectedBFs)
 {
     if (selectedBFs != null && selectedBFs.Count > 0)
     {
         foreach (BusinessFlow bf in selectedBFs)
         {
             if (!IsBusinessFlowAdded(bf.Guid))
             {
                 BusinessFlowToConvert flowToConversion = new BusinessFlowToConvert();
                 flowToConversion.BusinessFlow                = bf;
                 flowToConversion.ConversionStatus            = eConversionStatus.Pending;
                 flowToConversion.IsSelected                  = true;
                 flowToConversion.TotalProcessingActionsCount = mWizard.GetConvertibleActionsCountFromBusinessFlow(bf);
                 ListOfBusinessFlow.Add(flowToConversion);
             }
         }
     }
 }
        /// <summary>
        /// This method is used to ge the businessflows to convert
        /// </summary>
        /// <param name="businessFlows"></param>
        /// <returns></returns>
        private ObservableList <BusinessFlowToConvert> GetBusinessFlowsToConvert()
        {
            ObservableList <BusinessFlow>          businessFlows = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <BusinessFlow>();
            ObservableList <BusinessFlowToConvert> lst           = new ObservableList <BusinessFlowToConvert>();

            Parallel.ForEach(businessFlows, bf =>
            {
                if (IsWebServiceTargetApplicationInFlow(bf))
                {
                    BusinessFlowToConvert flowToConvert       = new BusinessFlowToConvert();
                    flowToConvert.BusinessFlow                = bf;
                    flowToConvert.TotalProcessingActionsCount = mConversionUtils.GetConvertibleActionsCountFromBusinessFlow(bf);
                    if (flowToConvert.TotalProcessingActionsCount > 0)
                    {
                        lst.Add(flowToConvert);
                    }
                }
            });
            return(lst);
        }
        private static void ExecuteActionConversion(bool parameterizeRequestBody, bool pullValidations)
        {
            ObservableList <BusinessFlowToConvert> ListOfBusinessFlowToConvert = new ObservableList <BusinessFlowToConvert>();
            ApiActionConversionUtils utils = new ApiActionConversionUtils();

            foreach (var bf in mListBF)
            {
                foreach (var act in bf.Activities)
                {
                    act.SelectedForConversion = true;
                }

                BusinessFlowToConvert flowConversion = new BusinessFlowToConvert();
                flowConversion.BusinessFlow                = bf;
                flowConversion.ConversionStatus            = eConversionStatus.Pending;
                flowConversion.TotalProcessingActionsCount = utils.GetConvertibleActionsCountFromBusinessFlow(bf);
                ListOfBusinessFlowToConvert.Add(flowConversion);
            }

            apiModelsFolder = WorkSpace.Instance.SolutionRepository.GetRepositoryItemRootFolder <ApplicationAPIModel>();
            utils.ConvertToApiActionsFromBusinessFlows(ListOfBusinessFlowToConvert, parameterizeRequestBody, pullValidations, apiModelsFolder);
        }