コード例 #1
0
ファイル: BaseGenOsqlHelper.cs プロジェクト: leonchen09/poc
        /// <summary>
        /// extract all field in UDF tag
        /// </summary>
        /// <param name="bizName"></param>
        /// <param name="dataTagFields"></param>
        /// <param name="dataTagOthers"></param>
        /// <returns></returns>
        private InternalBookmarkItem AddUdfFields(string bizName, ref GenOsqlParamInfo paramInfo)
        {
            string               bookmarkKey = DateTime.Now.ToString(BaseProntoMarkup.BookmarkKeyFormat);
            DSTreeView           item        = paramInfo.DomainInfo.GetField(bizName);
            InternalBookmarkItem bm          = new InternalBookmarkItem(bookmarkKey, item.Text, item.TechName,
                                                                        item.Type.ToString(), item.TableIndex, item.Relation, 1);

            bm.UniqueName = item.UniqueName;
            bm.DataType   = item.DataType;
            bm.Type       = XsltType.Select;
            paramInfo.AddDataTags(bm, true);

            return(bm);
        }
コード例 #2
0
        public string GetUdfSortedBizName(string udfBizName)
        {
            try
            {
                DSTreeView item = GetField(udfBizName);

                if (item != null && item.Type == DSIconType.UDF)
                {
                    string sortedBizName = item.OrderByDate;
                    return(string.IsNullOrEmpty(sortedBizName) ? udfBizName : sortedBizName);
                }
            }
            catch { }

            return(udfBizName);
        }
コード例 #3
0
        private void GenSelectClauseForField(InternalBookmarkItem bmItem, ref GenOsqlParamInfo paramInfo)
        {
            string     itemName = BaseMarkupUtilities.GetOriginalBizName(bmItem.Key, bmItem.BizName);
            DSTreeView item     = paramInfo.DomainInfo.GetField(itemName);
            DSIconType type     = (DSIconType)Enum.Parse(typeof(DSIconType), bmItem.ItemType);

            double     i         = Math.Log((double)bmItem.TableIndex, (double)2);
            DSOnClause table     = paramInfo.DomainInfo.DSDomainData.OnClauses.Items[bmItem.TableIndex];
            string     tableName = table.Alias;

            paramInfo.PutSelectedTable(tableName, false);
            paramInfo.SelectedTableIndexes.Add(item.TableIndex);

            UpdateSelectedColumns(ref paramInfo, tableName, itemName);
            InternalBookmarkItem existedItem = paramInfo.DataTagFields.FirstOrDefault(a => a.TableIndex == item.TableIndex && a.DSIconType == DSIconType.Field);
            bool isImageTrunc = bmItem.IsTruncImage();

            if (isImageTrunc && existedItem != null && existedItem.BizName == bmItem.BizName && !paramInfo.TablesHasField.Contains(item.TableIndex))
            { // this table has only image that is chunked then we need to add one default column
                GenSelectClauseItem(DSIconType.Field, item.TechName,
                                    string.Empty, Guid.NewGuid().ToString(), false, true, ref paramInfo);
                paramInfo.TablesHasField.Add(item.TableIndex);
                paramInfo.HasImage = true;
            }
            GenSelectClauseItem(type, bmItem.TechName, item.JavaClause, itemName, bmItem.IsTruncImage(), true, ref paramInfo);

            if (!string.IsNullOrEmpty(item.RenderXYOrder))
            {
                List <string> renderParam = item.RenderXYOrder.Split(';').ToList <string>();
                for (int j = 0; j < renderParam.Count; j++)
                {
                    AddItemToListJParameters((renderParam[j] == "1") ? FrameworkConstants.RenderArgumentX : FrameworkConstants.RenderArgumentY,
                                             ref paramInfo, OracleQueryConstants.DicSelectClauseParamName);
                }
            }

            #region Build Extra field
            if (existedItem == null && !string.IsNullOrEmpty(item.OrginalField) && !paramInfo.TablesHasField.Contains(item.TableIndex))
            {
                GenSelectClauseItem(DSIconType.Field, item.OrginalField, string.Empty, Guid.NewGuid().ToString(), false, true, ref paramInfo);
                paramInfo.TablesHasField.Add(item.TableIndex);
                return;
            }
            #endregion
        }
コード例 #4
0
ファイル: BaseGenOsqlHelper.cs プロジェクト: leonchen09/poc
        /// <summary>
        /// get list of data tag fields, data tag others and renderxy
        /// </summary>
        /// <param name="paramInfo"></param>
        protected void AnalyzeDataTag(ref GenOsqlParamInfo paramInfo)
        {
            paramInfo.RenderXY = 0;
            paramInfo.UpdateUSCItemsDictionary();

            int itemIndex = 0;
            Dictionary <string, bool> dataTagChecker = new Dictionary <string, bool>();

            while (itemIndex < paramInfo.IbmDomain.InternalBookmarkItems.Count)
            {
                InternalBookmarkItem ibmItem = paramInfo.IbmDomain.InternalBookmarkItems[itemIndex];
                DSIconType           type    = ibmItem.DSIconType;
                string     itemName          = BaseMarkupUtilities.GetOriginalBizName(ibmItem.Key, ibmItem.BizName);
                DSTreeView dsObject          = paramInfo.DomainInfo.GetField(itemName);

                if (dsObject != null)
                {
                    paramInfo.RenderXY = paramInfo.RenderXY | CheckRenderXY(dsObject.RenderXYOrder);
                }
                else
                {
                    paramInfo.RenderXY = paramInfo.RenderXY | CheckRenderXY("0");
                }

                itemIndex++;
                if (ProcessEndForeachIfTag(ref paramInfo, ibmItem.Key, itemName, dataTagChecker))
                {
                    continue;
                }

                if (ProcessStartForeachTag(ibmItem.Key, ibmItem.BizName, ref paramInfo, ref dataTagChecker))
                {
                    continue;
                }

                if (ProcessUSCTag(ibmItem, type, itemName, ref paramInfo, ref dataTagChecker))
                {
                    continue;
                }

                ProcessSelectTag(ibmItem, type, itemName, ref paramInfo, ref dataTagChecker);
            }
        }
コード例 #5
0
ファイル: IntegrationService.cs プロジェクト: leonchen09/poc
        /// <summary>
        /// item match with datasegment when it (bizname, uniquename, DataType.Name) exist in datasegment
        /// </summary>
        /// <param name="item"></param>
        /// <param name="sFields"></param>
        /// <returns></returns>
        private bool IsMatchWithDataSegment(InternalBookmarkItem item, Dictionary <string, DSTreeView> sFields)
        {
            string bizName = item.BizName;

            if (sFields.ContainsKey(bizName))
            {
                DSTreeView sField = sFields[bizName];

                if (sField.Type == DSIconType.SystemInfo)
                {
                    return((item.BizName == sField.Text) && (item.TechName == sField.TechName) && sField.Visible);
                }
                if (sField.Type == DSIconType.RenderXY)
                {
                    string techname = sField.TechName.Replace("@", "");
                    return((item.BizName == sField.Text) && (item.TechName == techname) && sField.Visible);
                }

                return(item.OriginalUniqueName == System.Xml.XmlConvert.DecodeName(sField.UniqueName) &&
                       item.DataType.Name == sField.DataType.Name && sField.Visible);
            }

            return(false);
        }
コード例 #6
0
ファイル: BaseGenOsqlHelper.cs プロジェクト: leonchen09/poc
        /// <summary>
        /// separate osql to multi paths
        /// </summary>
        /// <param name="fullItems"></param>
        /// <param name="dsDomain"></param>
        /// <returns></returns>
        protected List <List <InternalBookmarkItem> > GetPaths(ref GenOsqlParamInfo paramInfo,
                                                               List <InternalBookmarkItem> fullItems, DSDomain dsDomain)
        {
            List <List <InternalBookmarkItem> > paths = new List <List <InternalBookmarkItem> >();

            #region calculate used table indexes
            Dictionary <int, List <InternalBookmarkItem> > usedTableIndexes = new Dictionary <int, List <InternalBookmarkItem> >();
            List <int> sortedTableIndexes = new List <int>();
            foreach (InternalBookmarkItem ibmItem in fullItems)
            {
                if (!usedTableIndexes.ContainsKey(ibmItem.TableIndex))
                {
                    usedTableIndexes.Add(ibmItem.TableIndex, new List <InternalBookmarkItem>());
                    sortedTableIndexes.Add(ibmItem.TableIndex);
                }

                usedTableIndexes[ibmItem.TableIndex].Add(ibmItem);
            }
            if (!usedTableIndexes.ContainsKey(0))
            {
                usedTableIndexes.Add(0, new List <InternalBookmarkItem>());
                sortedTableIndexes.Add(0);
            }
            sortedTableIndexes = sortedTableIndexes.OrderBy(c => c).ToList();
            #endregion

            #region get paths
            string whereClauseName                    = "WhereClause";
            Dictionary <int, bool> checker            = new Dictionary <int, bool>();
            List <DSRelationRow>   dsRelationRows     = dsDomain.TableRelations.Rows.Items;
            DSRelationRow          dsWhereRelationRow = dsRelationRows.FirstOrDefault(
                c => whereClauseName.Equals(c.Name, StringComparison.OrdinalIgnoreCase));
            string whereRelations = BitHelper.ToBinaryFormat(dsWhereRelationRow.Data, true);
            whereRelations = BaseMarkupUtilities.ReverseString(whereRelations);
            foreach (DSRelationRow dsRelationRow in dsRelationRows)
            {
                if (whereClauseName.Equals(dsRelationRow.Name, StringComparison.OrdinalIgnoreCase))
                {
                    paramInfo.DSWhereClauseRelationRow = dsRelationRow;
                    continue;
                }

                List <InternalBookmarkItem> path = new List <InternalBookmarkItem>();
                string relations = BitHelper.ToBinaryFormat(dsRelationRow.Data, true);
                relations = BaseMarkupUtilities.ReverseString(relations);
                bool hasTable = false;
                foreach (int tableIndex in sortedTableIndexes)
                {
                    int index = tableIndex;
                    if (relations.Length > index && relations[index] == '1')
                    {
                        path.AddRange(usedTableIndexes[tableIndex]);
                        if (!checker.ContainsKey(tableIndex))
                        {
                            hasTable = true;
                            checker.Add(tableIndex, true);
                        }
                    }
                }

                if (hasTable)
                {
                    int parentTableIndex = GetParentTableInexInJoinClause(dsWhereRelationRow, dsRelationRow);
                    if (!usedTableIndexes.ContainsKey(parentTableIndex))
                    {
                        usedTableIndexes.Add(parentTableIndex, new List <InternalBookmarkItem>());
                    }
                    InternalBookmarkItem ibmItem = usedTableIndexes[parentTableIndex].FirstOrDefault(
                        c => c.TableIndex == parentTableIndex && c.DSIconType == DSIconType.Field);
                    if (ibmItem == null)
                    {
                        DSTreeView firstField = paramInfo.DomainInfo.Fields.Values.FirstOrDefault(
                            c => c.TableIndex == parentTableIndex && c.Type == DSIconType.Field);
                        if (firstField != null)
                        {
                            ibmItem = new InternalBookmarkItem()
                            {
                                BizName    = firstField.Text,
                                ItemType   = "Field",
                                JavaName   = firstField.JavaClause,
                                Key        = Guid.NewGuid().ToString(),
                                OrderNo    = 1,
                                TableIndex = parentTableIndex,
                                TechName   = firstField.TechName,
                                Type       = XsltType.Select
                            };

                            usedTableIndexes[parentTableIndex].Insert(0, ibmItem);
                            path.Insert(0, ibmItem);
                        }
                    }

                    paths.Add(path);
                }
            }
            #endregion

            return(paths);
        }