public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index = 0, bool inserted = false, string initializeWith = "")
        {
            IDev2TOFn toReturn = null;

            TypeSwitch.Do(dto,
                          // ReSharper disable ImplicitlyCapturedClosure
                          TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
                          // ReSharper restore ImplicitlyCapturedClosure
                          TypeSwitch.Case <DataSplitDTO>(x =>
            {
                var dataSplitDto = dto as DataSplitDTO;
                if (dataSplitDto != null)
                {
                    toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
                }
            }),
                          TypeSwitch.Case <DataMergeDTO>(x =>
            {
                var dataMergeDto = dto as DataMergeDTO;
                if (dataMergeDto != null)
                {
                    toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
                }
            }),
                          TypeSwitch.Case <CaseConvertTO>(x =>
            {
                var caseConvertTO = dto as CaseConvertTO;
                if (caseConvertTO != null)
                {
                    toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
                }
            }),
                          TypeSwitch.Case <BaseConvertTO>(x =>
            {
                var baseConvertTO = dto as BaseConvertTO;
                if (baseConvertTO != null)
                {
                    toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
                }
            }),
                          // ReSharper disable ImplicitlyCapturedClosure
                          TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
                                                                          // ReSharper restore ImplicitlyCapturedClosure
                                                                          new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
                                                                                                        initializeWith, index, inserted)),
                          // ReSharper disable ImplicitlyCapturedClosure
                          TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
                          // ReSharper restore ImplicitlyCapturedClosure
                          // ReSharper disable ImplicitlyCapturedClosure
                          TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
                          // ReSharper restore ImplicitlyCapturedClosure
                          // ReSharper disable ImplicitlyCapturedClosure
                          TypeSwitch.Default(() => toReturn = null));
            // ReSharper restore ImplicitlyCapturedClosure

            return(toReturn);
        }
        public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index = 0, bool inserted = false, string initializeWith = "")
        {
            IDev2TOFn toReturn = null;

            TypeSwitch.Do(dto,
                // ReSharper disable ImplicitlyCapturedClosure
            TypeSwitch.Case<ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
                // ReSharper restore ImplicitlyCapturedClosure
            TypeSwitch.Case<DataSplitDTO>(x =>
                {
                    var dataSplitDto = dto as DataSplitDTO;
                    if(dataSplitDto != null)
                    {
                        toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
                    }
                }),
            TypeSwitch.Case<DataMergeDTO>(x =>
                {
                    var dataMergeDto = dto as DataMergeDTO;
                    if(dataMergeDto != null)
                    {
                        toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
                    }
                }),
            TypeSwitch.Case<CaseConvertTO>(x =>
                {
                    var caseConvertTO = dto as CaseConvertTO;
                    if(caseConvertTO != null)
                    {
                        toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
                    }
                }),
            TypeSwitch.Case<BaseConvertTO>(x =>
                {
                    var baseConvertTO = dto as BaseConvertTO;
                    if(baseConvertTO != null)
                    {
                        toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
                    }
                }),
                // ReSharper disable ImplicitlyCapturedClosure
            TypeSwitch.Case<GatherSystemInformationTO>(x => toReturn =
                // ReSharper restore ImplicitlyCapturedClosure
                new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
                    initializeWith, index, inserted)),
                // ReSharper disable ImplicitlyCapturedClosure
            TypeSwitch.Case<XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index,  inserted)),
                // ReSharper restore ImplicitlyCapturedClosure
                // ReSharper disable ImplicitlyCapturedClosure
            TypeSwitch.Case<FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
                // ReSharper restore ImplicitlyCapturedClosure
                // ReSharper disable ImplicitlyCapturedClosure
            TypeSwitch.Default(() => toReturn = null));
            // ReSharper restore ImplicitlyCapturedClosure

            return toReturn;
        }
Example #3
0
        public override void UpdateDto(IDev2TOFn dto)
        {
            var decto = dto as DecisionTO;

            if (decto != null)
            {
                decto.UpdateDisplayAction = UpdateDecisionDisplayName;
            }
        }
Example #4
0
        public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index, bool inserted, string initializeWith)
        {
            IDev2TOFn toReturn = null;

            TypeSwitch.Do(dto,

                          TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),

                          TypeSwitch.Case <DataSplitDTO>(x =>
            {
                if (dto is DataSplitDTO dataSplitDto)
                {
                    toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
                }
            }),
                          TypeSwitch.Case <DataMergeDTO>(x =>
            {
                if (dto is DataMergeDTO dataMergeDto)
                {
                    toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
                }
            }),
                          TypeSwitch.Case <CaseConvertTO>(x =>
            {
                if (dto is CaseConvertTO caseConvertTO)
                {
                    toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
                }
            }),
                          TypeSwitch.Case <BaseConvertTO>(x =>
            {
                if (dto is BaseConvertTO baseConvertTO)
                {
                    toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
                }
            }),

                          TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
                                                                          new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
                                                                                                        initializeWith, index, inserted)),
                          TypeSwitch.Case <XPathDTO>(x => toReturn              = new XPathDTO(initializeWith, "", index, inserted)),
                          TypeSwitch.Case <FindRecordsTO>(() => toReturn        = new FindRecordsTO("", "", index, inserted)),
                          TypeSwitch.Case <DecisionTO>(() => toReturn           = new DecisionTO(initializeWith, "", "", index, inserted)),
                          TypeSwitch.Case <JsonMappingTo>(() => toReturn        = new JsonMappingTo(initializeWith, index, inserted)),
                          TypeSwitch.Case <SharepointSearchTo>(() => toReturn   = new SharepointSearchTo(initializeWith, "=", "", index, inserted)),
                          TypeSwitch.Case <SharepointReadListTo>(() => toReturn = new SharepointReadListTo("", initializeWith, "", "")),
                          TypeSwitch.Case <AssignObjectDTO>(x => toReturn       = new AssignObjectDTO(initializeWith, "", index, inserted)),
                          TypeSwitch.Default(() => toReturn = null));

            return(toReturn);
        }
 protected abstract IEnumerable <IActionableErrorInfo> ValidateCollectionItem(IDev2TOFn mi);
Example #6
0
 static void SetIndexNumber(IDev2TOFn mi, int indexNumber)
 {
     mi.IndexNumber = indexNumber;
 }
Example #7
0
 public virtual void UpdateDto(IDev2TOFn dto)
 {
 }
Example #8
0
 public static IDev2TOFn CreateNewDTO(IDev2TOFn dto) => CreateNewDTO(dto, 0, false, "");
Example #9
0
 protected override IEnumerable <IActionableErrorInfo> ValidateCollectionItem(IDev2TOFn mi)
 {
     yield break;
 }