Example #1
0
        public IInputOutputViewModel LoadOutputAutoMapping(IInputOutputViewModel item)
        {
            string value = string.Empty;

            if (item.Value == string.Empty)
            {
                IDataListItemModel recset = DataListSingleton.ActiveDataList.RecsetCollection.FirstOrDefault(x => x.Name == item.RecordSetName);
                if (recset != null)
                {
                    var val = recset.Children.FirstOrDefault(x => x.DisplayName == item.DisplayName);
                    if (val != null)
                    {
                        value = val.DisplayName;
                    }

                    if (value != null)
                    {
                        item.Value = value;
                    }
                }
                else
                {
                    IDataListItemModel scalar = DataListSingleton.ActiveDataList.ScalarCollection.FirstOrDefault(x => x.Name == item.DisplayName);
                    if (scalar != null)
                    {
                        item.Value = scalar.DisplayName;
                    }
                }
            }
            return(item);
        }
Example #2
0
        IEnumerable <IInputOutputViewModel> GetMapping(XContainer xml, bool isInput, ObservableCollection <IInputOutputViewModel> oldMappings)
        {
            var result = new ObservableCollection <IInputOutputViewModel>();

            var input = xml.Descendants(isInput ? "Input" : "Output").FirstOrDefault();

            if (input != null)
            {
                var newMappings = DeserializeMappings(isInput, input);

                foreach (var newMapping in newMappings)
                {
                    IInputOutputViewModel mapping = newMapping;
                    var oldMapping = oldMappings.FirstOrDefault(m => m.Name.Equals(mapping.Name, StringComparison.InvariantCultureIgnoreCase));
                    if (oldMapping != null)
                    {
                        newMapping.MapsTo = oldMapping.MapsTo;
                        newMapping.Value  = oldMapping.Value;
                    }
                    else
                    {
                        newMapping.IsNew = true;
                    }
                    result.Add(newMapping);
                }
            }
            return(result);
        }
        public IInputOutputViewModel LoadOutputAutoMapping(IInputOutputViewModel item)
        {
            string value = string.Empty;
            if(item.Value == string.Empty)
            {
                IDataListItemModel recset = DataListSingleton.ActiveDataList.RecsetCollection.FirstOrDefault(x => x.Name == item.RecordSetName);
                if(recset != null)
                {
                    var val = recset.Children.FirstOrDefault(x => x.DisplayName == item.DisplayName);
                    if(val != null)
                    {
                        value = val.DisplayName;
                    }

                    if(value != null)
                    {
                        item.Value = value;
                    }
                }
                else
                {
                    IDataListItemModel scalar = DataListSingleton.ActiveDataList.ScalarCollection.FirstOrDefault(x => x.Name == item.DisplayName);
                    if(scalar != null)
                    {
                        item.Value = scalar.DisplayName;
                    }
                }
            }
            return item;
        }
Example #4
0
        private void CheckRequiredMappingChangedErrors(DesignValidationMemo memo)
        {
            var keepError             = false;
            var reqiredMappingChanged = memo.Errors.FirstOrDefault(c => c.FixType == FixType.IsRequiredChanged);

            if (reqiredMappingChanged != null)
            {
                if (reqiredMappingChanged.FixData != null)
                {
                    var xElement = XElement.Parse(reqiredMappingChanged.FixData);
                    var inputOutputViewModels = DeserializeMappings(true, xElement);

                    foreach (var input in inputOutputViewModels)
                    {
                        IInputOutputViewModel currentInputViewModel = input;
                        var inputOutputViewModel = DataMappingViewModel?.Inputs.FirstOrDefault(c => c.Name == currentInputViewModel.Name);
                        if (inputOutputViewModel != null)
                        {
                            inputOutputViewModel.Required = input.Required;
                            if (inputOutputViewModel.MapsTo == string.Empty && inputOutputViewModel.Required)
                            {
                                keepError = true;
                            }
                        }
                    }
                }

                if (!keepError)
                {
                    var worstErrors = memo.Errors.Where(c => c.FixType == FixType.IsRequiredChanged && c.InstanceID == _serviceDesignerViewModel.UniqueID).ToList();
                    memo.Errors.RemoveAll(c => c.FixType == FixType.IsRequiredChanged && c.InstanceID == _serviceDesignerViewModel.UniqueID);
                    _serviceDesignerViewModel.ValidationMemoManager.RemoveErrors(worstErrors);
                }
            }
        }
Example #5
0
        public void NotInitialLoadInputAutoMappingTest()
        {
            _autoMappingInputAction = new AutoMappingInputAction(_mockDataMappingViewModel.Object, _mockWebActivity.Object);

            IInputOutputViewModel expected = _mockInputOutputViewModel.Object;
            IInputOutputViewModel actual;

            actual = _autoMappingInputAction.LoadInputAutoMapping(_mockInputOutputViewModel.Object);
            Assert.AreEqual(expected, actual);
        }
Example #6
0
        public void IsInitialLoadInputAutoMapping_Expected_ReturnedItemThatWasPassedInForInputMapping()
        {
            _autoMappingInputAction = new AutoMappingInputAction(_mockDataMappingViewModel.Object, _mockWebActivity.Object);

            IInputOutputViewModel expected = _mockInputOutputViewModel.Object;
            IInputOutputViewModel actual;

            actual = _autoMappingInputAction.LoadInputAutoMapping(_mockInputOutputViewModel.Object);
            Assert.AreEqual(expected, actual);
        }
        public static IList <IInputOutputViewModel> CreateListToDisplayInputs(IList <IDev2Definition> inputList)
        {
            IList <IInputOutputViewModel> displayInputData = new List <IInputOutputViewModel>();

            foreach (IDev2Definition itp in inputList)
            {
                IInputOutputViewModel inputOutputViewModel = CreateInputOutputViewModel(itp.Name, itp.RawValue, itp.RawValue, itp.DefaultValue, itp.IsRequired, itp.RecordSetName, itp.EmptyToNull);
                displayInputData.Add(inputOutputViewModel);
            }
            return(displayInputData);
        }
        public static IList <IInputOutputViewModel> CreateListToDisplayOutputs(IList <IDev2Definition> outputList)
        {
            IList <IInputOutputViewModel> displayOutputData = new List <IInputOutputViewModel>();

            foreach (IDev2Definition otp in outputList)
            {
                IInputOutputViewModel inputOutputViewModel = CreateInputOutputViewModel(otp.Name, otp.RawValue, otp.MapsTo, otp.DefaultValue, otp.IsRequired, otp.RecordSetName);
                displayOutputData.Add(inputOutputViewModel);
            }
            return(displayOutputData);
        }
Example #9
0
        protected override void ExecuteCore()
        {
            _copyOfBeforeAutoMapping.CopyFrom(_beforeAutoMapping);

            foreach (IInputOutputViewModel item in _beforeAutoMapping.Outputs)
            {
                IInputOutputViewModel tempItem = LoadOutputAutoMapping(item);
                item.Value  = tempItem.Value;
                item.MapsTo = tempItem.MapsTo;
            }
            _beforeAutoMapping.CreateXmlOutput(_beforeAutoMapping.Outputs, _beforeAutoMapping.Inputs);
        }
Example #10
0
        bool KeepInputOutputViewModelError(IInputOutputViewModel input)
        {
            bool keepError             = false;
            var  currentInputViewModel = input;
            var  inputOutputViewModel  = DataMappingViewModel?.Inputs.FirstOrDefault(c => c.Name == currentInputViewModel.Name);

            if (inputOutputViewModel != null)
            {
                inputOutputViewModel.Required = input.Required;
                if (inputOutputViewModel.MapsTo == string.Empty && inputOutputViewModel.Required)
                {
                    keepError = true;
                }
            }

            return(keepError);
        }
Example #11
0
        public void LoadInputAutoMappingInputOutputViewModelScalarValue_Expected_ReturnedItemThatWasPassedInForInputMapping()
        {
            _autoMappingInputAction = new AutoMappingInputAction(_mockDataMappingViewModel.Object, _mockWebActivity.Object);

            IInputOutputViewModel expected = _mockInputOutputViewModel.Object;
            IInputOutputViewModel actual;

            _mockInputOutputViewModel.Setup(c => c.Value).Returns(string.Empty);

            Mock <IDataListViewModel> mockDataListViewModel = Dev2MockFactory.SetupDataListViewModel();

            mockDataListViewModel.Setup(dlVM => dlVM.DataList).Returns(ReturnDefaultDataListViewModel(mockDataListViewModel.Object, false, "InputOutputTestDisplayName"));
            mockDataListViewModel.Setup(dlVM => dlVM.ScalarCollection).Returns(ReturnDefaultDataListViewModel(mockDataListViewModel.Object, false, "InputOutputTestDisplayName"));
            mockDataListViewModel.Setup(dlVM => dlVM.RecsetCollection).Returns(new OptomizedObservableCollection <IDataListItemModel>());

            DataListSingleton.SetDataList(mockDataListViewModel.Object);

            actual = _autoMappingInputAction.LoadInputAutoMapping(_mockInputOutputViewModel.Object);
            _mockInputOutputViewModel.VerifySet(input => input.Value = It.IsAny <string>(), Times.Exactly(1), "Input View Model failed to set to DataList Representation value");
        }
Example #12
0
        // PBI 6690 - 2013.07.04 - TWR : added
        void FixErrors()
        {
            if (!_versionsDifferent && (WorstDesignError.ErrorType == ErrorType.None || WorstDesignError.FixData == null))
            {
                return;
            }

            switch (WorstDesignError.FixType)
            {
            case FixType.ReloadMapping:
                ShowLarge = true;
                if (!_versionsDifferent)
                {
                    var xml     = FetchXElementFromFixData();
                    var inputs  = GetMapping(xml, true, DataMappingViewModel.Inputs);
                    var outputs = GetMapping(xml, false, DataMappingViewModel.Outputs);

                    DataMappingViewModel.Inputs.Clear();
                    foreach (var input in inputs)
                    {
                        DataMappingViewModel.Inputs.Add(input);
                    }

                    DataMappingViewModel.Outputs.Clear();
                    foreach (var output in outputs)
                    {
                        DataMappingViewModel.Outputs.Add(output);
                    }
                    SetInputs();
                    SetOuputs();
                    RemoveError(WorstDesignError);
                    UpdateWorstError();
                }
                else if (_versionsDifferent)
                {
                    ResourceModel = NewModel;
                    InitializeMappings();
                    RemoveErrors(
                        LastValidationMemo.Errors.Where(a => a.Message.Contains("Incorrect Version")).ToList());
                    UpdateWorstError();
                }
                break;

            case FixType.IsRequiredChanged:
                ShowLarge = true;
                var inputOutputViewModels = DeserializeMappings(true, FetchXElementFromFixData());
                foreach (var inputOutputViewModel in inputOutputViewModels.Where(c => c.Required))
                {
                    IInputOutputViewModel model = inputOutputViewModel;
                    var actualViewModel         = DataMappingViewModel.Inputs.FirstOrDefault(c => c.Name == model.Name);
                    if (actualViewModel != null)
                    {
                        if (actualViewModel.Value == string.Empty)
                        {
                            actualViewModel.RequiredMissing = true;
                        }
                    }
                }

                break;
            }
        }
Example #13
0
 public void OutputTextBoxGotFocus(IInputOutputViewModel selected)
 {
     //CurrentlySelectedOutput = Selected;
     CreateXmlOutput(Outputs, Inputs);
 }
Example #14
0
 public void OutputTextBoxGotFocus(IInputOutputViewModel selected)
 {
     //CurrentlySelectedOutput = Selected;
     CreateXmlOutput(Outputs, Inputs);
 }