Example #1
0
        public void TestAtRegnskabGetHenterRegnskab()
        {
            var adresselisteHelper   = new AdresselisteHelper(_adresseRepository.AdresseGetAll());
            var brevhovedlisteHelper = new BrevhovedlisteHelper(_fællesRepository.BrevhovedGetAll());
            var regnskab             = _finansstyringRepository.RegnskabGet(1, brevhovedlisteHelper.GetById,
                                                                            adresselisteHelper.GetById);

            Assert.That(regnskab, Is.Not.Null);
            Assert.That(regnskab.Nummer, Is.EqualTo(1));
        }
Example #2
0
        /// <summary>
        /// Udfører forespørgelse.
        /// </summary>
        /// <param name="query">Forespørgelse efter alle bogføringslinjer i et givent regnskab.</param>
        /// <returns>Alle bogføringslinjer i et givent regnskab.</returns>
        public IEnumerable <BogføringslinjeView> Query(BogføringslinjeGetByRegnskabQuery query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }
            var      adresser     = _adresseRepository.AdresseGetAll();
            var      getBrevhoved = new Func <int, Brevhoved>(nummer => _fællesRepository.BrevhovedGetByNummer(nummer));
            var      regnskaber   = _finansstyringRepository.RegnskabGetAll(getBrevhoved, r => MergeInformations(r, adresser));
            Regnskab regnskab;

            try
            {
                regnskab = regnskaber.Single(m => m.Nummer == query.Regnskabsnummer);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Regnskab),
                                                       query.Regnskabsnummer), ex);
            }
            var comparer         = new BogføringslinjeComparer();
            var bogføringslinjer = regnskab.Konti
                                   .OfType <Konto>()
                                   .SelectMany(m => m.Bogføringslinjer)
                                   .OrderByDescending(n => n, comparer)
                                   .ToArray();

            return(_objectMapper.Map <IEnumerable <Bogføringslinje>, IEnumerable <BogføringslinjeView> >(bogføringslinjer));
        }
Example #3
0
        public void TestAtAdresseGetAllHenterAdresser()
        {
            var adresser = _adresseRepository.AdresseGetAll();

            Assert.That(adresser, Is.Not.Null);
            Assert.That(adresser.Count(), Is.GreaterThan(0));
        }
        /// <summary>
        /// Udfører forespørgelse.
        /// </summary>
        /// <param name="query">Forespørgelse efter et givent firma.</param>
        /// <returns>Firma.</returns>
        public FirmaView Query(FirmaGetByNummerQuery query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }
            var   getBrevhoved = new Func <int, Brevhoved>(nummer => _fællesRepository.BrevhovedGetByNummer(nummer));
            var   regnskaber   = _finansstyringRepository.RegnskabGetAll(getBrevhoved);
            Firma firma;

            try
            {
                firma = _adresseRepository.AdresseGetAll(adresse => MergeInformations(adresse, regnskaber))
                        .OfType <Firma>()
                        .ToArray()
                        .Single(m => m.Nummer == query.Nummer);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Firma), query.Nummer),
                          ex);
            }
            return(_objectMapper.Map <Firma, FirmaView>(firma));
        }
        /// <summary>
        /// Udfører forespørgelse.
        /// </summary>
        /// <param name="query">Forespørgelse efter alle adresser til en adresseliste.</param>
        /// <returns>Alle adresser til en adresseliste.</returns>
        public IEnumerable <AdresselisteView> Query(AdresselisteGetAllQuery query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }
            var getBrevhoved = new Func <int, Brevhoved>(nummer => _fællesRepository.BrevhovedGetByNummer(nummer));
            var regnskaber   = _finansstyringRepository.RegnskabGetAll(getBrevhoved);
            var adresser     = _adresseRepository.AdresseGetAll(adresse => MergeInformations(adresse, regnskaber));

            return(_objectMapper.Map <IEnumerable <AdresseBase>, IEnumerable <AdresselisteView> >(adresser));
        }
        /// <summary>
        /// Udfører forespørgelse.
        /// </summary>
        /// <param name="query">Forespørgelse efter et givent regnskab.</param>
        /// <returns>Regnskab.</returns>
        public RegnskabView Query(RegnskabGetByNummerQuery query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }
            var      adresser     = _adresseRepository.AdresseGetAll();
            var      getBrevhoved = new Func <int, Brevhoved>(nummer => _fællesRepository.BrevhovedGetByNummer(nummer));
            var      regnskaber   = _finansstyringRepository.RegnskabGetAll(getBrevhoved, r => MergeInformations(r, adresser));
            Regnskab regnskab;

            try
            {
                regnskab = regnskaber.Single(m => m.Nummer == query.Regnskabsnummer);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Regnskab),
                                                       query.Regnskabsnummer), ex);
            }
            return(_objectMapper.Map <Regnskab, RegnskabView>(regnskab));
        }
        /// <summary>
        /// Udfører forespørgelse.
        /// </summary>
        /// <param name="query">Forespørgelse efter en given budgetkonto i et givent regnskab.</param>
        /// <returns>Budgetkonto.</returns>
        public BudgetkontoView Query(BudgetkontoGetByRegnskabAndKontonummerQuery query)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }
            var      adresser     = _adresseRepository.AdresseGetAll();
            var      getBrevhoved = new Func <int, Brevhoved>(nummer => _fællesRepository.BrevhovedGetByNummer(nummer));
            var      regnskaber   = _finansstyringRepository.RegnskabGetAll(getBrevhoved, r => MergeInformations(r, adresser));
            Regnskab regnskab;

            try
            {
                regnskab = regnskaber.Single(m => m.Nummer == query.Regnskabsnummer);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Regnskab),
                                                       query.Regnskabsnummer), ex);
            }
            Budgetkonto budgetkonto;

            try
            {
                budgetkonto = regnskab.Konti
                              .OfType <Budgetkonto>()
                              .Single(m => m.Kontonummer.CompareTo(query.Kontonummer) == 0);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Budgetkonto),
                                                       query.Kontonummer), ex);
            }
            return(_objectMapper.Map <Budgetkonto, BudgetkontoView>(budgetkonto));
        }
Example #8
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);
            }
        }
        /// <summary>
        /// Udførelse af kommandoen.
        /// </summary>
        /// <param name="command">Command til tilføjelse af en person.</param>
        /// <returns>Oprettet person.</returns>
        public PersonView Execute(PersonAddCommand command)
        {
            if (command == null)
            {
                throw new ArgumentNullException("command");
            }

            Adressegruppe adressegruppe;

            try
            {
                adressegruppe = _adresseRepository.AdressegruppeGetAll().Single(m => m.Nummer == command.Adressegruppe);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Adressegruppe),
                                                       command.Adressegruppe), ex);
            }
            Betalingsbetingelse betalingsbetingelse = null;

            if (command.Betalingsbetingelse != 0)
            {
                try
                {
                    betalingsbetingelse = _adresseRepository.BetalingsbetingelserGetAll()
                                          .Single(m => m.Nummer == command.Betalingsbetingelse);
                }
                catch (InvalidOperationException ex)
                {
                    throw new DataAccessSystemException(
                              Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId,
                                                           typeof(Betalingsbetingelse), command.Betalingsbetingelse), ex);
                }
            }
            Firma firma = null;

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

            var person = new Person(0, command.Navn, adressegruppe);

            person.SætAdresseoplysninger(command.Adresse1, command.Adresse2, command.PostnummerBy);
            person.SætTelefon(command.Telefon, command.Mobil);
            person.SætFødselsdato(command.Fødselsdato);
            person.SætBekendtskab(command.Bekendtskab);
            person.SætMailadresse(command.Mailadresse);
            person.SætWebadresse(command.Webadresse);
            person.SætBetalingsbetingelse(betalingsbetingelse);
            person.SætUdlånsfrist(command.Udlånsfrist);
            person.SætFilofaxAdresselabel(command.FilofaxAdresselabel);

            var oprettetPerson = _adresseRepository.PersonAdd(person.Navn, person.Adresse1, person.Adresse2,
                                                              person.PostnrBy, person.Telefon, person.Mobil,
                                                              person.Fødselsdato, person.Adressegruppe,
                                                              person.Bekendtskab, person.Mailadresse, person.Webadresse,
                                                              person.Betalingsbetingelse, person.Udlånsfrist,
                                                              person.FilofaxAdresselabel, firma);

            return(_objectMapper.Map <Person, PersonView>(oprettetPerson));
        }
        /// <summary>
        /// Udførelse af kommandoen.
        /// </summary>
        /// <param name="command">Command til opdatering af et givent firma.</param>
        /// <returns>Opdateret firma.</returns>
        public FirmaView Execute(FirmaModifyCommand command)
        {
            if (command == null)
            {
                throw new ArgumentNullException("command");
            }

            Adressegruppe adressegruppe;

            try
            {
                adressegruppe = _adresseRepository.AdressegruppeGetAll().Single(m => m.Nummer == command.Adressegruppe);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Adressegruppe),
                                                       command.Adressegruppe), ex);
            }
            Betalingsbetingelse betalingsbetingelse = null;

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

            Firma firma;

            try
            {
                firma = _adresseRepository.AdresseGetAll()
                        .OfType <Firma>()
                        .Single(m => m.Nummer == command.Nummer);
            }
            catch (InvalidOperationException ex)
            {
                throw new DataAccessSystemException(
                          Resource.GetExceptionMessage(ExceptionMessage.CantFindUniqueRecordId, typeof(Firma), command.Nummer),
                          ex);
            }
            firma.SætNavn(command.Navn);
            firma.SætAdresseoplysninger(command.Adresse1, command.Adresse2, command.PostnummerBy);
            firma.SætTelefon(command.Telefon1, command.Telefon2, command.Telefax);
            firma.SætAdressegruppe(adressegruppe);
            firma.SætBekendtskab(command.Bekendtskab);
            firma.SætMailadresse(command.Mailadresse);
            firma.SætWebadresse(command.Webadresse);
            firma.SætBetalingsbetingelse(betalingsbetingelse);
            firma.SætUdlånsfrist(command.Udlånsfrist);
            firma.SætFilofaxAdresselabel(command.FilofaxAdresselabel);

            var opdateretFirma = _adresseRepository.FirmaModify(firma.Nummer, firma.Navn, firma.Adresse1, firma.Adresse2,
                                                                firma.PostnrBy, firma.Telefon1, firma.Telefon2,
                                                                firma.Telefax, firma.Adressegruppe, firma.Bekendtskab,
                                                                firma.Mailadresse, firma.Webadresse,
                                                                firma.Betalingsbetingelse, firma.Udlånsfrist,
                                                                firma.FilofaxAdresselabel);

            return(_objectMapper.Map <Firma, FirmaView>(opdateretFirma));
        }