protected override void Execute(NativeActivityContext context)
        {
            var entity = Entity.Get(context);
            var obj    = entity as WMSBusinessObject;

            if (obj == null)
            {
                throw new NotImplementedException(string.Format("Тип '{0}' не поддерживается", entity.GetType()));
            }
            var objname = SourceNameHelper.Instance.GetSourceName(obj.GetType());
            // получим параметры MUST_SET
            var mustSetList    = GetProperties(context);
            var pmConfigs      = mustSetList as IList <PMConfig> ?? mustSetList.ToList();
            var mustProperties = pmConfigs.Select(pm => pm.ObjectName_r).Distinct();
            var objFields      = DataFieldHelper.Instance.GetDataFields(typeof(T), wmsMLC.General.PL.SettingDisplay.Detail);

            // проход по каждому параметру вперед и назад
            foreach (var attrName in mustProperties)
            {
                var methods     = pmConfigs.Where(pm => pm.ObjectName_r == attrName).Select(pm => pm.MethodCode_r).Distinct().ToList();
                var setNull     = methods.Exists(m => m == "SET_NULL");
                var mustSet     = methods.Exists(m => m == "MUST_SET");
                var mustCorrect = methods.Exists(m => m == "MUST_MANUAL_CORRECT");
                if (!setNull && !mustSet && !mustCorrect)
                {
                    continue;
                }

                var attrValue    = obj.GetProperty(attrName);
                var defaultValue = obj.GetPropertyDefaultValue(attrName);
                var datafield    = objFields.FirstOrDefault(i => i.Name.EqIgnoreCase(attrName));
                if (datafield == null)
                {
                    throw new DeveloperException("Ошибка в настройках менеджера товара. Задан неизвестный параметр '{0}.{1}'.", objname, attrName);
                }
                var field = new ValueDataField(datafield)
                {
                    LabelPosition = "Top"
                };
                // если у параметра есть значение по-умолчанию и оно совпадает с реальным, то необходимо подтверждение ввода
                if (!mustCorrect && !setNull && attrValue != null && !Equals(attrValue, defaultValue))
                {
                    continue;
                }

                // параметры атрибута
                field.Value = setNull
                    ? null
                    : (attrValue == null && defaultValue != null)
                        ? defaultValue
                        : attrValue;

                field.IsRequired = mustSet;

                if (string.IsNullOrEmpty(field.LookupCode))
                {
                    field.CloseDialog = true;
                }
                else //Если поле лукап
                {
                    field.Set(ValueDataFieldConstants.LookupType, RclLookupType.SelectControl.ToString());
                    field.Set(ValueDataFieldConstants.MaxRowsOnPage, MaxRowsOnPage.Get(context));
                }

                // *-* //
                var model   = GetMainModel(context, field);
                var showKey = ShowKey.Get(context);
                while (true) // делаем это для возврата на форму
                {
                    if (showKey)
                    {
                        model.PanelCaption = string.Format("Введите значение ('{0}')", obj.GetKey());
                    }

                    if (!ShowDialog(model))
                    {
                        throw new OperationException("Не были указаны обязательные параметры.");
                    }

                    var errorMessage = new StringBuilder();
                    switch (string.Format("1{0}", model.MenuResult))
                    {
                    case "1":
                    case "1F1":
                        var value = model[field.Name];
                        if (value == null && field.IsRequired)
                        {
                            errorMessage.AppendLine(string.Format("Не заполнено обязательное поле '{0}'.", field.Caption));
                        }
                        else
                        {
                            obj.SetProperty(field.Name, value);
                        }
                        break;

                    default:
                        throw new DeveloperException("Неизвестная команда.");
                    }
                    // если были ошибки, то покажем что не так и вернемся на форму
                    if (errorMessage.Length > 0)
                    {
                        var viewService = IoC.Instance.Resolve <IViewService>();
                        viewService.ShowDialog("Ошибка", errorMessage.ToString(), System.Windows.MessageBoxButton.OK,
                                               System.Windows.MessageBoxImage.Error, System.Windows.MessageBoxResult.OK);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            Entity.Set(context, obj);
        }
Esempio n. 2
0
        protected override void Execute(NativeActivityContext context)
        {
            var entity = Entity.Get(context);
            var obj    = entity as WMSBusinessObject;

            if (obj == null)
            {
                throw new NotImplementedException(string.Format("Тип '{0}' не поддерживается", entity.GetType()));
            }
            // получим параметры MUST_SET
            var mustSetList = GetMustSetProperies(context).ToArray();

            var objFields = DataFieldHelper.Instance.GetDataFields(typeof(T), wmsMLC.General.PL.SettingDisplay.Detail);
            var history   = HistoryPropertyValue.Get(context);

            // проход по каждому параметру вперед и назад
            foreach (var m in mustSetList)
            {
                // если у параметра есть значение, то оно может быть по умолчанию
                var defaultValue = obj.GetPropertyDefaultValue(m.PmConfig.ObjectName_r);
                if (obj.GetProperty(m.PmConfig.ObjectName_r) == null || defaultValue != null || m.Show)
                {
                    var datafield = objFields.FirstOrDefault(i => i.Name.EqIgnoreCase(m.PmConfig.ObjectName_r));
                    if (datafield == null)
                    {
                        throw new DeveloperException("Ошибка в настройках {1} менеджера товара. Задан неизвестный параметр '{0}'.", m.PmConfig.ObjectName_r, m.PmConfig.MethodCode_r);
                    }

                    var field = new ValueDataField(datafield)
                    {
                        LabelPosition = "Top"
                    };

                    if (defaultValue != null)
                    {
                        field.Value = defaultValue;
                    }

                    if (m.Show)
                    {
                        field.Value = obj.GetProperty(m.PmConfig.ObjectName_r);
                    }

                    //Массовый ввод
                    if (m.Set && m.PmConfig.PMCONFIGINPUTMASS == true && history != null && history.ContainsKey(field.Name))
                    {
                        field.Value = history[field.Name];
                    }

                    if (string.IsNullOrEmpty(field.LookupCode))
                    {
                        field.CloseDialog = true;
                    }
                    else //Если поле лукап
                    {
                        field.LabelPosition = "None";
                        field.Set(ValueDataFieldConstants.LookupType, RclLookupType.SelectControl.ToString());
                        field.Set(ValueDataFieldConstants.MaxRowsOnPage, MaxRowsOnPage.Get(context));
                    }

                    var model = GetMainModel(context, field);
                    if (m.Show)
                    {
                        model.PanelCaption = model.PanelCaption + " [Опционально]";
                    }

                    while (true) // делаем это для возврата на форму
                    {
                        var show = ShowDialog(model);
                        if (!show && m.Set)
                        {
                            throw new OperationException("Не были указаны обязательные параметры.");
                        }

                        if (!show && m.Show)
                        {
                            break;
                        }

                        var errorMessage = new StringBuilder();
                        switch (string.Format("1{0}", model.MenuResult))
                        {
                        case "1":
                        case "1F1":
                            var value = model[field.Name];
                            if (value == null && m.Set)
                            {
                                errorMessage.AppendLine(string.Format("Не заполнено обязательное поле '{0}'.",
                                                                      field.Caption));
                            }
                            else
                            {
                                //Дополнительные параметры PMConfig
                                if (m.Set && !string.IsNullOrEmpty(m.PmConfig.PMCONFIGINPUTMASK) && value is string)
                                {
                                    var expressions = Regex.Matches((string)value, m.PmConfig.PMCONFIGINPUTMASK,
                                                                    RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
                                    if (expressions.Count > 0)
                                    {
                                        errorMessage.AppendLine(string.Format("Поле '{0}' не прошло проверку по маске.", field.Caption));
                                    }
                                }

                                if (errorMessage.Length == 0)
                                {
                                    obj.SetProperty(field.Name, value);
                                    if (history != null)
                                    {
                                        history[field.Name] = value;
                                    }
                                }
                            }
                            break;

                        default:
                            throw new DeveloperException("Неизвестная команда.");
                        }
                        // если были ошибки, то покажем что не так и вернемся на форму
                        if (errorMessage.Length > 0)
                        {
                            var viewService = IoC.Instance.Resolve <IViewService>();
                            viewService.ShowDialog("Ошибка", errorMessage.ToString(),
                                                   System.Windows.MessageBoxButton.OK,
                                                   System.Windows.MessageBoxImage.Error, System.Windows.MessageBoxResult.OK);
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }

            Entity.Set(context, obj);
            if (history != null)
            {
                HistoryPropertyValue.Set(context, history);
            }
        }
        protected override void Execute(NativeActivityContext context)
        {
            const string isnullerrorformat = "Свойство '{0}' должно быть задано.";

            var entities = Entities.Get(context);

            if (entities == null)
            {
                throw new DeveloperException(isnullerrorformat, EntitiesDisplayName);
            }

            var artcodepropertyname = ArtCodePropertyName.Get(context);

            if (string.IsNullOrEmpty(artcodepropertyname))
            {
                throw new DeveloperException(isnullerrorformat, ArtCodePropertyNameDisplayName);
            }

            var operationCode = OperationCode.Get(context);

            if (string.IsNullOrEmpty(operationCode))
            {
                throw new DeveloperException(isnullerrorformat, OperationCodeDisplayName);
            }

            var boEntities = entities.OfType <WMSBusinessObject>().ToArray();

            //Получаем список артикулов из Entities
            var arts = boEntities.Select(p => p.GetProperty <string>(artcodepropertyname)).Distinct().ToArray();

            var result = boEntities.ToArray();

            var objFields = DataFieldHelper.Instance.GetDataFields(typeof(T), SettingDisplay.Detail);

            foreach (var artcode in arts)
            {
                var propList = GetPmMethodProperies(artcode, operationCode, context);
                var boEntity = result.FirstOrDefault(p => p.GetProperty <string>(artcodepropertyname) == artcode);
                if (boEntity == null)
                {
                    continue;
                }

                foreach (var method in propList.Keys)
                {
                    foreach (var property in propList[method])
                    {
                        var compareValues = result.Select(p => p.GetProperty(property)).Distinct().ToArray();
                        if (compareValues.Length <= 1)
                        {
                            continue; //Пропускаем
                        }
                        var datafield = objFields.FirstOrDefault(i => i.Name.EqIgnoreCase(property));
                        if (datafield == null)
                        {
                            throw new DeveloperException(
                                      "Ошибка в настройках '{0}' PM. Задан неизвестный параметр '{1}'.", method, property);
                        }

                        var field = new ValueDataField(datafield)
                        {
                            LabelPosition = "Top"
                        };
                        if (method == PMMethods.MUST_COMPARE_VISIBLE)
                        {
                            field.Value = boEntity.GetProperty(property);
                        }

                        if (string.IsNullOrEmpty(field.LookupCode))
                        {
                            field.CloseDialog = true;
                        }
                        else //Если поле лукап
                        {
                            field.LabelPosition = "None";
                            field.Set(ValueDataFieldConstants.LookupType, RclLookupType.SelectControl.ToString());
                            field.Set(ValueDataFieldConstants.MaxRowsOnPage, MaxRowsOnPage.Get(context));
                        }

                        var model = CreateDialogModel(context, field);
                        while (true) // делаем это для возврата на форму
                        {
                            if (!ShowDialog(model))
                            {
                                throw new OperationException("Значения полей не были указаны.");
                            }

                            var errorMessage = new StringBuilder();
                            switch (string.Format("1{0}", model.MenuResult))
                            {
                            case "1":
                            case "1Return":
                                var value = model[field.Name];
                                if (!compareValues.Any(p => Equals(value, p)))
                                {
                                    errorMessage.AppendLine(string.Format("Неверное значение поля '{0}'.",
                                                                          field.Caption));
                                }
                                else
                                {
                                    result = result.Where(p => Equals(value, p.GetProperty(property))).ToArray();
                                }
                                break;

                            default:
                                throw new DeveloperException("Неизвестная команда.");
                            }
                            // если были ошибки, то покажем что не так и вернемся на форму
                            if (errorMessage.Length > 0)
                            {
                                var viewService = IoC.Instance.Resolve <IViewService>();
                                viewService.ShowDialog("Ошибка", errorMessage.ToString(), MessageBoxButton.OK,
                                                       MessageBoxImage.Error, MessageBoxResult.OK);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                }
            }

            Result.Set(context, result.OfType <T>().ToArray());
        }