private static CodeSummaryItem GetCodeSummaryHierarchy(CodeIds codeIds, Naturetypekodetre kodetre)
        {
            var r = new CodeSummaryItem();

            foreach (var codeId in codeIds)
            {
                var codeItem = kodetre.HentFraKode(codeId.Key);
                var codes    = r.Codes;
                foreach (var parentCodeItem in codeItem.ParentCodeItems)
                {
                    if (!codes.ContainsKey(parentCodeItem.Id))
                    {
                        var item = new CodeSummaryItem(parentCodeItem.Name, parentCodeItem.Url, 0);
                        foreach (var id in codeId.Value)
                        {
                            if (item.HandledIds.Contains(id))
                            {
                                continue;
                            }
                            item.Count++;
                            item.HandledIds.Add(id);
                        }
                        codes[parentCodeItem.Id] = item;
                    }
                    else
                    {
                        foreach (var id in codeId.Value)
                        {
                            if (codes[parentCodeItem.Id].HandledIds.Contains(id))
                            {
                                continue;
                            }
                            codes[parentCodeItem.Id].Count++;
                            codes[parentCodeItem.Id].HandledIds.Add(id);
                        }
                    }
                }

                if (!codes.ContainsKey(codeItem.Id))
                {
                    codes[codeItem.Id] = new CodeSummaryItem(codeItem.Name, codeItem.Url,
                                                             codeId.Value.Count);
                }
                else
                {
                    codes[codeItem.Id].Count += codeId.Value.Count;
                }
            }
            return(r);
        }
Esempio n. 2
0
        private static CodeSummaryItem GetCodeSummaryHierarchy(CodeIds idsForCodes, Naturetypekodetre kodetre)
        {
            var root = new CodeSummaryItem();

            var index = new Dictionary <string, CodeSummaryItem>();

            foreach (var idsForCode in idsForCodes)
            {
                var codeItemFromTree = kodetre.HentFraKode(idsForCode.Key);

                if (codeItemFromTree.Name == "?")
                {
                    continue;
                }

                HandleParents(root.Codes, index, codeItemFromTree);

                CodeSummaryItem item = null;

                if (!index.ContainsKey(codeItemFromTree.Id))
                {
                    item = new CodeSummaryItem(codeItemFromTree.Name, codeItemFromTree.Url, idsForCode.Value.Count);

                    if (codeItemFromTree.ParentCodeItems.Count > 0)
                    {
                        var parent = index[codeItemFromTree.ParentCodeItems.Last().Id];

                        parent.Codes.Add(codeItemFromTree.Id, item);
                    }
                    else
                    {
                        root.Codes.Add(codeItemFromTree.Id, item);
                    }

                    index.Add(codeItemFromTree.Id, item);
                }
                else
                {
                    item           = index[codeItemFromTree.Id];
                    item.OwnCount += idsForCode.Value.Count;
                }
            }

            return(root);
        }
Esempio n. 3
0
        private static void HandleParents(Dictionary <string, CodeSummaryItem> rootCodes, Dictionary <string, CodeSummaryItem> index, CodeItem codeItemFromTree)
        {
            CodeSummaryItem item = null;

            for (int i = 0; i < codeItemFromTree.ParentCodeItems.Count; i++)
            {
                var parent = codeItemFromTree.ParentCodeItems[i];
                item = new CodeSummaryItem(parent.Name, parent.Url, 0);

                if (i == 0 && !rootCodes.ContainsKey(parent.Id))
                {
                    rootCodes.Add(parent.Id, item);
                    index.Add(parent.Id, item);
                }
                else if (!index.ContainsKey(parent.Id))
                {
                    var parentOfParent = index[codeItemFromTree.ParentCodeItems[i - 1].Id];

                    parentOfParent.Codes.Add(parent.Id, item);

                    index.Add(parent.Id, item);
                }
            }
        }
Esempio n. 4
0
        public object GetNatureAreaSummary([FromBody] AreaFilterRequest areaFilterRequest)
        {
            if (string.IsNullOrWhiteSpace(areaFilterRequest.Geometry) && cachedNatureAreaSummary != null)
            {
                return(cachedNatureAreaSummary);
            }

            var geometry = "";

            if (areaFilterRequest != null)
            {
                geometry = areaFilterRequest.Geometry;
            }

            var natureAreaTypes        = SqlServer.GetNatureAreaSummary(geometry);
            var natureAreaTypeHash     = new CodeIds();
            var decriptionVariableHash = new CodeIds();

            foreach (var natureAreaTypeItem in natureAreaTypes)
            {
                if (natureAreaTypeItem.Item3)
                {
                    if (natureAreaTypeHash.ContainsKey(natureAreaTypeItem.Item1))
                    {
                        natureAreaTypeHash[natureAreaTypeItem.Item1].Add(natureAreaTypeItem.Item2);
                    }
                    else
                    {
                        natureAreaTypeHash[natureAreaTypeItem.Item1] = new HashSet <int> {
                            natureAreaTypeItem.Item2
                        }
                    };
                }
                else
                {
                    if (decriptionVariableHash.ContainsKey(natureAreaTypeItem.Item1))
                    {
                        decriptionVariableHash[natureAreaTypeItem.Item1].Add(natureAreaTypeItem.Item2);
                    }
                    else
                    {
                        decriptionVariableHash[natureAreaTypeItem.Item1] = new HashSet <int> {
                            natureAreaTypeItem.Item2
                        }
                    };
                }
            }

            CodeSummaryItem natureAreaTypeSummary      = GetNatureAreaTypeSummary(natureAreaTypeHash);
            CodeSummaryItem descriptionVariableSummary = GetDescriptionVariableSummary(decriptionVariableHash);

            var r = new NatureAreaSummary
            {
                NatureAreaTypes      = natureAreaTypeSummary,
                DescriptionVariables = descriptionVariableSummary
            };

            var jo = JObject.FromObject(r);

            RemoveFields(jo, "HandledIds", true);
            if (jo.First != null)
            {
                RemoveFields(jo.First.First, "Name", false);
                RemoveFields(jo.First.First, "Url", false);
                RemoveFields(jo.First.First, "Count", false);
            }
            if (jo.Last != null)
            {
                RemoveFields(jo.Last.First, "Name", false);
                RemoveFields(jo.Last.First, "Url", false);
                RemoveFields(jo.Last.First, "Count", false);
            }

            if (string.IsNullOrWhiteSpace(areaFilterRequest.Geometry))
            {
                cachedNatureAreaSummary = jo;
            }

            return(jo);
        }