Esempio n. 1
0
        /// <summary>
        /// Initializes a new instance of the <see cref="EnterpriseAccounting"/> class.
        /// </summary>
        /// <param name="repository">The repository of data structures.</param>
        /// <param name="enterpriseId">The enterprise identifier.</param>
        public EnterpriseAccounting(IDataStructureRepository repository, string enterpriseId)
        {
            Requires(repository != null, "Repositorio de estructuras de datos invalido");
            Requires(!string.IsNullOrWhiteSpace(enterpriseId), "Identificador de empresa invalido");

            repository.Get(enterpriseId + "_AccountDataByCode", out _accountDataByCode);
            repository.Get(enterpriseId + "_AccountBalanceByCode", out _accountBalanceByCode);
            repository.Get(enterpriseId + "_Balances", out _balancesById);
            repository.Get(enterpriseId + "_TransactionsById", out _transactionsById);
            _repository   = repository;
            _enterpriseId = enterpriseId;
        }
Esempio n. 2
0
        /// <summary>
        /// Adds a new accounting transaction.
        /// </summary>
        /// <param name="transaction">The accounting transaction.</param>
        /// <returns>Identificador de transaccion</returns>
        public Guid AddTransaction(NewTransaction transaction)
        {
            Requires(transaction != null, "Nueva transaccion invalida");
            Requires(transaction.Entries != null, "Asientos contables en la transaccion invalidos");
            Requires(transaction.Entries.Count > 0, "Nueva transaccion sin asientos contables");
            Requires(transaction.Entries.Sum(x => x.Value) == 0, "Nueva transaccion cuyas sumas no son iguales");
            Requires(transaction.Entries.All(x => _accountDataByCode.ContainsKey(x.AccountCode)), "Codigo de cuenta no existe");

            var now           = DateTimeOffset.Now;
            var transactionId = Guid.NewGuid();

            var transactionData = new TransactionData();

            transactionData.Holder  = transaction.Holder;
            transactionData.Entries = new List <TransactionEntryData>();
            transactionData.Time    = now;

            var balanceIncrements = new Dictionary <string, decimal>();

            foreach (var item in transaction.Entries)
            {
                var entryId = Guid.NewGuid();

                var transactionEntryData = new TransactionEntryData();
                transactionEntryData.AccountCode = item.AccountCode;
                transactionEntryData.Value       = item.Value;
                transactionEntryData.EntryId     = entryId;
                if (transactionEntryData.Value > 0)
                {
                    transactionData.Total += transactionEntryData.Value;
                }
                transactionData.Entries.Add(transactionEntryData);

                ISortedDictionary <Guid, AccountingEntryData> recordDictionary;
                _repository.Get(GetAccountRecordsLookupTableName(item.AccountCode), out recordDictionary);

                var accountingEntryData = new AccountingEntryData();
                accountingEntryData.Time          = now;
                accountingEntryData.AccountCode   = item.AccountCode;
                accountingEntryData.Value         = item.Value;
                accountingEntryData.TransactionId = transactionId;
                recordDictionary.Add(entryId, accountingEntryData);

                decimal increment;
                if (balanceIncrements.TryGetValue(item.AccountCode, out increment))
                {
                    balanceIncrements[item.AccountCode] = increment + transactionEntryData.Value;
                }
                else
                {
                    balanceIncrements.Add(item.AccountCode, transactionEntryData.Value);
                }
            }

            _accountBalanceByCode.Increment(balanceIncrements);
            _transactionsById.Add(transactionId, transactionData);

            return(transactionId);
        }