public Task <IBudgetAccountGroup> DeleteBudgetAccountGroupAsync(int number)
{
return(ExecuteAsync(async() =>
{
using BudgetAccountGroupModelHandler budgetAccountGroupModelHandler = new BudgetAccountGroupModelHandler(DbContext, AccountingModelConverter.Create());
return await budgetAccountGroupModelHandler.DeleteAsync(number);
},
MethodBase.GetCurrentMethod()));
}
public Task <IEnumerable <IPaymentTerm> > GetPaymentTermsAsync()
{
return(ExecuteAsync(async() =>
{
using PaymentTermModelHandler paymentTermModelHandler = new PaymentTermModelHandler(DbContext, AccountingModelConverter.Create());
return await paymentTermModelHandler.ReadAsync();
},
MethodBase.GetCurrentMethod()));
}
public Task <IContactAccountCollection> GetContactAccountsAsync(int accountingNumber, DateTime statusDate)
{
return(ExecuteAsync(async() =>
{
using ContactAccountModelHandler contactAccountModelHandler = new ContactAccountModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, statusDate, true);
IContactAccountCollection contactAccountCollection = new ContactAccountCollection
{
await contactAccountModelHandler.ReadAsync(contactAccountModel => contactAccountModel.AccountingIdentifier == accountingNumber, prepareReadState: new AccountingIdentificationState(accountingNumber))
};
return contactAccountCollection;
},
MethodBase.GetCurrentMethod()));
}
public Task <IBudgetAccountGroup> UpdateBudgetAccountGroupAsync(IBudgetAccountGroup budgetAccountGroup)
{
NullGuard.NotNull(budgetAccountGroup, nameof(budgetAccountGroup));
return(ExecuteAsync(async() =>
{
using BudgetAccountGroupModelHandler budgetAccountGroupModelHandler = new BudgetAccountGroupModelHandler(DbContext, AccountingModelConverter.Create());
return await budgetAccountGroupModelHandler.UpdateAsync(budgetAccountGroup);
},
MethodBase.GetCurrentMethod()));
}
public Task <IAccounting> DeleteAccountingAsync(int number)
{
return(ExecuteAsync(async() =>
{
using AccountingModelHandler accountingModelHandler = new AccountingModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.Today, true, true);
return await accountingModelHandler.DeleteAsync(number, new AccountingIdentificationState(number));
},
MethodBase.GetCurrentMethod()));
}
public Task <IContact> CreateOrUpdateContactSupplementAsync(IContact contact, string existingExternalIdentifier = null)
{
NullGuard.NotNull(contact, nameof(contact));
return(ExecuteAsync(async() =>
{
using ContactSupplementModelHandler contactSupplementModelHandler = new ContactSupplementModelHandler(DbContext, ContactModelConverter.Create(), AccountingModelConverter.Create());
return await contactSupplementModelHandler.CreateOrUpdateContactSupplementAsync(contact, existingExternalIdentifier);
},
MethodBase.GetCurrentMethod()));
}
public Task <IPostingJournalResult> ApplyPostingJournalAsync(IPostingJournal postingJournal, IPostingWarningCalculator postingWarningCalculator)
{
NullGuard.NotNull(postingJournal, nameof(postingJournal))
.NotNull(postingWarningCalculator, nameof(postingWarningCalculator));
return(ExecuteAsync(async() =>
{
IPostingLineCollection postingLineCollection = new PostingLineCollection();
foreach (IGrouping <int, IPostingLine> group in postingJournal.PostingLineCollection.GroupBy(postingLine => postingLine.Accounting.Number))
{
using PostingLineModelHandler postingLineModelHandler = new PostingLineModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.MinValue, DateTime.Today, true, true, applyingPostingLines: true);
AccountingIdentificationState accountingIdentificationState = new AccountingIdentificationState(group.Key);
IPostingLine[] createdPostingLineCollection = (await postingLineModelHandler.CreateAsync(group.OrderBy(m => m.PostingDate).ThenBy(m => m.SortOrder), accountingIdentificationState, true)).ToArray();
IPostingLine[] updatedPostingLineCollection = (await postingLineModelHandler.UpdateAsync(createdPostingLineCollection.OrderBy(m => m.PostingDate.Date).ThenBy(m => m.SortOrder), accountingIdentificationState)).ToArray();
foreach (IPostingLine postingLine in updatedPostingLineCollection)
{
IPostingLine[] affectedPostingCollection = (await postingLineModelHandler.ReadAsync(m => m.AccountingIdentifier == accountingIdentificationState.AccountingIdentifier && (m.PostingDate == postingLine.PostingDate && m.PostingLineIdentifier > postingLine.SortOrder || m.PostingDate > postingLine.PostingDate), prepareReadState: accountingIdentificationState)).ToArray();
foreach (IPostingLine affectedPostingLine in affectedPostingCollection.Where(m => updatedPostingLineCollection.Contains(m) == false))
{
await postingLineModelHandler.UpdateAsync(affectedPostingLine, accountingIdentificationState);
}
}
postingLineCollection.Add(updatedPostingLineCollection);
}
return (IPostingJournalResult) new PostingJournalResult(postingLineCollection, postingWarningCalculator);
},
MethodBase.GetCurrentMethod()));
}
public Task <IPaymentTerm> DeletePaymentTermAsync(int number)
{
return(ExecuteAsync(async() =>
{
using PaymentTermModelHandler paymentTermModelHandler = new PaymentTermModelHandler(DbContext, AccountingModelConverter.Create());
return await paymentTermModelHandler.DeleteAsync(number);
},
MethodBase.GetCurrentMethod()));
}
public Task <IContactAccount> DeleteContactAccountAsync(int accountingNumber, string accountNumber)
{
NullGuard.NotNullOrWhiteSpace(accountNumber, nameof(accountNumber));
return(ExecuteAsync(async() =>
{
using ContactAccountModelHandler contactAccountModelHandler = new ContactAccountModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.Today, true);
return await contactAccountModelHandler.DeleteAsync(new Tuple <int, string>(accountingNumber, accountNumber), new AccountingIdentificationState(accountingNumber));
},
MethodBase.GetCurrentMethod()));
}
public Task <IPostingLineCollection> GetPostingLinesAsync(int accountingNumber, DateTime statusDate, int numberOfPostingLines)
{
return(ExecuteAsync(async() =>
{
using PostingLineModelHandler postingLineModelHandler = new PostingLineModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.MinValue, statusDate, true, true, numberOfPostingLines);
IPostingLineCollection postingLineCollection = new PostingLineCollection
{
await postingLineModelHandler.ReadAsync(accountingNumber)
};
return postingLineCollection;
},
MethodBase.GetCurrentMethod()));
}
public Task <IContactAccount> UpdateContactAccountAsync(IContactAccount contactAccount)
{
NullGuard.NotNull(contactAccount, nameof(contactAccount));
return(ExecuteAsync(async() =>
{
using ContactAccountModelHandler contactAccountModelHandler = new ContactAccountModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.Today, true);
return await contactAccountModelHandler.UpdateAsync(contactAccount, new AccountingIdentificationState(contactAccount.Accounting.Number));
},
MethodBase.GetCurrentMethod()));
}
public Task <IContactAccount> GetContactAccountAsync(int accountingNumber, string accountNumber, DateTime statusDate)
{
NullGuard.NotNullOrWhiteSpace(accountNumber, nameof(accountNumber));
return(ExecuteAsync(async() =>
{
using ContactAccountModelHandler contactAccountModelHandler = new ContactAccountModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, statusDate, true);
return await contactAccountModelHandler.ReadAsync(accountingNumber, accountNumber);
},
MethodBase.GetCurrentMethod()));
}
public Task <bool> ContactAccountExistsAsync(int accountingNumber, string accountNumber)
{
NullGuard.NotNullOrWhiteSpace(accountNumber, nameof(accountNumber));
return(ExecuteAsync(async() =>
{
using ContactAccountModelHandler contactAccountModelHandler = new ContactAccountModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.Today, false);
return await contactAccountModelHandler.ExistsAsync(accountingNumber, accountNumber);
},
MethodBase.GetCurrentMethod()));
}
public Task <bool> AccountingExistsAsync(int number)
{
return(ExecuteAsync(async() =>
{
using AccountingModelHandler accountingModelHandler = new AccountingModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.Today, false, false);
return await accountingModelHandler.ExistsAsync(number);
},
MethodBase.GetCurrentMethod()));
}
public Task <IAccountGroup> GetAccountGroupAsync(int number)
{
return(ExecuteAsync(async() =>
{
using AccountGroupModelHandler accountGroupModelHandler = new AccountGroupModelHandler(DbContext, AccountingModelConverter.Create());
return await accountGroupModelHandler.ReadAsync(number);
},
MethodBase.GetCurrentMethod()));
}
public Task <IPaymentTerm> UpdatePaymentTermAsync(IPaymentTerm paymentTerm)
{
NullGuard.NotNull(paymentTerm, nameof(paymentTerm));
return(ExecuteAsync(async() =>
{
using PaymentTermModelHandler paymentTermModelHandler = new PaymentTermModelHandler(DbContext, AccountingModelConverter.Create());
return await paymentTermModelHandler.UpdateAsync(paymentTerm);
},
MethodBase.GetCurrentMethod()));
}
public Task <IEnumerable <IAccounting> > GetAccountingsAsync()
{
return(ExecuteAsync(async() =>
{
using AccountingModelHandler accountingModelHandler = new AccountingModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.Today, false, false);
return await accountingModelHandler.ReadAsync();
},
MethodBase.GetCurrentMethod()));
}
public Task <IAccounting> UpdateAccountingAsync(IAccounting accounting)
{
NullGuard.NotNull(accounting, nameof(accounting));
return(ExecuteAsync(async() =>
{
using AccountingModelHandler accountingModelHandler = new AccountingModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.Today, true, true);
return await accountingModelHandler.UpdateAsync(accounting, new AccountingIdentificationState(accounting.Number));
},
MethodBase.GetCurrentMethod()));
}
public Task <IAccountGroup> CreateAccountGroupAsync(IAccountGroup accountGroup)
{
NullGuard.NotNull(accountGroup, nameof(accountGroup));
return(ExecuteAsync(async() =>
{
using AccountGroupModelHandler accountGroupModelHandler = new AccountGroupModelHandler(DbContext, AccountingModelConverter.Create());
return await accountGroupModelHandler.CreateAsync(accountGroup);
},
MethodBase.GetCurrentMethod()));
}
public Task <IEnumerable <IContact> > ApplyContactSupplementAsync(IEnumerable <IContact> contacts)
{
NullGuard.NotNull(contacts, nameof(contacts));
return(ExecuteAsync(async() =>
{
using ContactSupplementModelHandler contactSupplementModelHandler = new ContactSupplementModelHandler(DbContext, ContactModelConverter.Create(), AccountingModelConverter.Create());
return await contactSupplementModelHandler.ApplyContactSupplementAsync(contacts);
},
MethodBase.GetCurrentMethod()));
}
public Task <IEnumerable <IBudgetAccountGroup> > GetBudgetAccountGroupsAsync()
{
return(ExecuteAsync(async() =>
{
using BudgetAccountGroupModelHandler budgetAccountGroupModelHandler = new BudgetAccountGroupModelHandler(DbContext, AccountingModelConverter.Create());
return await budgetAccountGroupModelHandler.ReadAsync();
},
MethodBase.GetCurrentMethod()));
}
public Task <IContact> DeleteContactSupplementAsync(IContact contact)
{
NullGuard.NotNull(contact, nameof(contact));
return(ExecuteAsync(async() =>
{
using ContactSupplementModelHandler contactSupplementModelHandler = new ContactSupplementModelHandler(DbContext, ContactModelConverter.Create(), AccountingModelConverter.Create());
return await contactSupplementModelHandler.DeleteAsync(contact);
},
MethodBase.GetCurrentMethod()));
}
public Task <IBudgetAccount> CreateBudgetAccountAsync(IBudgetAccount budgetAccount)
{
NullGuard.NotNull(budgetAccount, nameof(budgetAccount));
return(ExecuteAsync(async() =>
{
using BudgetAccountModelHandler budgetAccountModelHandler = new BudgetAccountModelHandler(DbContext, AccountingModelConverter.Create(), _eventPublisher, DateTime.Today, true, false);
return await budgetAccountModelHandler.CreateAsync(budgetAccount, new AccountingIdentificationState(budgetAccount.Accounting.Number));
},
MethodBase.GetCurrentMethod()));
}
