示例#1
0
        /// <summary>
        /// Для указанной табличной секции
        /// </summary>
        /// <param name="sectionNode"></param>
        /// <param name="activityParameters"></param>
        /// <returns></returns>
        public static int GetNumForNewRow(this FlexNode sectionNode, EditableList <ActivityParameter> activityParameters)
        {
            var idParameters = sectionNode.GetIDParametersForSection();
            var numRow       = 0;
            var findedRows   = 0;

            foreach (var ap in activityParameters)
            {
                if (ap.IsMarkedToDelete)
                {
                    continue;
                }
                if (!ap.idfsParameter.HasValue || !ap.intNumRow.HasValue)
                {
                    continue;
                }
                if (!idParameters.Contains(ap.idfsParameter.Value))
                {
                    continue;
                }
                if (ap.intNumRow > numRow)
                {
                    numRow = ap.intNumRow.Value;
                }
                findedRows++;
            }
            if (findedRows > 0)
            {
                numRow++;
            }
            return(numRow);
        }
示例#2
0
        /// <summary>
        /// Формирует таблицу данных исходя из табличной секции верхнего уровня
        /// </summary>
        /// <param name="sectionNode"></param>
        /// <returns></returns>
        public static DataTable GetDataTableForSectionTable(this FlexNode sectionNode)
        {
            var section = sectionNode.GetSectionTemplate();

            if (section == null)
            {
                return(null);
            }
            if (!section.blnGrid)
            {
                return(null);
            }

            const string paramKey             = "idfsParameter";
            const string typeKey              = "columnType";
            const string widthKey             = "width";
            const string sectionKey           = "idfsSection";
            const string parameterTemplateKey = "parameterTemplate";

            var resultTable = new DataTable();

            //параметры станут столбцами
            var parameterTemplates = sectionNode.GetParameterTemplateForDataTable();
            //TODO проверить, не сломалось ли в других местах
            //parameterTemplates.Sort(new ParameterTemplateComparer());
            var predefinedStubs = sectionNode.GetPredefinedStubsForDataTable();

            predefinedStubs.Sort(new PredefinedStubComparer());

            var columnInfo = new List <IObject>();

            columnInfo.AddRange(predefinedStubs);
            columnInfo.AddRange(parameterTemplates);

            var idParameters = sectionNode.GetIDParametersForSection();
            var idRowsInStub = new List <long>();

            if (section.PredefinedStubRows != null)
            {
                foreach (var ps in section.PredefinedStubRows)
                {
                    if (ps.idfRow.HasValue)
                    {
                        idRowsInStub.Add(ps.idfRow.Value);
                    }
                }
            }

            //формируем остальные столбцы
            foreach (var columnInfoItem in columnInfo)
            {
                //могут быть только числовые или текстовые параметры
                //боковик не участвует в установке типа

                var  columnName        = String.Empty;
                var  nationalName      = String.Empty;
                var  type              = typeof(String);
                long idfsParameter     = 0;
                var  columnType        = 0; //0-ParameterTemplate, 1- PredefinedStub
                var  width             = 0;
                long idfsSection       = 0;
                var  parameterTemplate = columnInfoItem as ParameterTemplate;

                if (parameterTemplate != null)
                {
                    //для Summary надо отбирать только числовые параметры
                    if (parameterTemplate.IsParameterNumericPositive())
                    {
                        type = typeof(Double);
                    }
                    else if (parameterTemplate.IsParameterNumeric())
                    {
                        type = typeof(Int32);
                    }
                    else if (sectionNode.FFModel.IsSummary)
                    {
                        continue;
                    }

                    columnName    = GetColumnName(parameterTemplate.idfsParameter);//parameterTemplate.DefaultName;
                    nationalName  = parameterTemplate.NationalName;
                    idfsParameter = parameterTemplate.idfsParameter;
                    columnType    = 0;
                    width         = parameterTemplate.intWidth;
                    if (parameterTemplate.idfsSection.HasValue)
                    {
                        idfsSection = parameterTemplate.idfsSection.Value;
                    }
                }
                else
                {
                    var predefinedStub = columnInfoItem as PredefinedStub;
                    if ((predefinedStub != null) && (predefinedStub.idfsParameter.HasValue))
                    {
                        columnName    = GetColumnName(predefinedStub.idfsParameter.Value);//predefinedStub.strDefaultParameterName;
                        nationalName  = predefinedStub.strDefaultParameterName;
                        idfsParameter = predefinedStub.idfsParameter.Value;
                        columnType    = 1;
                        width         = 80; //??
                    }
                }

                if (idfsParameter > 0)
                {
                    var column = new DataColumn(columnName, type)
                    {
                        Caption = nationalName
                    };
                    column.ExtendedProperties.Add(paramKey, idfsParameter);
                    column.ExtendedProperties.Add(typeKey, columnType);
                    column.ExtendedProperties.Add(widthKey, width);
                    column.ExtendedProperties.Add(sectionKey, idfsSection);
                    if (parameterTemplate != null)
                    {
                        column.ExtendedProperties.Add(parameterTemplateKey, parameterTemplate);
                    }
                    resultTable.Columns.Add(column);
                }
            }

            //добавляем специальный столбец с ID строк
            resultTable.Columns.Add(new DataColumn("idfRow", typeof(Int64))
            {
                Caption = "idfRow"
            });

            //подставляем пользовательские данные
            if ((sectionNode.ActivityParameters != null) && (sectionNode.ActivityParameters.Count > 0))
            {
                //заполняем сначала все строки
                var activityParametersAll = sectionNode.ActivityParameters;
                activityParametersAll.Sort(new ActivityParametersComparer());
                var rowList = new List <DataRow>();
                foreach (var ap in activityParametersAll)
                {
                    if (ap.IsMarkedToDelete)
                    {
                        continue;
                    }
                    if (!ap.idfsParameter.HasValue)
                    {
                        continue;
                    }
                    //проверяем, находится ли параметр в этой таблице (может быть как тело таблицы, так и боковик)
                    if (!idParameters.Contains(ap.idfsParameter.Value))
                    {
                        continue;
                    }
                    //проверяем, чтобы эта строка присутствовала в боковике
                    if (idRowsInStub.Count > 0 && ap.idfRow.HasValue && !idRowsInStub.Contains(ap.idfRow.Value))
                    {
                        continue;
                    }

                    var row    = resultTable.NewRow();
                    var idfRow = ap.idfRow;
                    var finded = false;
                    foreach (var dataRow in rowList)
                    {
                        if (!idfRow.HasValue)
                        {
                            continue;
                        }
                        if (Convert.ToInt64(dataRow["idfRow"]) == idfRow.Value)
                        {
                            finded = true;
                            break;
                        }
                    }
                    if (finded)
                    {
                        continue;
                    }
                    //if (resultTable.Select(String.Format("idfRow={0}", idfRow)).Length > 0) continue;
                    row["idfRow"] = idfRow;
                    rowList.Add(row);
                    //resultTable.Rows.Add(row);
                }

                //теперь распихиваем остальные данные по строкам и столбцам
                foreach (var row in /*resultTable.Rows*/ rowList)
                {
                    var idfRow             = Convert.ToInt64(row["idfRow"]);
                    var activityParameters = sectionNode.ActivityParameters.Where(ap => ap.idfRow.HasValue && (ap.idfRow.Value == idfRow)).ToList();
                    if (activityParameters.Count == 0)
                    {
                        continue;
                    }
                    //построчно переносим все значения
                    foreach (DataColumn column in resultTable.Columns)
                    {
                        if ((!column.ExtendedProperties.ContainsKey(typeKey)) ||
                            (!column.ExtendedProperties.ContainsKey(paramKey)))
                        {
                            continue;
                        }

                        //var otkey = column.ExtendedProperties[typeKey];
                        var opkey = column.ExtendedProperties[paramKey];
                        //if ((otkey == null) || (opkey == null)) continue;
                        if (opkey == null)
                        {
                            continue;
                        }
                        var idfsParameter = Convert.ToInt64(opkey);
                        var ap            = activityParameters.FirstOrDefault(a => a.idfsParameter == idfsParameter);
                        if ((ap != null) && !ap.IsMarkedToDelete)
                        {
                            object value;
                            if (ap.strNameValue.Length > 0)
                            {
                                value = ap.strNameValue;
                            }
                            else
                            {
                                value = ap.varValue ?? String.Empty;
                                int i;
                                if (Int32.TryParse(value.ToString(), out i))
                                {
                                    value = i;
                                    if (i == 0)
                                    {
                                        value = String.Empty;
                                    }
                                }
                            }

                            var strValue = value.ToString();
                            if (strValue.Length > 0)
                            {
                                //уточняем формат выводимых дат
                                if (column.ExtendedProperties.Contains(parameterTemplateKey))
                                {
                                    var pt = column.ExtendedProperties[parameterTemplateKey] as ParameterTemplate;
                                    if ((pt != null) && pt.IsParameterDate())
                                    {
                                        var sp = strValue.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
                                        if (sp.Length > 0)
                                        {
                                            strValue = sp[0];
                                        }
                                    }
                                }

                                row[GetColumnName(idfsParameter)] = strValue;
                            }
                        }
                    }
                }

                //сортируем, упорядочивая по номерам строк. Это актуально для динамических таблиц.
                if (!section.IsFixedStubSection)
                {
                    rowList.Sort(new ActivityParametersRowsComparer());
                }
                foreach (var dataRow in rowList)
                {
                    resultTable.Rows.Add(dataRow);
                }
            }

            return(resultTable);
        }