private void ApplyFormat(Style style, ModuleFieldInfo field, ref Dictionary <object, string> listSource)
        {
            if (field.FieldType == CODES.DEFMODFLD.FLDTYPE.DATE)
            {
                style.Custom = "dd/MM/yyyy";
            }

            if (field.FieldType == CODES.DEFMODFLD.FLDTYPE.DATETIME)
            {
                style.Custom = "dd/MM/yyyy HH:mm:ss";
            }

            if (field.ListSource != null)
            {
                listSource = new Dictionary <object, string>();
                if (!string.IsNullOrEmpty(field.ListSource))
                {
                    var match = Regex.Match(field.ListSource, "^:([^.]+).([^.]+)$");

                    if (match.Success)
                    {
                        var codeType = match.Groups[1].Value;
                        var codeName = match.Groups[2].Value;
                        var codes    = CodeUtils.GetCodes(codeType, codeName);
                        foreach (var code in codes)
                        {
                            listSource.Add(
                                code.CodeValue.Decode(field), LangUtils.Translate(
                                    LangType.DEFINE_CODE,
                                    code.CodeType,
                                    code.CodeName,
                                    code.CodeValueName));
                        }
                    }
                    else
                    {
                        var procExpression = ExpressionUtils.ParseScript(field.ListSource);
                        if (procExpression != null && procExpression.StoreProcName != null)
                        {
                            var count = (from op in procExpression.Operands
                                         where op.Type == OperandType.NAME
                                         select 1).Count();
                            if (count == 0)
                            {
                                var sourceList = App.Environment.GetSourceList(ModuleInfo, field,
                                                                               (from operand in procExpression.Operands
                                                                                select operand.NameOrValue).ToList());

                                foreach (var item in sourceList)
                                {
                                    listSource.Add(item.Value.Decode(field), item.Text);
                                }
                            }
                        }
                    }
                }
            }
        }
Example #2
0
        public static string BuildSearchConditionKey(ModuleInfo moduleInfo, SearchConditionInstance conditionIntance)
        {
            if (conditionIntance.SQLLogic != null)
            {
                var conditions = new List <string>();
                foreach (var pCondition in conditionIntance.SubCondition)
                {
                    var strCondition = BuildSearchConditionKey(moduleInfo, pCondition);
                    if (!string.IsNullOrEmpty(strCondition))
                    {
                        conditions.Add(strCondition);
                    }
                }

                if (conditions.Count == 0)
                {
                    return(string.Empty);
                }

                switch (conditionIntance.SQLLogic)
                {
                case CODES.SQL_EXPRESSION.SQL_LOGIC.OR:
                    return("(" + string.Join(" OR ", conditions.ToArray()) + ")");

                default:
                    return("(" + string.Join(" AND ", conditions.ToArray()) + ")");
                }
            }

            var    condition = FieldUtils.GetModuleFieldByID(moduleInfo.ModuleID, conditionIntance.ConditionID);
            string conditionFormat;

            switch (conditionIntance.Operator)
            {
            case CODES.DEFMODFLD.CONDITION_OPERATOR.LIKE:
                conditionFormat = "{0} LIKE '%{1}%'";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.NOTLIKE:
                conditionFormat = "{0} NOT LIKE '%{1}%'";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.NOTEQUAL:
                conditionFormat = "{0} <> {1}";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.BEGINWITH:
                conditionFormat = "{0} LIKE '{1}%'";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.ENDWITH:
                conditionFormat = "{0} LIKE '%{1}'";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.LARGER:
                conditionFormat = "{0} > {1}";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.LARGEROREQUAL:
                conditionFormat = "{0} >= {1}";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.SMALLER:
                conditionFormat = "{0} < {1}";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.SMALLEROREQUAL:
                conditionFormat = "{0} <= {1}";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.INARRAY:
                conditionFormat = "{0} IN ({1})";
                break;

            case CODES.DEFMODFLD.CONDITION_OPERATOR.NOTINARRAY:
                conditionFormat = "{0} NOT IN ({1})";
                break;

            default:
                conditionFormat = "{0}={1}";
                break;
            }

            string fieldName;

            if (App.Environment.EnvironmentType == EnvironmentType.CLIENT_APPLICATION)
            {
                fieldName = string.Format("[{0}]",
                                          LangUtils.Translate(
                                              LangType.LABEL_FIELD,
                                              moduleInfo.ModuleName,
                                              condition.FieldName));
            }
            else
            {
                fieldName = condition.ParameterName;
            }

            if (conditionIntance.Value == null)
            {
                return(string.Format(conditionFormat, fieldName, null));
            }

            return(string.Format(conditionFormat, fieldName, conditionIntance.Value));
        }