예제 #1
0
        private Dictionary <string, AllCodesCode[]> CreateKartleggingsenheter(NiNDbContext dbContext, IEnumerable <Kartleggingsenhet> entities, string host)
        {
            var codes = new Dictionary <int, IList <AllCodesCode> >();

            foreach (var k in entities)
            {
                var kartleggingsenhet = dbContext.Kartleggingsenhet
                                        .Include(x => x.Kode)
                                        .FirstOrDefault(x => x.Id == k.Id);

                if (kartleggingsenhet == null)
                {
                    continue;
                }

                var enumValue = NinEnumConverter.GetValue <MalestokkEnum>(kartleggingsenhet.Malestokk);
                var scale     = int.Parse(Regex.Match(enumValue, @"\d+").Value, NumberFormatInfo.InvariantInfo);
                if (!codes.ContainsKey(scale))
                {
                    codes.Add(scale, new List <AllCodesCode>());
                }

                codes[scale].Add(ConvertNinKode2Code(kartleggingsenhet.Kode, host));
            }

            return(codes.ToDictionary(code => code.Key.ToString(), code => CreateOrderedList(code.Value)));
        }
예제 #2
0
        private Step[] CreateTrinn(NiNDbContext dbContext, IEnumerable <Trinn> entities)
        {
            var steps = new List <Step>();

            foreach (var t in entities)
            {
                var trinn = dbContext.Trinn
                            .Include(x => x.Kode)
                            .Include(x => x.Basistrinn)
                            .FirstOrDefault(x => x.Id == t.Id);

                if (trinn == null)
                {
                    continue;
                }

                steps.Add(new Step
                {
                    Navn       = trinn.Navn,
                    Kode       = trinn.Kode.KodeName,
                    Basistrinn = string.Join(", ", trinn.Basistrinn.Select(x => x.Navn).ToList().OrderByList <IList <string> >())
                });
            }

            return(steps.OrderBy(x => x.Kode).ToArray());
        }
예제 #3
0
        private EnvironmentVariable[] CreateMiljovariabler(NiNDbContext dbContext, IEnumerable <Miljovariabel> entities)
        {
            var variables = new List <EnvironmentVariable>();

            foreach (var m in entities)
            {
                var miljovariabel = dbContext.Miljovariabel
                                    .Include(x => x.Kode)
                                    .Include(x => x.Trinn)
                                    .FirstOrDefault(x => x.Id == m.Id);

                if (miljovariabel == null)
                {
                    continue;
                }

                variables.Add(new EnvironmentVariable
                {
                    Kode        = miljovariabel.Kode.Kode,
                    LKMKategori = miljovariabel.LkmKategori,
                    Navn        = miljovariabel.Navn,
                    Type        = miljovariabel.Type,
                    Trinn       = CreateTrinn(dbContext, miljovariabel.Trinn)
                });
            }

            return(variables.OrderBy(x => x.Kode).ToArray());
        }
예제 #4
0
        private VarietyCodeCode[] CreateUnderordnetKoder(NiNDbContext dbContext, ICollection <VarietyLevel5> koder, string host)
        {
            if (koder == null || !koder.Any())
            {
                return(null);
            }

            var list = new List <VarietyCodeCode>();

            foreach (var kode in koder)
            {
                var k = dbContext.VarietyLevel5s
                        .Include(x => x.Kode)
                        .FirstOrDefault(x => x.Id == kode.Id);

                if (k == null)
                {
                    continue;
                }

                list.Add(new VarietyCodeCode
                {
                    Id         = k.Kode.KodeName,
                    Definition = $"{host}{k.Kode.KodeName.Replace(" ", "_")}"
                });
            }

            return(CreateOrderedList(list));
        }
예제 #5
0
        public Stream ExportToCsv(NiNDbContext dbContext, string version)
        {
            var ninCodeExport = new NinCodeExport(dbContext, version);
            var stream        = ninCodeExport.GenerateStream();

            if (stream == null)
            {
                return(null);
            }

            stream.Seek(0, SeekOrigin.Begin);
            return(stream);
        }
예제 #6
0
 public IEnumerable <Codes> GetAll(NiNDbContext dbContext, string host, string version = "", bool tree = false)
 {
     using (var session = _store.OpenSession())
     {
         var query = session.Query <NaturTypeV21B>(IndexName);
         using (var enumerator = session.Advanced.Stream(query))
         {
             while (enumerator.MoveNext())
             {
                 yield return(CreateCodesByNaturtype(enumerator.Current?.Document, host));
             }
         }
     }
 }
 public IEnumerable <VarietyAllCodes> GetAll(NiNDbContext dbContext, string host, string version = "")
 {
     using (var session = _store.OpenSession())
     {
         var query = session.Query <VariasjonV22>(IndexName);
         using (var enumerator = session.Advanced.Stream(query))
         {
             while (enumerator.MoveNext())
             {
                 yield return(CreateVarietyAllCodes(enumerator.Current?.Document, $"{host}hentkode/"));
             }
         }
     }
 }
예제 #8
0
        private AllCodesCode[] CreateUnderordnetKoder(NiNDbContext dbContext, IEnumerable <Hovedtype> entities, string host)
        {
            var codes = new List <AllCodesCode>();

            foreach (var h in entities)
            {
                var hovedtype = dbContext.Hovedtype
                                .Include(x => x.Kode)
                                .FirstOrDefault(x => x.Id == h.Id);

                if (hovedtype == null)
                {
                    continue;
                }

                codes.Add(ConvertNinKode2Code(hovedtype.Kode, host));
            }

            return(CreateOrderedList(codes));
        }
예제 #9
0
        public IEnumerable <Codes> GetAll(NiNDbContext dbContext, string host, string version = "", bool tree = false)
        {
            var list = new List <Codes>();

            using (var session = _store.OpenSession())
            {
                var query = session.Query <NaturTypeV22>(IndexName);
                using (var enumerator = session.Advanced.Stream(query))
                {
                    while (enumerator.MoveNext())
                    {
                        list.Add(CreateCodesByNaturtype(enumerator.Current?.Document, $"{host}hentkode/"));
                    }
                }
            }

            list.Sort(new CodesComparer());

            return(list);
        }
        public VarietyCode GetByKode(NiNDbContext dbContext, string id, string host, string version = "")
        {
            if (string.IsNullOrEmpty(id))
            {
                return(null);
            }

            using (var session = _store.OpenSession())
            {
                var query = session.Query <VariasjonV22>(IndexName).Where(x => x.Kode.Equals(id, StringComparison.OrdinalIgnoreCase));
                using (var enumerator = session.Advanced.Stream(query))
                {
                    while (enumerator.MoveNext())
                    {
                        return(CreateVarietyCode(enumerator.Current?.Document, host));
                    }
                }
            }

            return(null);
        }
예제 #11
0
        public Codes GetByKode(NiNDbContext dbContext, string id, string host, string version = "")
        {
            if (string.IsNullOrEmpty(id))
            {
                return(null);
            }

            id = id.Replace("_", " ");

            using (var session = _store.OpenSession())
            {
                var query = session.Query <NaturTypeV21B>(IndexName).Where(x => x.Kode.Equals(id, StringComparison.OrdinalIgnoreCase));
                using (var enumerator = session.Advanced.Stream(query))
                {
                    while (enumerator.MoveNext())
                    {
                        return(CreateCodesByNaturtype(enumerator.Current?.Document, host));
                    }
                }
            }

            return(null);
        }
예제 #12
0
        public IEnumerable <Codes> GetAll(NiNDbContext dbContext, string host, string version = "", bool tree = false)
        {
            if (host.EndsWith("koder/", StringComparison.OrdinalIgnoreCase))
            {
                host += "hentkode/";
            }

            var kodeList = dbContext.Kode.Include(x => x.Version).Where(x => x.Version.Navn.Equals(version)).ToList();

            foreach (var kode in kodeList)
            {
                Codes code = null;
                switch (kode.Kategori)
                {
                case KategoriEnum.Naturmangfoldnivå:
                    var natursystem = dbContext.Natursystem
                                      .Include(x => x.Kode)
                                      .Include(x => x.UnderordnetKoder)
                                      .FirstOrDefault(x => x.Kode.Id == kode.Id);
                    if (natursystem == null)
                    {
                        continue;
                    }

                    code = new Codes
                    {
                        Navn     = natursystem.Navn,
                        Kategori = natursystem.Kategori,
                        Kode     = ConvertNinKode2Code(natursystem.Kode, host)
                    };
                    if (natursystem.UnderordnetKoder.Any())
                    {
                        code.UnderordnetKoder = CreateUnderordnetKoder(dbContext, natursystem.UnderordnetKoder, host);
                    }

                    break;

                case KategoriEnum.Hovedtypegruppe:
                    var hovedtypegruppe = dbContext.Hovedtypegruppe
                                          .Include(x => x.Natursystem)
                                          .Include(x => x.Natursystem.Kode)
                                          .Include(x => x.Kode)
                                          .Include(x => x.UnderordnetKoder)
                                          .FirstOrDefault(x => x.Kode.Id == kode.Id);

                    if (hovedtypegruppe == null)
                    {
                        break;
                    }

                    code = new Codes
                    {
                        Navn           = hovedtypegruppe.Navn,
                        Kategori       = hovedtypegruppe.Kategori,
                        Kode           = ConvertNinKode2Code(hovedtypegruppe.Kode, host),
                        OverordnetKode = ConvertNinKode2Code(hovedtypegruppe.Natursystem.Kode, host)
                    };

                    if (hovedtypegruppe.UnderordnetKoder.Any())
                    {
                        code.UnderordnetKoder = CreateUnderordnetKoder(dbContext, hovedtypegruppe.UnderordnetKoder, host);
                    }

                    break;

                case KategoriEnum.Hovedtype:

                    var hovedtype = dbContext.Hovedtype
                                    .Include(x => x.Hovedtypegruppe)
                                    .Include(x => x.Hovedtypegruppe.Kode)
                                    .Include(x => x.UnderordnetKoder)
                                    .Include(x => x.Kartleggingsenheter)
                                    .Include(x => x.Miljovariabler)
                                    .FirstOrDefault(x => x.Kode.Id == kode.Id);

                    if (hovedtype == null)
                    {
                        break;
                    }

                    code = new Codes
                    {
                        Navn           = hovedtype.Navn,
                        Kategori       = hovedtype.Kategori,
                        Kode           = ConvertNinKode2Code(hovedtype.Kode, host),
                        OverordnetKode = ConvertNinKode2Code(hovedtype.Hovedtypegruppe.Kode, host)
                    };

                    if (hovedtype.UnderordnetKoder.Any())
                    {
                        code.UnderordnetKoder = CreateUnderordnetKoder(dbContext, hovedtype.UnderordnetKoder, host);
                    }

                    if (hovedtype.Kartleggingsenheter.Any())
                    {
                        code.Kartleggingsenheter = CreateKartleggingsenheter(dbContext, hovedtype.Kartleggingsenheter, host);
                    }

                    if (hovedtype.Miljovariabler.Any())
                    {
                        code.Miljovariabler = CreateMiljovariabler(dbContext, hovedtype.Miljovariabler);
                    }

                    break;

                case KategoriEnum.Grunntype:

                    var grunntype = dbContext.Grunntype
                                    .Include(x => x.Hovedtype)
                                    .Include(x => x.Hovedtype.Kode)
                                    .FirstOrDefault(x => x.Kode.Id == kode.Id);

                    if (grunntype == null)
                    {
                        break;
                    }

                    code = new Codes
                    {
                        Navn           = grunntype.Navn,
                        Kategori       = grunntype.Kategori,
                        Kode           = ConvertNinKode2Code(grunntype.Kode, host),
                        OverordnetKode = ConvertNinKode2Code(grunntype.Hovedtype.Kode, host)
                    };

                    break;

                case KategoriEnum.Kartleggingsenhet:

                    var kartleggingsenhet = dbContext.Kartleggingsenhet
                                            .Include(x => x.Grunntype)
                                            .FirstOrDefault(x => x.Kode.Id == kode.Id);

                    if (kartleggingsenhet == null)
                    {
                        break;
                    }

                    code = new Codes
                    {
                        Navn      = kartleggingsenhet.Definisjon,
                        Kategori  = kartleggingsenhet.Kategori,
                        Malestokk = kartleggingsenhet.Malestokk,
                        Kode      = ConvertNinKode2Code(kartleggingsenhet.Kode, host)
                    };

                    var kgs = new List <Codes>();
                    foreach (var kg in kartleggingsenhet.Grunntype)
                    {
                        var g = dbContext.Grunntype
                                .FirstOrDefault(x => x.Id == kg.Id);
                        if (g == null)
                        {
                            continue;
                        }
                        kgs.Add(new Codes
                        {
                            Navn           = g.Navn,
                            Kategori       = g.Kategori,
                            Kode           = ConvertNinKode2Code(g.Kode, host),
                            OverordnetKode = ConvertNinKode2Code(g.Hovedtype.Kode, host)
                        });
                    }

                    if (kgs.Any())
                    {
                        code.Grunntyper = kgs.ToArray();
                    }

                    break;
                }

                if (code == null)
                {
                    continue;
                }

                yield return(code);
            }
        }
예제 #13
0
 public NinCodeImport(NiNDbContext ninContext, string version)
 {
     _context          = ninContext;
     _version          = version;
     _csvConfiguration = new CsvConfiguration(new CultureInfo("nb-NO"));
 }
예제 #14
0
 public IEnumerable <string> GetVersions(NiNDbContext dbContext)
 {
     return(dbContext.NinVersion.Select(x => $"v{x.Navn}"));
 }
예제 #15
0
 public NinCodeExport(NiNDbContext ninContext, string version)
 {
     _context = ninContext;
     _version = version;
 }
예제 #16
0
 public bool ImportFromCsv(Stream stream, NiNDbContext dbContext, string version)
 {
     throw new System.NotImplementedException();
 }
예제 #17
0
        public IEnumerable <VarietyAllCodes> GetAll(NiNDbContext dbContext, string host, string version = "")
        {
            if (host.EndsWith("variasjon/", StringComparison.OrdinalIgnoreCase))
            {
                host += "hentkode/";
            }
            var varietyList = dbContext.VariasjonKode.Include(x => x.Version).Where(x => x.Version.Navn.Equals(version)).ToList();

            foreach (var variety in varietyList)
            {
                VarietyAllCodes codes = null;

                switch (variety.VarietyCategory)
                {
                case VarietyEnum.VarietyLevel0:
                    var v0 = dbContext.VarietyLevel0s
                             .Include(x => x.Kode)
                             //.Include(x => x.UnderordnetKoder)
                             .FirstOrDefault(x => x.Kode.Id == variety.Id);

                    if (v0 == null)
                    {
                        continue;
                    }

                    codes = CreateVarietyAllCodes(v0, host);

                    break;

                case VarietyEnum.VarietyLevel1:
                    var v1 = dbContext.VarietyLevel1s
                             .Include(x => x.Kode)
                             .Include(x => x.OverordnetKode.Kode)
                             //.Include(x => x.UnderordnetKoder)
                             .FirstOrDefault(x => x.Kode.Id == variety.Id);

                    if (v1 == null)
                    {
                        continue;
                    }

                    codes = CreateVarietyAllCodes(v1, host);

                    break;

                case VarietyEnum.VarietyLevel2:
                    var v2 = dbContext.VarietyLevel2s
                             .Include(x => x.Kode)
                             .Include(x => x.OverordnetKode.Kode)
                             //.Include(x => x.UnderordnetKoder)
                             .FirstOrDefault(x => x.Kode.Id == variety.Id);

                    if (v2 == null)
                    {
                        continue;
                    }

                    codes = CreateVarietyAllCodes(v2, host);

                    break;

                case VarietyEnum.VarietyLevel3:
                    var v3 = dbContext.VarietyLevel3s
                             .Include(x => x.Kode)
                             .Include(x => x.OverordnetKode.Kode)
                             //.Include(x => x.UnderordnetKoder)
                             .FirstOrDefault(x => x.Kode.Id == variety.Id);

                    if (v3 == null)
                    {
                        continue;
                    }

                    codes = CreateVarietyAllCodes(v3, host);

                    break;

                case VarietyEnum.VarietyLevel4:
                    var v4 = dbContext.VarietyLevel4s
                             .Include(x => x.Kode)
                             .Include(x => x.OverordnetKode.Kode)
                             //.Include(x => x.UnderordnetKoder)
                             .FirstOrDefault(x => x.Kode.Id == variety.Id);

                    if (v4 == null)
                    {
                        continue;
                    }

                    codes = CreateVarietyAllCodes(v4, host);

                    break;

                case VarietyEnum.VarietyLevel5:
                    var v5 = dbContext.VarietyLevel5s
                             .Include(x => x.Kode)
                             .Include(x => x.OverordnetKode.Kode)
                             //.Include(x => x.UnderordnetKoder)
                             .FirstOrDefault(x => x.Kode.Id == variety.Id);

                    if (v5 == null)
                    {
                        continue;
                    }

                    codes = CreateVarietyAllCodes(v5, host);

                    break;
                }

                if (codes == null)
                {
                    continue;
                }

                yield return(codes);
            }
        }
예제 #18
0
        public VarietyCode GetByKode(NiNDbContext dbContext, string id, string host, string version = "")
        {
            if (string.IsNullOrEmpty(id))
            {
                return(null);
            }

            var ninVersion = dbContext.NinVersion.FirstOrDefault(x => x.Navn.Equals(version));

            if (ninVersion == null)
            {
                return(null);
            }

            id = id.Replace(" ", "_");

            var variety = dbContext.VariasjonKode
                          .FirstOrDefault(x => x.Version.Id == ninVersion.Id && x.KodeName.Equals(id));

            if (variety == null)
            {
                return(null);
            }

            VarietyCode varietyCode = null;

            switch (variety.VarietyCategory)
            {
            case VarietyEnum.VarietyLevel0:
                var v0 = dbContext.VarietyLevel0s
                         .Include(x => x.Kode)
                         .Include(x => x.UnderordnetKoder)
                         .FirstOrDefault(x => x.Kode.Id == variety.Id);

                if (v0 == null)
                {
                    return(null);
                }

                varietyCode = new VarietyCode
                {
                    Name             = v0.Navn,
                    Code             = ConvertVarietyCode(v0.Kode, host),
                    UnderordnetKoder = CreateUnderordnetKoder(dbContext, v0.UnderordnetKoder, host)
                };
                break;

            case VarietyEnum.VarietyLevel1:
                var v1 = dbContext.VarietyLevel1s
                         .Include(x => x.Kode)
                         .Include(x => x.OverordnetKode.Kode)
                         .Include(x => x.UnderordnetKoder)
                         .FirstOrDefault(x => x.Kode.Id == variety.Id);

                if (v1 == null)
                {
                    return(null);
                }

                varietyCode = new VarietyCode
                {
                    Name           = v1.Navn,
                    Code           = ConvertVarietyCode(v1.Kode, host),
                    OverordnetKode = new VarietyCodeCode
                    {
                        Id         = v1.OverordnetKode.Kode.KodeName,
                        Definition = $"{host}{v1.OverordnetKode.Kode.KodeName}"
                    },
                    UnderordnetKoder = CreateUnderordnetKoder(dbContext, v1.UnderordnetKoder, host)
                };
                break;

            case VarietyEnum.VarietyLevel2:
                var v2 = dbContext.VarietyLevel2s
                         .Include(x => x.Kode)
                         .Include(x => x.OverordnetKode.Kode)
                         .Include(x => x.UnderordnetKoder)
                         .FirstOrDefault(x => x.Kode.Id == variety.Id);

                if (v2 == null)
                {
                    return(null);
                }

                varietyCode = new VarietyCode
                {
                    Name           = v2.Navn,
                    Code           = ConvertVarietyCode(v2.Kode, host),
                    OverordnetKode = new VarietyCodeCode
                    {
                        Id         = v2.OverordnetKode.Kode.KodeName,
                        Definition = $"{host}{v2.OverordnetKode.Kode.KodeName}"
                    },
                    UnderordnetKoder = CreateUnderordnetKoder(dbContext, v2.UnderordnetKoder, host)
                };
                break;

            case VarietyEnum.VarietyLevel3:
                var v3 = dbContext.VarietyLevel3s
                         .Include(x => x.Kode)
                         .Include(x => x.OverordnetKode.Kode)
                         .Include(x => x.UnderordnetKoder)
                         .FirstOrDefault(x => x.Kode.Id == variety.Id);

                if (v3 == null)
                {
                    return(null);
                }

                varietyCode = new VarietyCode
                {
                    Name           = v3.Navn,
                    Code           = ConvertVarietyCode(v3.Kode, host),
                    OverordnetKode = new VarietyCodeCode
                    {
                        Id         = v3.OverordnetKode.Kode.KodeName,
                        Definition = $"{host}{v3.OverordnetKode.Kode.KodeName}"
                    },
                    UnderordnetKoder = CreateUnderordnetKoder(dbContext, v3.UnderordnetKoder, host)
                };
                break;

            case VarietyEnum.VarietyLevel4:
                var v4 = dbContext.VarietyLevel4s
                         .Include(x => x.Kode)
                         .Include(x => x.OverordnetKode.Kode)
                         .Include(x => x.UnderordnetKoder)
                         .FirstOrDefault(x => x.Kode.Id == variety.Id);

                if (v4 == null)
                {
                    return(null);
                }

                varietyCode = new VarietyCode
                {
                    Name           = v4.Navn,
                    Code           = ConvertVarietyCode(v4.Kode, host),
                    OverordnetKode = new VarietyCodeCode
                    {
                        Id         = v4.OverordnetKode.Kode.KodeName,
                        Definition = $"{host}{v4.OverordnetKode.Kode.KodeName}"
                    },
                    UnderordnetKoder = CreateUnderordnetKoder(dbContext, v4.UnderordnetKoder, host)
                };
                break;

            case VarietyEnum.VarietyLevel5:
                var v5 = dbContext.VarietyLevel5s
                         .Include(x => x.Kode)
                         .Include(x => x.OverordnetKode.Kode)
                         .FirstOrDefault(x => x.Kode.Id == variety.Id);

                if (v5 == null)
                {
                    return(null);
                }

                varietyCode = new VarietyCode
                {
                    Name           = v5.Navn,
                    Code           = ConvertVarietyCode(v5.Kode, host),
                    OverordnetKode = new VarietyCodeCode
                    {
                        Id         = v5.OverordnetKode.Kode.KodeName,
                        Definition = $"{host}{v5.OverordnetKode.Kode.KodeName}"
                    }
                };
                break;
            }

            return(varietyCode);
        }
예제 #19
0
        //public IEnumerable<Codes> GetAlll(NiNDbContext dbContext, string host, string version = "", bool tree = false)
        //{
        //    if (host.EndsWith("koder/", StringComparison.OrdinalIgnoreCase)) host += "hentkode/";

        //    var kodeList = dbContext.Kode.Include(x => x.Version).Where(x => x.Version.Navn.Equals(version)).ToList();
        //    foreach (var kode in kodeList)
        //    {
        //        Codes code = null;
        //        switch (kode.Kategori)
        //        {
        //            case KategoriEnum.Naturmangfoldnivå:
        //                var natursystem = dbContext.Natursystem
        //                    .Include(x => x.Kode)
        //                    .Include(x => x.UnderordnetKoder)
        //                    .FirstOrDefault(x => x.Kode.Id == kode.Id);
        //                if (natursystem == null) continue;

        //                code = new Codes
        //                {
        //                    Navn = natursystem.Navn,
        //                    Kategori = natursystem.Kategori,
        //                    Kode = ConvertNinKode2Code(natursystem.Kode, host)
        //                };
        //                if (natursystem.UnderordnetKoder.Any())
        //                {
        //                    code.UnderordnetKoder = CreateUnderordnetKoder(dbContext, natursystem.UnderordnetKoder, host);
        //                }

        //                break;

        //            case KategoriEnum.Hovedtypegruppe:
        //                var hovedtypegruppe = dbContext.Hovedtypegruppe
        //                    .Include(x => x.Natursystem)
        //                    .Include(x => x.Natursystem.Kode)
        //                    .Include(x => x.Kode)
        //                    .Include(x => x.UnderordnetKoder)
        //                    .FirstOrDefault(x => x.Kode.Id == kode.Id);

        //                if (hovedtypegruppe == null) break;

        //                code = new Codes
        //                {
        //                    Navn = hovedtypegruppe.Navn,
        //                    Kategori = hovedtypegruppe.Kategori,
        //                    Kode = ConvertNinKode2Code(hovedtypegruppe.Kode, host),
        //                    OverordnetKode = ConvertNinKode2Code(hovedtypegruppe.Natursystem.Kode, host)
        //                };

        //                if (hovedtypegruppe.UnderordnetKoder.Any())
        //                {
        //                    code.UnderordnetKoder = CreateUnderordnetKoder(dbContext, hovedtypegruppe.UnderordnetKoder, host);
        //                }

        //                break;

        //            case KategoriEnum.Hovedtype:

        //                var hovedtype = dbContext.Hovedtype
        //                    .Include(x => x.Hovedtypegruppe)
        //                    .Include(x => x.Hovedtypegruppe.Kode)
        //                    .Include(x => x.UnderordnetKoder)
        //                    .Include(x => x.Kartleggingsenheter)
        //                    .Include(x => x.Miljovariabler)
        //                    .FirstOrDefault(x => x.Kode.Id == kode.Id);

        //                if (hovedtype == null) break;

        //                code = new Codes
        //                {
        //                    Navn = hovedtype.Navn,
        //                    Kategori = hovedtype.Kategori,
        //                    Kode = ConvertNinKode2Code(hovedtype.Kode, host),
        //                    OverordnetKode = ConvertNinKode2Code(hovedtype.Hovedtypegruppe.Kode, host)
        //                };

        //                if (hovedtype.UnderordnetKoder.Any())
        //                {
        //                    code.UnderordnetKoder = CreateUnderordnetKoder(dbContext, hovedtype.UnderordnetKoder, host);
        //                }

        //                if (hovedtype.Kartleggingsenheter.Any())
        //                {
        //                    code.Kartleggingsenheter = CreateKartleggingsenheter(dbContext, hovedtype.Kartleggingsenheter, host);
        //                }

        //                if (hovedtype.Miljovariabler.Any())
        //                {
        //                    code.Miljovariabler = CreateMiljovariabler(dbContext, hovedtype.Miljovariabler);
        //                }

        //                break;

        //            case KategoriEnum.Grunntype:

        //                var grunntype = dbContext.Grunntype
        //                    .Include(x => x.Hovedtype)
        //                    .Include(x => x.Hovedtype.Kode)
        //                    .FirstOrDefault(x => x.Kode.Id == kode.Id);

        //                if (grunntype == null) break;

        //                code = new Codes
        //                {
        //                    Navn = grunntype.Navn,
        //                    Kategori = grunntype.Kategori,
        //                    Kode = ConvertNinKode2Code(grunntype.Kode, host),
        //                    OverordnetKode = ConvertNinKode2Code(grunntype.Hovedtype.Kode, host)
        //                };

        //                break;

        //        }

        //        if (code == null) continue;

        //        yield return code;
        //    }
        //}

        public Codes GetByKode(NiNDbContext dbContext, string id, string host, string version = "")
        {
            if (string.IsNullOrEmpty(id))
            {
                return(null);
            }

            var ninVersion = dbContext.NinVersion.FirstOrDefault(x => x.Navn.Equals(version));

            if (ninVersion == null)
            {
                return(null);
            }

            id = id.Replace("_", " ");

            var kode = dbContext.Kode
                       .FirstOrDefault(x => x.Version.Id == ninVersion.Id && x.KodeName.Equals(id));

            if (kode == null)
            {
                return(null);
            }

            Codes code = null;

            switch (kode.Kategori)
            {
            case KategoriEnum.Naturmangfoldnivå:
                var natursystem = dbContext.Natursystem
                                  .Include(x => x.Kode)
                                  .Include(x => x.UnderordnetKoder)
                                  .AsSplitQuery()
                                  .FirstOrDefault(x => x.Kode.Id == kode.Id);

                if (natursystem == null)
                {
                    return(null);
                }

                code = new Codes
                {
                    Navn     = natursystem.Navn,
                    Kategori = natursystem.Kategori,
                    Kode     = ConvertNinKode2Code(natursystem.Kode, host)
                };

                if (natursystem.UnderordnetKoder.Any())
                {
                    code.UnderordnetKoder = CreateUnderordnetKoder(dbContext, natursystem.UnderordnetKoder, host);
                }

                break;

            case KategoriEnum.Hovedtypegruppe:
                var hovedtypegruppe = dbContext.Hovedtypegruppe
                                      .Include(x => x.Natursystem)
                                      .Include(x => x.Natursystem.Kode)
                                      .Include(x => x.Kode)
                                      .Include(x => x.UnderordnetKoder)
                                      .AsSplitQuery()
                                      .FirstOrDefault(x => x.Kode.Id == kode.Id);

                if (hovedtypegruppe == null)
                {
                    break;
                }

                code = new Codes
                {
                    Navn           = hovedtypegruppe.Navn,
                    Kategori       = hovedtypegruppe.Kategori,
                    Kode           = ConvertNinKode2Code(hovedtypegruppe.Kode, host),
                    OverordnetKode = ConvertNinKode2Code(hovedtypegruppe.Natursystem.Kode, host)
                };

                if (hovedtypegruppe.UnderordnetKoder.Any())
                {
                    code.UnderordnetKoder = CreateUnderordnetKoder(dbContext, hovedtypegruppe.UnderordnetKoder, host);
                }

                break;

            case KategoriEnum.Hovedtype:
                var hovedtype = dbContext.Hovedtype
                                .Include(x => x.Hovedtypegruppe)
                                .Include(x => x.Hovedtypegruppe.Kode)
                                .Include(x => x.UnderordnetKoder)
                                .Include(x => x.Kartleggingsenheter)
                                .Include(x => x.Miljovariabler)
                                .AsSplitQuery()
                                .FirstOrDefault(x => x.Kode.Id == kode.Id);

                if (hovedtype == null)
                {
                    break;
                }

                code = new Codes
                {
                    Navn           = hovedtype.Navn,
                    Kategori       = hovedtype.Kategori,
                    Kode           = ConvertNinKode2Code(hovedtype.Kode, host),
                    OverordnetKode = ConvertNinKode2Code(hovedtype.Hovedtypegruppe.Kode, host)
                };

                if (hovedtype.UnderordnetKoder.Any())
                {
                    code.UnderordnetKoder = CreateUnderordnetKoder(dbContext, hovedtype.UnderordnetKoder, host);
                }

                if (hovedtype.Kartleggingsenheter.Any())
                {
                    code.Kartleggingsenheter = CreateKartleggingsenheter(dbContext, hovedtype.Kartleggingsenheter, host);
                }

                if (hovedtype.Miljovariabler.Any())
                {
                    code.Miljovariabler = CreateMiljovariabler(dbContext, hovedtype.Miljovariabler);
                }

                break;

            case KategoriEnum.Grunntype:
                var grunntype = dbContext.Grunntype
                                .Include(x => x.Hovedtype)
                                .Include(x => x.Hovedtype.Kode)
                                .Include(x => x.Kartleggingsenhet)
                                .Include(x => x.Basistrinn)
                                .AsSplitQuery()
                                .FirstOrDefault(x => x.Kode.Id == kode.Id);

                if (grunntype == null)
                {
                    break;
                }

                code = new Codes
                {
                    Navn           = grunntype.Navn,
                    Kategori       = grunntype.Kategori,
                    Kode           = ConvertNinKode2Code(grunntype.Kode, host),
                    OverordnetKode = ConvertNinKode2Code(grunntype.Hovedtype.Kode, host)
                };

                if (grunntype.Kartleggingsenhet.Any())
                {
                    code.Kartleggingsenheter = CreateKartleggingsenheter(dbContext, grunntype.Kartleggingsenhet, host);
                }

                if (grunntype.Basistrinn.Any())
                {
                    var list = grunntype.Basistrinn.Select(b => new AllCodesCode {
                        Id = b.Navn
                    }).ToList();

                    code.Basistrinn = list.OrderBy(x => x.Id).ToArray();
                }

                break;

            case KategoriEnum.Kartleggingsenhet:
                var kartlegging = dbContext.Kartleggingsenhet
                                  .Include(x => x.Hovedtype)
                                  .Include(x => x.Hovedtype.Kode)
                                  .Include(x => x.Grunntype)
                                  .AsSplitQuery()
                                  .FirstOrDefault(x => x.Kode.Id == kode.Id);

                if (kartlegging == null)
                {
                    break;
                }

                code = new Codes
                {
                    Navn           = kartlegging.Definisjon,
                    Kategori       = NinEnumConverter.GetValue <KategoriEnum>(kartlegging.Kode.Kategori),
                    Malestokk      = kartlegging.Malestokk,
                    Kode           = ConvertNinKode2Code(kartlegging.Kode, host),
                    OverordnetKode = ConvertNinKode2Code(kartlegging.Hovedtype.Kode, host)
                };

                if (kartlegging.Grunntype.Any())
                {
                    var grunntyper = new List <Codes>();
                    foreach (var item in kartlegging.Grunntype)
                    {
                        var g = dbContext.Grunntype
                                .Include(x => x.Kode)
                                .FirstOrDefault(x => x.Id == item.Id);

                        if (g == null)
                        {
                            continue;
                        }

                        grunntyper.Add(new Codes
                        {
                            Navn     = g.Navn,
                            Kategori = g.Kategori,
                            Kode     = ConvertNinKode2Code(g.Kode, host)
                        });
                    }
                    code.Grunntyper = grunntyper.ToArray();
                }

                break;
            }

            return(code);
        }