/// <summary>
 /// Danner et bogføringsresultat for en bogføringslinje.
 /// </summary>
 /// <param name="bogføringslinje">Bogførignslinje.</param>
 public Bogføringsresultat(Bogføringslinje bogføringslinje)
 {
     if (bogføringslinje == null)
     {
         throw new ArgumentNullException("bogføringslinje");
     }
     // Initiering og validering af bogføringslinje.
     _bogføringslinje = bogføringslinje;
     if (_bogføringslinje.Konto == null)
     {
         throw new IntranetSystemException(Resource.GetExceptionMessage(ExceptionMessage.IllegalValue, _bogføringslinje.Konto, "Konto"));
     }
     // Dan eventuelle bogføringsadvarsler.
     _bogføringslinje.Konto.Calculate(_bogføringslinje.Dato, _bogføringslinje.Løbenummer);
     if (_bogføringslinje.Konto.DisponibelPrStatusdato < 0M)
     {
         _advarsler.Add(new Bogføringsadvarsel(Resource.GetExceptionMessage(ExceptionMessage.AccountIsOverdrawn), _bogføringslinje.Konto, Math.Abs(_bogføringslinje.Konto.DisponibelPrStatusdato)));
     }
     if (_bogføringslinje.Budgetkonto == null)
     {
         return;
     }
     _bogføringslinje.Budgetkonto.Calculate(_bogføringslinje.Dato, _bogføringslinje.Løbenummer);
     if (_bogføringslinje.Kredit != 0M && _bogføringslinje.Budgetkonto.BudgetPrStatusdato <= 0M && _bogføringslinje.Budgetkonto.DisponibelPrStatusdato < 0M)
     {
         _advarsler.Add(new Bogføringsadvarsel(Resource.GetExceptionMessage(ExceptionMessage.BudgetAccountIsOverdrawn), _bogføringslinje.Budgetkonto, Math.Abs(_bogføringslinje.Budgetkonto.DisponibelPrStatusdato)));
     }
 }
Exemplo n.º 2
0
        public void TestAtConstructorDannerBogføringsadvarselVedOvertrækPåKonto()
        {
            var fixture = new Fixture();

            fixture.Inject(DateTime.Now);

            var loebenr = fixture.Create <int>();
            var konto   = fixture.Create <Konto>();

            Assert.That(konto, Is.Not.Null);
            konto.TilføjKreditoplysninger(new Kreditoplysninger(fixture.Create <DateTime>().Year, fixture.Create <DateTime>().Month, 50000M));
            konto.TilføjBogføringslinje(new Bogføringslinje(loebenr, fixture.Create <DateTime>(), fixture.Create <string>(), fixture.Create <string>(), 0M, 48000M));

            var bogføringslinje = new Bogføringslinje(loebenr + 1, fixture.Create <DateTime>(), fixture.Create <string>(), fixture.Create <string>(), 0M, 5000M);

            Assert.That(bogføringslinje, Is.Not.Null);
            konto.TilføjBogføringslinje(bogføringslinje);

            var bogføringsresultat = new Bogføringsresultat(bogføringslinje);

            Assert.That(bogføringsresultat, Is.Not.Null);
            Assert.That(bogføringsresultat.Bogføringslinje, Is.Not.Null);
            Assert.That(bogføringsresultat.Bogføringslinje, Is.EqualTo(bogføringslinje));
            Assert.That(bogføringsresultat.Advarsler, Is.Not.Null);
            Assert.That(bogføringsresultat.Advarsler, Is.TypeOf(typeof(List <IBogføringsadvarsel>)));
            Assert.That(bogføringsresultat.Advarsler.Count(), Is.EqualTo(1));

            var bogføringsadvarsel = bogføringsresultat.Advarsler.ElementAt(0);

            Assert.That(bogføringsadvarsel, Is.Not.Null);
            Assert.That(bogføringsadvarsel.Advarsel, Is.Not.Null);
            Assert.That(bogføringsadvarsel.Konto, Is.Not.Null);
            Assert.That(bogføringsadvarsel.Konto, Is.EqualTo(konto));
            Assert.That(bogføringsadvarsel.Beløb, Is.EqualTo(3000M));
        }
Exemplo n.º 3
0
        public void TestAtQueryHenterBogføringslinjer()
        {
            var fixture = new Fixture();
            var random  = new Random(fixture.Create <int>());

            var statusDate = fixture.Create <DateTime>();
            var regnskab   = fixture.Create <Regnskab>();

            foreach (var konto in fixture.CreateMany <Konto>(3))
            {
                regnskab.TilføjKonto(konto);
                while (konto.Bogføringslinjer.Count() < 25)
                {
                    var bogføringslinje = new Bogføringslinje(fixture.Create <int>(), statusDate.AddDays(random.Next(0, 365) * -1), fixture.Create <string>(), fixture.Create <string>(), fixture.Create <decimal>(), fixture.Create <decimal>());
                    konto.TilføjBogføringslinje(bogføringslinje);
                }
            }

            var finansstyringRepository = MockRepository.GenerateMock <IFinansstyringRepository>();

            finansstyringRepository.Expect(m => m.RegnskabGet(Arg <int> .Is.Anything, Arg <Func <int, Brevhoved> > .Is.NotNull, Arg <Func <int, AdresseBase> > .Is.NotNull))
            .Return(regnskab);
            var adresseRepository = MockRepository.GenerateMock <IAdresseRepository>();

            adresseRepository.Expect(m => m.AdresseGetAll())
            .Return(fixture.CreateMany <Person>(25));
            var fællesRepository = MockRepository.GenerateMock <IFællesRepository>();

            fællesRepository.Expect(m => m.BrevhovedGetAll())
            .Return(fixture.CreateMany <Brevhoved>(3));
            var objectMapper = MockRepository.GenerateMock <IObjectMapper>();

            objectMapper.Expect(m => m.Map <Bogføringslinje, BogføringslinjeView>(Arg <Bogføringslinje> .Is.NotNull))
            .Return(fixture.Create <BogføringslinjeView>())
            .Repeat.Any();

            fixture.Inject(finansstyringRepository);
            fixture.Inject(adresseRepository);
            fixture.Inject(fællesRepository);
            fixture.Inject(objectMapper);
            var queryHandler = fixture.Create <BogføringerGetQueryHandler>();

            Assert.That(queryHandler, Is.Not.Null);

            var query = new BogføringerGetQuery
            {
                Regnskabsnummer = regnskab.Nummer,
                StatusDato      = statusDate,
                Linjer          = 30
            };
            var bogføringslinjer = queryHandler.Query(query);

            Assert.That(bogføringslinjer, Is.Not.Null);
            Assert.That(bogføringslinjer.Count(), Is.EqualTo(query.Linjer));

            finansstyringRepository.AssertWasCalled(m => m.RegnskabGet(Arg <int> .Is.Equal(query.Regnskabsnummer), Arg <Func <int, Brevhoved> > .Is.NotNull, Arg <Func <int, AdresseBase> > .Is.NotNull));
            adresseRepository.AssertWasCalled(m => m.AdresseGetAll());
            fællesRepository.AssertWasCalled(m => m.BrevhovedGetAll());
        }
Exemplo n.º 4
0
 /// <summary>
 /// Tilføjer en bogføringslinje til adressen.
 /// </summary>
 /// <param name="bogføringslinje">Bogføringslinje.</param>
 public virtual void TilføjBogføringslinje(Bogføringslinje bogføringslinje)
 {
     if (bogføringslinje == null)
     {
         throw new ArgumentNullException("bogføringslinje");
     }
     bogføringslinje.SætAdresse(this);
     _bogføringslinjer.Add(bogføringslinje);
 }
        /// <summary>
        /// Danner domæneobjekt bygger.
        /// </summary>
        public DomainObjectBuilder()
        {
            var mapperConfiguration = new MapperConfiguration(config =>
            {
                config.CreateMap <AdressereferenceView, AdresseBase>()
                .ConvertUsing(s => { throw new NotSupportedException(); });

                config.CreateMap <PersonView, AdresseBase>()
                .ConvertUsing(s =>
                {
                    Adressegruppe adressegruppe;
                    lock (SyncRoot)
                    {
                        if (GetAdressegruppeCallback == null)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetAdressegruppeCallback"));
                        }
                        try
                        {
                            adressegruppe = GetAdressegruppeCallback(s.Adressegruppe.Nummer);
                        }
                        catch (IntranetRepositoryException)
                        {
                            throw;
                        }
                        catch (Exception ex)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Adressegruppe).Name, s.Adressegruppe.Nummer), ex);
                        }
                    }
                    var person = new Person(s.Nummer, s.Navn, adressegruppe);
                    person.SætAdresseoplysninger(s.Adresse1, s.Adresse2, s.PostnummerBy);
                    person.SætTelefon(s.Telefon, s.Mobil);
                    person.SætFødselsdato(s.Fødselsdato);
                    person.SætBekendtskab(s.Bekendtskab);
                    person.SætMailadresse(s.Mailadresse);
                    person.SætWebadresse(s.Webadresse);
                    if (s.Betalingsbetingelse != null)
                    {
                        Betalingsbetingelse betalingsbetingelse;
                        lock (SyncRoot)
                        {
                            if (GetBetalingsbetingelseCallback == null)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetBetalingsbetingelseCallback"));
                            }
                            try
                            {
                                betalingsbetingelse = GetBetalingsbetingelseCallback(s.Betalingsbetingelse.Nummer);
                            }
                            catch (IntranetRepositoryException)
                            {
                                throw;
                            }
                            catch (Exception ex)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Betalingsbetingelse).Name, s.Betalingsbetingelse.Nummer), ex);
                            }
                        }
                        person.SætBetalingsbetingelse(betalingsbetingelse);
                    }
                    person.SætUdlånsfrist(s.Udlånsfrist);
                    person.SætFilofaxAdresselabel(s.FilofaxAdresselabel);
                    if (s.Firma != null)
                    {
                        Firma firma;
                        lock (SyncRoot)
                        {
                            if (GetAdresseBaseCallback == null)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetAdresseBaseCallback"));
                            }
                            try
                            {
                                firma = (Firma)GetAdresseBaseCallback(s.Firma.Nummer);
                            }
                            catch (IntranetRepositoryException)
                            {
                                throw;
                            }
                            catch (Exception ex)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Firma).Name, s.Firma.Nummer), ex);
                            }
                        }
                        firma.TilføjPerson(person);
                    }
                    return(person);
                });

                config.CreateMap <FirmaView, AdresseBase>()
                .ConvertUsing(s =>
                {
                    Adressegruppe adressegruppe;
                    lock (SyncRoot)
                    {
                        if (GetAdressegruppeCallback == null)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetAdressegruppeCallback"));
                        }
                        try
                        {
                            adressegruppe = GetAdressegruppeCallback(s.Adressegruppe.Nummer);
                        }
                        catch (IntranetRepositoryException)
                        {
                            throw;
                        }
                        catch (Exception ex)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Adressegruppe).Name, s.Adressegruppe.Nummer), ex);
                        }
                    }
                    var firma = new Firma(s.Nummer, s.Navn, adressegruppe);
                    firma.SætAdresseoplysninger(s.Adresse1, s.Adresse2, s.PostnummerBy);
                    firma.SætTelefon(s.Telefon1, s.Telefon2, s.Telefax);
                    firma.SætBekendtskab(s.Bekendtskab);
                    firma.SætMailadresse(s.Mailadresse);
                    firma.SætWebadresse(s.Webadresse);
                    if (s.Betalingsbetingelse != null)
                    {
                        Betalingsbetingelse betalingsbetingelse;
                        lock (SyncRoot)
                        {
                            if (GetBetalingsbetingelseCallback == null)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetBetalingsbetingelseCallback"));
                            }
                            try
                            {
                                betalingsbetingelse = GetBetalingsbetingelseCallback(s.Betalingsbetingelse.Nummer);
                            }
                            catch (IntranetRepositoryException)
                            {
                                throw;
                            }
                            catch (Exception ex)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Betalingsbetingelse).Name, s.Betalingsbetingelse.Nummer), ex);
                            }
                        }
                        firma.SætBetalingsbetingelse(betalingsbetingelse);
                    }
                    firma.SætUdlånsfrist(s.Udlånsfrist);
                    firma.SætFilofaxAdresselabel(s.FilofaxAdresselabel);
                    return(firma);
                });

                config.CreateMap <PostnummerView, Postnummer>()
                .ConvertUsing(s => new Postnummer(s.Landekode, s.Postnummer, s.Bynavn));

                config.CreateMap <AdressegruppeView, Adressegruppe>()
                .ConvertUsing(s => new Adressegruppe(s.Nummer, s.Navn, s.AdressegruppeOswebdb));

                config.CreateMap <BetalingsbetingelseView, Betalingsbetingelse>()
                .ConvertUsing(s => new Betalingsbetingelse(s.Nummer, s.Navn));

                config.CreateMap <RegnskabListeView, Regnskab>()
                .ConvertUsing(s =>
                {
                    var regnskab = new Regnskab(s.Nummer, s.Navn);
                    if (s.Brevhoved != null && s.Brevhoved.Nummer != 0)
                    {
                        Brevhoved brevhoved;
                        lock (SyncRoot)
                        {
                            if (GetBrevhovedCallback == null)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetBrevhovedCallback"));
                            }
                            try
                            {
                                brevhoved = GetBrevhovedCallback(s.Brevhoved.Nummer);
                            }
                            catch (IntranetRepositoryException)
                            {
                                throw;
                            }
                            catch (Exception ex)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Brevhoved).Name, s.Brevhoved.Nummer), ex);
                            }
                        }
                        regnskab.SætBrevhoved(brevhoved);
                    }
                    return(regnskab);
                });

                config.CreateMap <RegnskabView, Regnskab>()
                .ConvertUsing(s =>
                {
                    var regnskab = new Regnskab(s.Nummer, s.Navn);
                    if (s.Brevhoved != null && s.Brevhoved.Nummer != 0)
                    {
                        Brevhoved brevhoved;
                        lock (SyncRoot)
                        {
                            if (GetBrevhovedCallback == null)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetBrevhovedCallback"));
                            }
                            try
                            {
                                brevhoved = GetBrevhovedCallback(s.Brevhoved.Nummer);
                            }
                            catch (IntranetRepositoryException)
                            {
                                throw;
                            }
                            catch (Exception ex)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Brevhoved).Name, s.Brevhoved.Nummer), ex);
                            }
                        }
                        regnskab.SætBrevhoved(brevhoved);
                    }
                    lock (SyncRoot)
                    {
                        var cached = _regnskaber.SingleOrDefault(m => m.Nummer == regnskab.Nummer);
                        if (cached != null)
                        {
                            _regnskaber.Remove(cached);
                        }
                        _regnskaber.Add(regnskab);
                        var regnskabslisteHelper = new RegnskabslisteHelper(_regnskaber);
                        GetRegnskabCallback      = regnskabslisteHelper.GetById;
                        foreach (var konto in BuildMany <KontoView, Konto>(s.Konti))
                        {
                            regnskab.TilføjKonto(konto);
                        }
                        foreach (var budgetkonto in BuildMany <BudgetkontoView, Budgetkonto>(s.Budgetkonti))
                        {
                            regnskab.TilføjKonto(budgetkonto);
                        }
                        BuildMany <BogføringslinjeView, Bogføringslinje>(s.Konti.SelectMany(m => m.Bogføringslinjer));
                    }
                    return(regnskab);
                });

                config.CreateMap <KontoListeView, Konto>()
                .ConvertUsing(s => { throw new NotSupportedException(); });

                config.CreateMap <KontoView, Konto>()
                .ConvertUsing(s =>
                {
                    Regnskab regnskab;
                    lock (SyncRoot)
                    {
                        if (GetRegnskabCallback == null)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetRegnskabCallback"));
                        }
                        try
                        {
                            regnskab = GetRegnskabCallback(s.Regnskab.Nummer);
                        }
                        catch (IntranetRepositoryException)
                        {
                            throw;
                        }
                        catch (Exception ex)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Regnskab).Name, s.Regnskab.Nummer), ex);
                        }
                    }
                    Kontogruppe kontogruppe;
                    lock (SyncRoot)
                    {
                        if (GetKontogruppeCallback == null)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetKontogruppeCallback"));
                        }
                        try
                        {
                            kontogruppe = GetKontogruppeCallback(s.Kontogruppe.Nummer);
                        }
                        catch (IntranetRepositoryException)
                        {
                            throw;
                        }
                        catch (Exception ex)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Kontogruppe).Name, s.Kontogruppe.Nummer), ex);
                        }
                    }
                    var konto = new Konto(regnskab, s.Kontonummer, s.Kontonavn, kontogruppe);
                    konto.SætBeskrivelse(s.Beskrivelse);
                    konto.SætNote(s.Note);
                    foreach (var kreditoplysninger in BuildMany <KreditoplysningerView, Kreditoplysninger>(s.Kreditoplysninger))
                    {
                        konto.TilføjKreditoplysninger(kreditoplysninger);
                    }
                    return(konto);
                });

                config.CreateMap <KreditoplysningerView, Kreditoplysninger>()
                .ConvertUsing(s => new Kreditoplysninger(s.År, s.Måned, s.Kredit));

                config.CreateMap <BudgetkontoListeView, Budgetkonto>()
                .ConvertUsing(s => { throw new NotSupportedException(); });

                config.CreateMap <BudgetkontoView, Budgetkonto>()
                .ConvertUsing(s =>
                {
                    Regnskab regnskab;
                    lock (SyncRoot)
                    {
                        if (GetRegnskabCallback == null)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetRegnskabCallback"));
                        }
                        try
                        {
                            regnskab = GetRegnskabCallback(s.Regnskab.Nummer);
                        }
                        catch (IntranetRepositoryException)
                        {
                            throw;
                        }
                        catch (Exception ex)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Regnskab).Name, s.Regnskab.Nummer), ex);
                        }
                    }
                    Budgetkontogruppe budgetkontogruppe;
                    lock (SyncRoot)
                    {
                        if (GetBudgetkontogruppeCallback == null)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetBudgetkontogruppeCallback"));
                        }
                        try
                        {
                            budgetkontogruppe = GetBudgetkontogruppeCallback(s.Budgetkontogruppe.Nummer);
                        }
                        catch (IntranetRepositoryException)
                        {
                            throw;
                        }
                        catch (Exception ex)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Budgetkontogruppe).Name, s.Budgetkontogruppe.Nummer), ex);
                        }
                    }
                    var budgetkonto = new Budgetkonto(regnskab, s.Kontonummer, s.Kontonavn, budgetkontogruppe);
                    budgetkonto.SætBeskrivelse(s.Beskrivelse);
                    budgetkonto.SætNote(s.Note);
                    foreach (var budgetoplysninger in BuildMany <BudgetoplysningerView, Budgetoplysninger>(s.Budgetoplysninger))
                    {
                        budgetkonto.TilføjBudgetoplysninger(budgetoplysninger);
                    }
                    return(budgetkonto);
                });

                config.CreateMap <BudgetoplysningerView, Budgetoplysninger>()
                .ConvertUsing(s => new Budgetoplysninger(s.År, s.Måned, s.Indtægter, s.Udgifter));

                config.CreateMap <BogføringslinjeView, Bogføringslinje>()
                .ConvertUsing(s =>
                {
                    Regnskab regnskab;
                    lock (SyncRoot)
                    {
                        if (GetRegnskabCallback == null)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetRegnskabCallback"));
                        }
                        try
                        {
                            regnskab = GetRegnskabCallback(s.Konto.Regnskab.Nummer);
                        }
                        catch (IntranetRepositoryException)
                        {
                            throw;
                        }
                        catch (Exception ex)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Regnskab).Name, s.Konto.Regnskab.Nummer), ex);
                        }
                    }
                    Konto konto;
                    try
                    {
                        konto = regnskab.Konti
                                .OfType <Konto>()
                                .Single(m => String.Compare(m.Kontonummer, s.Konto.Kontonummer, StringComparison.Ordinal) == 0);
                    }
                    catch (InvalidOperationException ex)
                    {
                        throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Konto).Name, s.Konto.Kontonummer), ex);
                    }
                    Budgetkonto budgetkonto = null;
                    if (s.Budgetkonto != null && string.IsNullOrEmpty(s.Budgetkonto.Kontonummer) == false)
                    {
                        try
                        {
                            budgetkonto = regnskab.Konti
                                          .OfType <Budgetkonto>()
                                          .Single(m => String.Compare(m.Kontonummer, s.Budgetkonto.Kontonummer, StringComparison.Ordinal) == 0);
                        }
                        catch (InvalidOperationException ex)
                        {
                            throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(Budgetkonto).Name, s.Budgetkonto.Kontonummer), ex);
                        }
                    }
                    AdresseBase adresse = null;
                    if (s.Adresse != null && s.Adresse.Nummer != 0)
                    {
                        lock (SyncRoot)
                        {
                            if (GetAdresseBaseCallback == null)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.NoRegistrationForDelegate, "GetAdresseBaseCallback"));
                            }
                            try
                            {
                                adresse = GetAdresseBaseCallback(s.Adresse.Nummer);
                            }
                            catch (IntranetRepositoryException)
                            {
                                throw;
                            }
                            catch (Exception ex)
                            {
                                throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.CantFindObjectById, typeof(AdresseBase).Name, s.Adresse.Nummer), ex);
                            }
                        }
                    }
                    var bogføringslinje = new Bogføringslinje(s.Løbenummer, s.Dato, s.Bilag, s.Tekst, s.Debit, s.Kredit);
                    konto.TilføjBogføringslinje(bogføringslinje);
                    if (budgetkonto != null)
                    {
                        budgetkonto.TilføjBogføringslinje(bogføringslinje);
                    }
                    if (adresse != null)
                    {
                        adresse.TilføjBogføringslinje(bogføringslinje);
                    }
                    return(bogføringslinje);
                });

                config.CreateMap <KontogruppeView, Kontogruppe>()
                .ConvertUsing(s =>
                {
                    var kontogruppe = new Kontogruppe(s.Nummer, s.Navn, KontogruppeType.Aktiver);
                    switch (s.KontogruppeType)
                    {
                    case DataAccess.Contracts.Enums.KontogruppeType.Aktiver:
                        kontogruppe.SætKontogruppeType(KontogruppeType.Aktiver);
                        break;

                    case DataAccess.Contracts.Enums.KontogruppeType.Passiver:
                        kontogruppe.SætKontogruppeType(KontogruppeType.Passiver);
                        break;

                    default:
                        throw new IntranetRepositoryException(Resource.GetExceptionMessage(ExceptionMessage.UnhandledSwitchValue, s.KontogruppeType, "KontogruppeType", MethodBase.GetCurrentMethod().Name));
                    }
                    return(kontogruppe);
                });

                config.CreateMap <BudgetkontogruppeView, Budgetkontogruppe>()
                .ConvertUsing(s => new Budgetkontogruppe(s.Nummer, s.Navn));

                config.CreateMap <BrevhovedView, Brevhoved>()
                .ConvertUsing(s =>
                {
                    var brevhoved = new Brevhoved(s.Nummer, s.Navn);
                    brevhoved.SætLinje1(s.Linje1);
                    brevhoved.SætLinje2(s.Linje2);
                    brevhoved.SætLinje3(s.Linje3);
                    brevhoved.SætLinje4(s.Linje4);
                    brevhoved.SætLinje5(s.Linje5);
                    brevhoved.SætLinje6(s.Linje6);
                    brevhoved.SætLinje7(s.Linje7);
                    brevhoved.SætCvrNr(s.CvrNr);
                    return(brevhoved);
                });

                config.CreateMap <BrevhovedreferenceView, Brevhoved>()
                .ConvertUsing(s => new Brevhoved(s.Nummer, s.Navn));
            });

            mapperConfiguration.AssertConfigurationIsValid();

            _mapper = mapperConfiguration.CreateMapper();
        }
Exemplo n.º 6
0
        /// <summary>
        /// Udførelse af kommandoen.
        /// </summary>
        /// <param name="command">Kommand til oprettelse af en bogføringslinje.</param>
        /// <returns>Oprettet bogføringslinje.</returns>
        public BogføringslinjeView Execute(BogføringslinjeAddCommand command)
        {
            if (command == null)
            {
                throw new ArgumentNullException("command");
            }

            Regnskab regnskab;

            try
            {
                var getBrevhoved = new Func <int, Brevhoved>(nummer => _fællesRepository.BrevhovedGetByNummer(nummer));
                regnskab = _finansstyringRepository.RegnskabGetAll(getBrevhoved)
                           .Single(m => m.Nummer == command.Regnskabsnummer);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Regnskab),
                                                       command.Regnskabsnummer), ex);
            }
            Konto konto;

            try
            {
                konto = regnskab.Konti
                        .OfType <Konto>()
                        .Single(m => m.Kontonummer.CompareTo(command.Kontonummer) == 0);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Konto),
                                                       command.Kontonummer), ex);
            }
            Budgetkonto budgetkonto = null;

            if (!string.IsNullOrEmpty(command.Budgetkontonummer))
            {
                try
                {
                    budgetkonto = regnskab.Konti
                                  .OfType <Budgetkonto>()
                                  .Single(m => m.Kontonummer.CompareTo(command.Budgetkontonummer) == 0);
                }
                catch (InvalidOperationException ex)
                {
                    throw new DataAccessSystemException(
                              Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Budgetkonto),
                                                           command.Budgetkontonummer), ex);
                }
            }
            AdresseBase adresse = null;

            if (command.AdresseId != 0)
            {
                try
                {
                    adresse = _adresseRepository.AdresseGetAll()
                              .Single(m => m.Nummer == command.AdresseId);
                }
                catch (InvalidOperationException ex)
                {
                    throw new DataAccessSystemException(
                              Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(AdresseBase),
                                                           command.AdresseId), ex);
                }
            }

            var bogføringslinje = _finansstyringRepository.BogføringslinjeAdd(command.Bogføringsdato, command.Bilag,
                                                                              konto, command.Tekst, budgetkonto,
                                                                              command.Debit, command.Kredit, adresse);

            var oldValue = Bogføringslinje.AutoCalculate;

            try
            {
                Bogføringslinje.SætAutoCalculate(true);
                return(_objectMapper.Map <Bogføringslinje, BogføringslinjeView>(bogføringslinje));
            }
            finally
            {
                Bogføringslinje.SætAutoCalculate(oldValue);
            }
        }
Exemplo n.º 7
0
        /// <summary>
        /// Alle mapninger sættes op i den statiske
        /// constructor af objektet.
        /// </summary>
        static ObjectMapper()
        {
            Mapper.CreateMap <AdresseBase, PersonView>()
            .ConvertUsing(s =>
            {
                if (s == null)
                {
                    return(null);
                }
                var mapper = new ObjectMapper();
                if (s is Adressereference)
                {
                    return(null);
                }
                if (s is Person)
                {
                    return(mapper.Map <Person, PersonView>(s as Person));
                }
                throw new DataAccessSystemException(
                    Resource.GetExceptionMessage(ExceptionMessage.CantAutoMapType, s.GetType()));
            });

            Mapper.CreateMap <AdresseBase, FirmaView>()
            .ConvertUsing(s =>
            {
                if (s == null)
                {
                    return(null);
                }
                var mapper = new ObjectMapper();
                if (s is Adressereference)
                {
                    return(null);
                }
                if (s is Firma)
                {
                    return(mapper.Map <Firma, FirmaView>(s as Firma));
                }
                throw new DataAccessSystemException(
                    Resource.GetExceptionMessage(ExceptionMessage.CantAutoMapType, s.GetType()));
            });

            Mapper.CreateMap <AdresseBase, AdresselisteView>()
            .ConvertUsing(s =>
            {
                if (s == null)
                {
                    return(null);
                }
                var mapper = new ObjectMapper();
                if (s is Adressereference)
                {
                    return(null);
                }
                if (s is Person)
                {
                    return(mapper.Map <Person, AdresselisteView>(s as Person));
                }
                if (s is Firma)
                {
                    return(mapper.Map <Firma, AdresselisteView>(s as Firma));
                }
                throw new DataAccessSystemException(
                    Resource.GetExceptionMessage(ExceptionMessage.CantAutoMapType, s.GetType()));
            });

            Mapper.CreateMap <AdresseBase, AdressereferenceView>()
            .ConvertUsing(s =>
            {
                if (s == null)
                {
                    return(null);
                }
                var mapper = new ObjectMapper();
                if (s is Adressereference)
                {
                    return(null);
                }
                if (s is Person)
                {
                    return(mapper.Map <Person, AdressereferenceView>(s as Person));
                }
                if (s is Firma)
                {
                    return(mapper.Map <Firma, AdressereferenceView>(s as Firma));
                }
                throw new DataAccessSystemException(
                    Resource.GetExceptionMessage(ExceptionMessage.CantAutoMapType, s.GetType()));
            });

            Mapper.CreateMap <Person, PersonView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn))
            .ForMember(x => x.Adresse1, opt => opt.MapFrom(s => s.Adresse1))
            .ForMember(x => x.Adresse2, opt => opt.MapFrom(s => s.Adresse2))
            .ForMember(x => x.PostnummerBy, opt => opt.MapFrom(s => s.PostnrBy))
            .ForMember(x => x.Telefon, opt => opt.MapFrom(s => s.Telefon))
            .ForMember(x => x.Mobil, opt => opt.MapFrom(s => s.Mobil))
            .ForMember(x => x.Fødselsdato, opt => opt.MapFrom(s => s.Fødselsdato))
            .ForMember(x => x.Adressegruppe, opt => opt.MapFrom(s => s.Adressegruppe))
            .ForMember(x => x.Bekendtskab, opt => opt.MapFrom(s => s.Bekendtskab))
            .ForMember(x => x.Mailadresse, opt => opt.MapFrom(s => s.Mailadresse))
            .ForMember(x => x.Webadresse, opt => opt.MapFrom(s => s.Webadresse))
            .ForMember(x => x.Betalingsbetingelse, opt => opt.MapFrom(s => s.Betalingsbetingelse))
            .ForMember(x => x.Udlånsfrist, opt => opt.MapFrom(s => s.Udlånsfrist))
            .ForMember(x => x.FilofaxAdresselabel, opt => opt.MapFrom(s => s.FilofaxAdresselabel))
            .ForMember(x => x.Firma, opt => opt.MapFrom(s => s.Firma))
            .ForMember(x => x.Bogføringslinjer, opt => opt.MapFrom(s => s.Bogføringslinjer));

            Mapper.CreateMap <Person, AdresselisteView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn))
            .ForMember(x => x.Adressegruppe, opt => opt.MapFrom(s => s.Adressegruppe))
            .ForMember(x => x.Adresse1, opt => opt.MapFrom(s => s.Adresse1))
            .ForMember(x => x.Adresse2, opt => opt.MapFrom(s => s.Adresse2))
            .ForMember(x => x.PostnummerBy, opt => opt.MapFrom(s => s.PostnrBy))
            .ForMember(x => x.Telefon, opt => opt.MapFrom(s => s.Telefon))
            .ForMember(x => x.Mobil, opt => opt.MapFrom(s => s.Mobil))
            .ForMember(x => x.Mailadresse, opt => opt.MapFrom(s => s.Mailadresse));

            Mapper.CreateMap <Person, AdressereferenceView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn));

            Mapper.CreateMap <Firma, FirmaView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn))
            .ForMember(x => x.Adresse1, opt => opt.MapFrom(s => s.Adresse1))
            .ForMember(x => x.Adresse2, opt => opt.MapFrom(s => s.Adresse2))
            .ForMember(x => x.PostnummerBy, opt => opt.MapFrom(s => s.PostnrBy))
            .ForMember(x => x.Telefon1, opt => opt.MapFrom(s => s.Telefon1))
            .ForMember(x => x.Telefon2, opt => opt.MapFrom(s => s.Telefon2))
            .ForMember(x => x.Telefax, opt => opt.MapFrom(s => s.Telefax))
            .ForMember(x => x.Adressegruppe, opt => opt.MapFrom(s => s.Adressegruppe))
            .ForMember(x => x.Bekendtskab, opt => opt.MapFrom(s => s.Bekendtskab))
            .ForMember(x => x.Mailadresse, opt => opt.MapFrom(s => s.Mailadresse))
            .ForMember(x => x.Webadresse, opt => opt.MapFrom(s => s.Webadresse))
            .ForMember(x => x.Betalingsbetingelse, opt => opt.MapFrom(s => s.Betalingsbetingelse))
            .ForMember(x => x.Udlånsfrist, opt => opt.MapFrom(s => s.Udlånsfrist))
            .ForMember(x => x.FilofaxAdresselabel, opt => opt.MapFrom(s => s.FilofaxAdresselabel))
            .ForMember(x => x.Personer, opt => opt.MapFrom(s => s.Personer))
            .ForMember(x => x.Bogføringslinjer, opt => opt.MapFrom(s => s.Bogføringslinjer));

            Mapper.CreateMap <Firma, AdresselisteView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn))
            .ForMember(x => x.Adressegruppe, opt => opt.MapFrom(s => s.Adressegruppe))
            .ForMember(x => x.Adresse1, opt => opt.MapFrom(s => s.Adresse1))
            .ForMember(x => x.Adresse2, opt => opt.MapFrom(s => s.Adresse2))
            .ForMember(x => x.PostnummerBy, opt => opt.MapFrom(s => s.PostnrBy))
            .ForMember(x => x.Telefon, opt => opt.MapFrom(s => s.Telefon1))
            .ForMember(x => x.Mobil, opt => opt.Ignore())
            .ForMember(x => x.Mailadresse, opt => opt.MapFrom(s => s.Mailadresse));

            Mapper.CreateMap <Firma, AdressereferenceView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn));

            Mapper.CreateMap <Postnummer, PostnummerView>()
            .ForMember(x => x.Landekode, opt => opt.MapFrom(s => s.Landekode))
            .ForMember(x => x.Postnummer, opt => opt.MapFrom(s => s.Postnr))
            .ForMember(x => x.Bynavn, opt => opt.MapFrom(s => s.By));

            Mapper.CreateMap <Adressegruppe, AdressegruppeView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn))
            .ForMember(x => x.AdressegruppeOswebdb, opt => opt.MapFrom(s => s.AdressegruppeOswebdb));

            Mapper.CreateMap <Betalingsbetingelse, BetalingsbetingelseView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn));

            Mapper.CreateMap <Regnskab, RegnskabView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn))
            .ForMember(x => x.Brevhoved, opt => opt.MapFrom(s => s.Brevhoved))
            .ForMember(x => x.Konti, opt => opt.MapFrom(s => s.Konti.OfType <Konto>().ToArray()))
            .ForMember(x => x.Budgetkonti, opt => opt.MapFrom(s => s.Konti.OfType <Budgetkonto>().ToArray()));

            Mapper.CreateMap <Regnskab, RegnskabListeView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn))
            .ForMember(x => x.Brevhoved, opt => opt.MapFrom(s => s.Brevhoved));

            Mapper.CreateMap <Konto, KontoView>()
            .ForMember(x => x.Regnskab, opt => opt.MapFrom(s => s.Regnskab))
            .ForMember(x => x.Kontonummer, opt => opt.MapFrom(s => s.Kontonummer))
            .ForMember(x => x.Kontonavn, opt => opt.MapFrom(s => s.Kontonavn))
            .ForMember(x => x.Beskrivelse, opt => opt.MapFrom(s => s.Beskrivelse))
            .ForMember(x => x.Note, opt => opt.MapFrom(s => s.Note))
            .ForMember(x => x.Kontogruppe, opt => opt.MapFrom(s => s.Kontogruppe))
            .ForMember(x => x.Kreditoplysninger, opt => opt.MapFrom(s => s.Kreditoplysninger))
            .ForMember(x => x.Bogføringslinjer, opt => opt.MapFrom(s => s.Bogføringslinjer));

            Mapper.CreateMap <Konto, KontoListeView>()
            .ForMember(x => x.Regnskab, opt => opt.MapFrom(s => s.Regnskab))
            .ForMember(x => x.Kontonummer, opt => opt.MapFrom(s => s.Kontonummer))
            .ForMember(x => x.Kontonavn, opt => opt.MapFrom(s => s.Kontonavn))
            .ForMember(x => x.Beskrivelse, opt => opt.MapFrom(s => s.Beskrivelse))
            .ForMember(x => x.Note, opt => opt.MapFrom(s => s.Note))
            .ForMember(x => x.Kontogruppe, opt => opt.MapFrom(s => s.Kontogruppe));

            Mapper.CreateMap <Budgetkonto, BudgetkontoView>()
            .ForMember(x => x.Regnskab, opt => opt.MapFrom(s => s.Regnskab))
            .ForMember(x => x.Kontonummer, opt => opt.MapFrom(s => s.Kontonummer))
            .ForMember(x => x.Kontonavn, opt => opt.MapFrom(s => s.Kontonavn))
            .ForMember(x => x.Beskrivelse, opt => opt.MapFrom(s => s.Beskrivelse))
            .ForMember(x => x.Note, opt => opt.MapFrom(s => s.Note))
            .ForMember(x => x.Budgetkontogruppe, opt => opt.MapFrom(s => s.Budgetkontogruppe))
            .ForMember(x => x.Budgetoplysninger, opt => opt.MapFrom(s => s.Budgetoplysninger))
            .ForMember(x => x.Bogføringslinjer, opt => opt.MapFrom(s => s.Bogføringslinjer));

            Mapper.CreateMap <Budgetkonto, BudgetkontoListeView>()
            .ForMember(x => x.Regnskab, opt => opt.MapFrom(s => s.Regnskab))
            .ForMember(x => x.Kontonummer, opt => opt.MapFrom(s => s.Kontonummer))
            .ForMember(x => x.Kontonavn, opt => opt.MapFrom(s => s.Kontonavn))
            .ForMember(x => x.Beskrivelse, opt => opt.MapFrom(s => s.Beskrivelse))
            .ForMember(x => x.Note, opt => opt.MapFrom(s => s.Note))
            .ForMember(x => x.Budgetkontogruppe, opt => opt.MapFrom(s => s.Budgetkontogruppe));

            Mapper.CreateMap <Kreditoplysninger, KreditoplysningerView>()
            .ForMember(x => x.År, opt => opt.MapFrom(s => s.År))
            .ForMember(x => x.Måned, opt => opt.MapFrom(s => s.Måned))
            .ForMember(x => x.Kredit, opt => opt.MapFrom(s => s.Kredit));

            Mapper.CreateMap <Budgetoplysninger, BudgetoplysningerView>()
            .ForMember(x => x.År, opt => opt.MapFrom(s => s.År))
            .ForMember(x => x.Måned, opt => opt.MapFrom(s => s.Måned))
            .ForMember(x => x.Indtægter, opt => opt.MapFrom(s => s.Indtægter))
            .ForMember(x => x.Udgifter, opt => opt.MapFrom(s => s.Udgifter));

            Bogføringslinje.SætAutoCalculate(false);
            Mapper.CreateMap <Bogføringslinje, BogføringslinjeView>()
            .ForMember(x => x.Løbenummer, opt => opt.MapFrom(s => s.Løbenummer))
            .ForMember(x => x.Dato, opt => opt.MapFrom(s => s.Dato))
            .ForMember(x => x.Bilag, opt => opt.MapFrom(s => s.Bilag))
            .ForMember(x => x.Konto, opt => opt.MapFrom(s => s.Konto))
            .ForMember(x => x.Tekst, opt => opt.MapFrom(s => s.Tekst))
            .ForMember(x => x.Budgetkonto, opt => opt.MapFrom(s => s.Budgetkonto))
            .ForMember(x => x.Debit, opt => opt.MapFrom(s => s.Debit))
            .ForMember(x => x.Kredit, opt => opt.MapFrom(s => s.Kredit))
            .ForMember(x => x.Adresse, opt => opt.MapFrom(s => s.Adresse));

            Mapper.CreateMap <Kontogruppe, KontogruppeView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn))
            .ForMember(x => x.KontogruppeType, opt => opt.MapFrom(s => s.KontogruppeType));

            Mapper.CreateMap <Budgetkontogruppe, BudgetkontogruppeView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn));

            Mapper.CreateMap <Brevhoved, BrevhovedreferenceView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn));

            Mapper.CreateMap <Brevhoved, BrevhovedView>()
            .ForMember(x => x.Nummer, opt => opt.MapFrom(s => s.Nummer))
            .ForMember(x => x.Navn, opt => opt.MapFrom(s => s.Navn))
            .ForMember(x => x.Linje1, opt => opt.MapFrom(s => s.Linje1))
            .ForMember(x => x.Linje2, opt => opt.MapFrom(s => s.Linje2))
            .ForMember(x => x.Linje3, opt => opt.MapFrom(s => s.Linje3))
            .ForMember(x => x.Linje4, opt => opt.MapFrom(s => s.Linje4))
            .ForMember(x => x.Linje5, opt => opt.MapFrom(s => s.Linje5))
            .ForMember(x => x.Linje6, opt => opt.MapFrom(s => s.Linje6))
            .ForMember(x => x.Linje7, opt => opt.MapFrom(s => s.Linje7))
            .ForMember(x => x.CvrNr, opt => opt.MapFrom(s => s.CvrNr));

            Mapper.AssertConfigurationIsValid();
        }
        /// <summary>
        /// Tilføjer en bogføringslinje.
        /// </summary>
        /// <param name="bogføringstidspunkt">Bogføringstidspunkt.</param>
        /// <param name="bilag">Bilag.</param>
        /// <param name="konto">Konto.</param>
        /// <param name="tekst">Tekst.</param>
        /// <param name="budgetkonto">Budgetkonto.</param>
        /// <param name="debit">Debitbeløb.</param>
        /// <param name="kredit">Kreditbeløb.</param>
        /// <param name="adressekonto">Adressekonto.</param>
        /// <returns>Oprettet bogføringslinje.</returns>
        public Bogføringslinje BogføringslinjeAdd(DateTime bogføringstidspunkt, string bilag, Konto konto, string tekst, Budgetkonto budgetkonto, decimal debit, decimal kredit, AdresseBase adressekonto)
        {
            if (konto == null)
            {
                throw new ArgumentNullException("konto");
            }
            if (string.IsNullOrEmpty(tekst))
            {
                throw new ArgumentNullException("tekst");
            }
            var channel = _channelFactory.CreateChannel <IFinansstyringRepositoryService>(EndpointConfigurationName);

            try
            {
                // Udførelse af kommando.
                var command = new BogføringslinjeAddCommand
                {
                    Regnskabsnummer   = konto.Regnskab.Nummer,
                    Bogføringsdato    = bogføringstidspunkt,
                    Bilag             = bilag,
                    Kontonummer       = konto.Kontonummer,
                    Tekst             = tekst,
                    Budgetkontonummer = budgetkonto == null ? null : budgetkonto.Kontonummer,
                    Debit             = debit,
                    Kredit            = kredit,
                    AdresseId         = adressekonto == null ? 0 : adressekonto.Nummer
                };
                var result = channel.BogføringslinjeAdd(command);
                // Behandling af resultat.
                var bogføringslinje = new Bogføringslinje(result.Løbenummer, result.Dato, result.Bilag, result.Tekst,
                                                          result.Debit, result.Kredit);
                konto.TilføjBogføringslinje(bogføringslinje);
                if (budgetkonto != null)
                {
                    budgetkonto.TilføjBogføringslinje(bogføringslinje);
                }
                if (adressekonto != null)
                {
                    adressekonto.TilføjBogføringslinje(bogføringslinje);
                }
                return(bogføringslinje);
            }
            catch (IntranetRepositoryException)
            {
                throw;
            }
            catch (FaultException ex)
            {
                throw new IntranetRepositoryException(ex.Message);
            }
            catch (Exception ex)
            {
                throw new IntranetRepositoryException(
                          Resource.GetExceptionMessage(ExceptionMessage.RepositoryError, MethodBase.GetCurrentMethod().Name,
                                                       ex.Message), ex);
            }
            finally
            {
                ChannelTools.CloseChannel(channel);
            }
        }