/// <summary>
        /// Udførelse af kommandoen.
        /// </summary>
        /// <param name="command">Command til oprettelse af et brevhoved.</param>
        /// <returns>Oprettet brevhoved.</returns>
        public BrevhovedView Execute(BrevhovedAddCommand command)
        {
            if (command == null)
            {
                throw new ArgumentNullException("command");
            }

            var brevhoved = new Brevhoved(command.Nummer, command.Navn);

            brevhoved.SætLinje1(command.Linje1);
            brevhoved.SætLinje2(command.Linje2);
            brevhoved.SætLinje3(command.Linje3);
            brevhoved.SætLinje4(command.Linje4);
            brevhoved.SætLinje5(command.Linje5);
            brevhoved.SætLinje6(command.Linje6);
            brevhoved.SætLinje7(command.Linje7);
            brevhoved.SætCvrNr(command.CvrNr);

            var oprettetBrevhoved = _fællesRepository.BrevhovedAdd(brevhoved.Nummer, brevhoved.Navn, brevhoved.Linje1,
                                                                   brevhoved.Linje2, brevhoved.Linje3, brevhoved.Linje4,
                                                                   brevhoved.Linje5, brevhoved.Linje6, brevhoved.Linje7,
                                                                   brevhoved.CvrNr);

            return(_objectMapper.Map <Brevhoved, BrevhovedView>(oprettetBrevhoved));
        }
コード例 #2
0
        /// <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();
        }
コード例 #3
0
 /// <summary>
 /// Henter alle brevhoveder.
 /// </summary>
 /// <returns>Liste indeholdende alle brevhoveder.</returns>
 public IEnumerable <Brevhoved> BrevhovedGetAll()
 {
     lock (BrevhovedCache)
     {
         if (BrevhovedCache.Count > 0)
         {
             return(new List <Brevhoved>(BrevhovedCache));
         }
         var brevhoveder = GetTableContentFromTabel <Brevhoved>(2020, (dbHandle, searchHandle, list) =>
         {
             var nummer =
                 GetFieldValueAsInt(dbHandle,
                                    searchHandle,
                                    "Nummer");
             var navn =
                 GetFieldValueAsString(dbHandle,
                                       searchHandle,
                                       "Tekst");
             var brevhoved = new Brevhoved(
                 nummer, navn);
             brevhoved.SætLinje1(
                 GetFieldValueAsString(dbHandle,
                                       searchHandle,
                                       "BrevhovedLinie1"));
             brevhoved.SætLinje2(
                 GetFieldValueAsString(dbHandle,
                                       searchHandle,
                                       "BrevhovedLinie2"));
             brevhoved.SætLinje3(
                 GetFieldValueAsString(dbHandle,
                                       searchHandle,
                                       "BrevhovedLinie3"));
             brevhoved.SætLinje4(
                 GetFieldValueAsString(dbHandle,
                                       searchHandle,
                                       "BrevhovedLinie4"));
             brevhoved.SætLinje5(
                 GetFieldValueAsString(dbHandle,
                                       searchHandle,
                                       "BrevhovedLinie5"));
             brevhoved.SætLinje6(
                 GetFieldValueAsString(dbHandle,
                                       searchHandle,
                                       "BrevhovedLinie6"));
             brevhoved.SætLinje7(
                 GetFieldValueAsString(dbHandle,
                                       searchHandle,
                                       "BrevhovedLinie7"));
             brevhoved.SætCvrNr(
                 GetFieldValueAsString(dbHandle,
                                       searchHandle,
                                       "BrevhovedCVR"));
             list.Add(brevhoved);
         });
         BrevhovedCache.Clear();
         foreach (var brevhoved in brevhoveder)
         {
             BrevhovedCache.Add(brevhoved);
         }
         return(new List <Brevhoved>(BrevhovedCache));
     }
 }