public Order AddOrder(AccountTransactionType template, Department department, string userName, MenuItem menuItem, IList <TaxTemplate> taxTemplates, MenuItemPortion portion, string priceTag, ProductTimer timer)
{
UnLock();
var order = new Order();
order.UpdateMenuItem(userName, menuItem, taxTemplates, portion, priceTag, 1);
order.AccountTransactionTypeId = template.Id;
order.WarehouseId = department.WarehouseId;
order.DepartmentId = department.Id;
TransactionDocument.AddSingletonTransaction(template.Id, template, GetTicketAccounts());
if (taxTemplates != null)
{
foreach (var taxTemplate in taxTemplates)
{
TransactionDocument.AddSingletonTransaction(taxTemplate.AccountTransactionType.Id,
taxTemplate.AccountTransactionType,
GetTicketAccounts());
}
}
order.UpdateProductTimer(timer);
Orders.Add(order);
return(order);
}
public async Task <HttpTrigger1Response> HandleAsync(
HttpTrigger1Request httpTrigger1Request)
{
var transactionDocument =
new TransactionDocument
{
TransactionId = httpTrigger1Request.TransactionId
};
transactionDocument =
await _transactionDocumentStore.AddAsync(
transactionDocument);
var httpTrigger1Response =
new HttpTrigger1Response
{
Id = transactionDocument.Id,
TransactionId = transactionDocument.TransactionId,
JobId = transactionDocument.JobId,
Status = transactionDocument.Status,
ReceivedOn = transactionDocument.ReceivedOn,
ProcessedOn = transactionDocument.ProcessedOn
};
return(httpTrigger1Response);
}
private async Task <TransactionCreationResponse> CreateFJDocumentSettlementCurrency(long fxDealId, long settlementTransactionDocumentId, string settlementCurrency, DateTime maturityDate, bool isReversal, string company)
{
try
{
TransactionDocument transactionDocument = new TransactionDocument();
transactionDocument.TransactionDocumentTypeId = (int)MasterDocumentType.FJ;
transactionDocument.TransactionDocumentId = settlementTransactionDocumentId;
transactionDocument.DocumentDate = maturityDate;
transactionDocument.CurrencyCode = settlementCurrency;
transactionDocument.AuthorizedForPosting = true;
transactionDocument.ToInterface = true;
transactionDocument.Company = company;
var transactionDocumentResponse = await _transactionDocumentService.CreateTransactionDocument(transactionDocument);
if (transactionDocumentResponse.TransactionDocumentId > 0)
{
if (!isReversal)
{
await _transactionDocumentService.CreateFxDealSettlementMapping(transactionDocumentResponse.TransactionDocumentId, fxDealId, company, (int)FxSettlementDocumentType.FxSettlement);
}
await _transactionDocumentService.EnqueueMessage(Convert.ToString(transactionDocumentResponse.TransactionDocumentId, System.Globalization.CultureInfo.InvariantCulture), company);
}
return(transactionDocumentResponse);
}
catch
{
throw;
}
}
public void AddChangePayment(ChangePaymentType changePaymentType, Account account, decimal amount, decimal exchangeRate, int userId)
{
var transaction = TransactionDocument.AddNewTransaction(changePaymentType.AccountTransactionType, GetTicketAccounts(account), amount, exchangeRate);
var payment = new ChangePayment {
AccountTransaction = transaction, Amount = amount, Name = account.Name, ChangePaymentTypeId = changePaymentType.Id
};
ChangePayments.Add(payment);
}
public void UpdateCalculationTransaction(Calculation calculation, decimal amount)
{
TransactionDocument.UpdateSingletonTransactionAmount(calculation.AccountTransactionTypeId, calculation.Name, amount, ExchangeRate);
if (amount == 0)
{
TransactionDocument.AccountTransactions.Remove(
TransactionDocument.AccountTransactions.Single(x => x.AccountTransactionTypeId == calculation.AccountTransactionTypeId));
}
}
private bool IsLastTransaction(TransactionDocument document)
{
var lastId = _transactionRepository.Query()
.Where(x => x.PersonId == document.PersonId && !x.DeleteDate.HasValue)
.OrderByDescending(x => x.Date).ThenByDescending(x => x.Id)
.Select(x => x.Id)
.FirstOrDefault();
return(lastId == 0 || lastId == document.Id);
}
private void CancelDocument(TransactionDocument document, CancelTransaction request)
{
var person = document.Person;
var cancelDocument = document.Void(_numberSequenceService);
cancelDocument.Description = request.Description;
person.Accept(cancelDocument);
_transactionRepository.Add(cancelDocument);
}
public async Task <TransactionCreationResponse> CreateTransactionDocument(TransactionDocument transactionDocument)
{
string documentLabel = string.Empty;
string year = string.Empty;
int transactionDocumentTypeId = transactionDocument.TransactionDocumentTypeId;
int documentReferenceYear = 0;
string documentReferenceYearValue = string.Empty;
CommonRules commonRules = new CommonRules(_accountingQueries, _authorizationService, _identityService);
documentReferenceYear = await commonRules.GetDocumentReferenceYear(transactionDocument.DocumentDate, transactionDocument.Company);
documentReferenceYearValue = documentReferenceYear.ToString(System.Globalization.CultureInfo.InvariantCulture).Substring(2, 2);
documentLabel = Enum.GetName(typeof(MasterDocumentType), transactionDocumentTypeId);
year = DateTime.UtcNow.Year.ToString(CultureInfo.InvariantCulture).Substring(2, 2);
int referencenumber = await _transactionDataRepository.GetInvoiceDocumentReferenceValues(transactionDocument.Company, transactionDocumentTypeId, documentReferenceYear);
int yearNumber = referencenumber;
int docYear = DateTime.UtcNow.Year;
string documentReference = string.Concat(documentLabel, year, string.Format(CultureInfo.InvariantCulture, "{0:D5}", referencenumber));
var objResponse = await _transactionDataRepository.CreateTransactionDocument(
transactionDocument.TransactionDocumentTypeId,
transactionDocument.DocumentDate,
transactionDocument.CurrencyCode,
transactionDocument.AuthorizedForPosting,
transactionDocument.PhysicalDocumentId,
documentReference,
yearNumber,
documentReferenceYear,
transactionDocument.Company,
transactionDocument.ToInterface);
// Creation of the "reversal" record
if (transactionDocument.TransactionDocumentId > 0)
{
// create mapping between main and reversed document
await _transactionDataRepository.InsertReversalTransactionMapping(transactionDocument.TransactionDocumentId, objResponse.TransactionDocumentId, transactionDocument.Company);
// Update of the status "isreversed" for the original document
await _transactionDataRepository.UpdateDocumentTypeForDocumentReversal(transactionDocument.TransactionDocumentId, transactionDocument.Company);
}
if (objResponse.TransactionDocumentId > 0)
{
objResponse.DocumentReference = documentReference;
}
return(objResponse);
}
public void AddPayment(PaymentType paymentType, Account account, decimal amount, decimal exchangeRate, int userId)
{
var transaction = TransactionDocument.AddNewTransaction(paymentType.AccountTransactionType, GetTicketAccounts(account), amount, exchangeRate);
transaction.UpdateDescription(transaction.Name + " [" + account.Name + "]");
var payment = new Payment {
AccountTransaction = transaction, Amount = amount, Name = account.Name, PaymentTypeId = paymentType.Id, UserId = userId
};
Payments.Add(payment);
LastPaymentDate = DateTime.Now;
RemainingAmount = GetRemainingAmount();
}
public void AddPayment(PaymentType paymentType, Account account, decimal amount, decimal exchangeRate, int userId)
{
var transaction = TransactionDocument.AddNewTransaction(paymentType.AccountTransactionType, GetTicketAccounts(account), amount, exchangeRate);
var payment = new Payment {
AccountTransaction = transaction, Amount = amount, Name = account.Name, PaymentTypeId = paymentType.Id
};
Payments.Add(payment);
LastPaymentDate = DateTime.Now;
RemainingAmount = GetRemainingAmount();
if (RemainingAmount == 0)
{
PaidItems.Clear();
}
}
public void AddOrder(Order order, IEnumerable <TaxTemplate> taxTemplates, AccountTransactionType template, string userName)
{
TransactionDocument.AddSingletonTransaction(template.Id, template, GetTicketAccounts());
if (taxTemplates != null)
{
foreach (var taxTemplate in taxTemplates)
{
TransactionDocument.AddSingletonTransaction(taxTemplate.AccountTransactionType.Id,
taxTemplate.AccountTransactionType,
GetTicketAccounts());
}
}
Orders.Add(order);
LastModifiedUserName = userName;
}
public Order AddOrder(AccountTransactionType template, string userName, MenuItem menuItem, MenuItemPortion portion, string priceTag, ProductTimer timer)
{
Locked = false;
var order = new Order();
order.UpdateMenuItem(userName, menuItem, portion, priceTag, 1);
order.AccountTransactionTypeId = template.Id;
TransactionDocument.AddSingletonTransaction(template.Id, template, AccountTypeId, AccountId);
if (menuItem.TaxTemplate != null)
{
TransactionDocument.AddSingletonTransaction(order.TaxTempleteAccountTransactionTypeId,
menuItem.TaxTemplate.AccountTransactionType,
AccountTypeId, AccountId);
}
order.UpdateProductTimer(timer);
Orders.Add(order);
return(order);
}
public void AddCalculation(CalculationType calculationType, decimal amount)
{
var calculation = Calculations.SingleOrDefault(x => x.CalculationTypeId == calculationType.Id) ??
Calculations.SingleOrDefault(x => x.AccountTransactionTypeId == calculationType.AccountTransactionType.Id);
if (calculation == null)
{
calculation = new Calculation
{
Amount = amount,
Name = calculationType.Name,
CalculationType = calculationType.CalculationMethod,
CalculationTypeId = calculationType.Id,
IncludeTax = calculationType.IncludeTax,
DecreaseAmount = calculationType.DecreaseAmount,
UsePlainSum = calculationType.UsePlainSum,
Order = calculationType.SortOrder,
AccountTransactionTypeId = calculationType.AccountTransactionType.Id
};
Calculations.Add(calculation);
TransactionDocument.AddSingletonTransaction(calculation.AccountTransactionTypeId, calculationType.AccountTransactionType, GetTicketAccounts());
}
else if (calculationType.ToggleCalculation && calculation.Amount == amount)
{
amount = 0;
}
else
{
calculation.Amount = amount;
}
calculation.Name = calculationType.Name;
if (amount == 0 && calculation.CalculationType != 5)
{
Calculations.Remove(calculation);
calculation.UpdateCalculationTransaction(TransactionDocument, 0, ExchangeRate);
}
}
public void AddCalculation(CalculationType template, decimal amount)
{
var t = Calculations.SingleOrDefault(x => x.CalculationTypeId == template.Id) ??
Calculations.SingleOrDefault(x => x.AccountTransactionTypeId == template.AccountTransactionType.Id);
if (t == null)
{
t = new Calculation
{
Amount = amount,
Name = template.Name,
CalculationType = template.CalculationMethod,
CalculationTypeId = template.Id,
IncludeTax = template.IncludeTax,
DecreaseAmount = template.DecreaseAmount,
Order = template.Order,
AccountTransactionTypeId = template.AccountTransactionType.Id
};
Calculations.Add(t);
TransactionDocument.AddSingletonTransaction(t.AccountTransactionTypeId, template.AccountTransactionType, AccountTypeId, AccountId);
}
else if (t.Amount == amount)
{
amount = 0;
}
else
{
t.Amount = amount;
}
t.Name = template.Name;
if (amount == 0)
{
Calculations.Remove(t);
UpdateCalculationTransaction(t, 0);
}
}
public static async Task <long> AddAsync(string tenant, LoginView userInfo, TransactionPosting model)
{
long transactionMasterId = 0;
string bookName = "Journal Entry";
bool canPost = await CanPostTransactionAsync(tenant, userInfo.LoginId, userInfo.UserId, userInfo.OfficeId, bookName, model.ValueDate).ConfigureAwait(false);
if (!canPost)
{
return(transactionMasterId);
}
using (var db = DbProvider.Get(FrapidDbServer.GetConnectionString(tenant), tenant).GetDatabase())
{
try
{
db.BeginTransaction();
var master = new TransactionMaster
{
Book = bookName,
ValueDate = model.ValueDate,
BookDate = model.BookDate,
TransactionTs = DateTimeOffset.UtcNow,
TransactionCode = string.Empty,
LoginId = userInfo.LoginId,
UserId = userInfo.UserId,
OfficeId = userInfo.OfficeId,
CostCenterId = model.CostCenterId,
ReferenceNumber = model.ReferenceNumber,
StatementReference = string.Empty,
VerificationStatusId = 0,
VerificationReason = string.Empty,
AuditUserId = userInfo.UserId,
AuditTs = DateTimeOffset.UtcNow,
Deleted = false
};
var insertedId =
await
db.InsertAsync("finance.transaction_master", "transaction_master_id", true, master)
.ConfigureAwait(true);
transactionMasterId = insertedId.To <long>();
foreach (var line in model.Details)
{
decimal amountInCurrency;
string tranType;
decimal amountInLocalCurrency;
if (line.Credit.Equals(0) && line.Debit > 0)
{
tranType = "Dr";
amountInCurrency = line.Debit;
amountInLocalCurrency = line.LocalCurrencyDebit;
}
else
{
tranType = "Cr";
amountInCurrency = line.Credit;
amountInLocalCurrency = line.LocalCurrencyCredit;
}
var detail = new TransactionDetail
{
TransactionMasterId = transactionMasterId,
ValueDate = model.ValueDate,
BookDate = model.BookDate,
TranType = tranType,
AccountId = await Accounts.GetAccountIdByAccountNumberAsync(tenant, line.AccountNumber).ConfigureAwait(false),
StatementReference = line.StatementReference,
CashRepositoryId = await CashRepositories.GetCashRepositoryIdByCashRepositoryCodeAsync(tenant, line.CashRepositoryCode).ConfigureAwait(false),
CurrencyCode = line.CurrencyCode,
AmountInCurrency = amountInCurrency,
OfficeId = userInfo.OfficeId,
LocalCurrencyCode = userInfo.CurrencyCode,
Er = line.ExchangeRate,
AmountInLocalCurrency = amountInLocalCurrency,
AuditUserId = userInfo.UserId,
AuditTs = DateTimeOffset.UtcNow
};
await db.InsertAsync("finance.transaction_details", "transaction_detail_id", true, detail).ConfigureAwait(false);
}
if (model.Attachemnts != null && model.Attachemnts.Count > 0)
{
foreach (var item in model.Attachemnts)
{
var document = new TransactionDocument
{
TransactionMasterId = transactionMasterId,
OriginalFileName = item.OriginalFileName,
FileExtension = item.FileExtension,
FilePath = item.FilePath,
Memo = item.Memo,
AuditUserId = userInfo.UserId,
AuditTs = DateTimeOffset.UtcNow,
Deleted = false
};
await db.InsertAsync("finance.transaction_documents", "document_id", true, document).ConfigureAwait(false);
}
}
var sql = new Sql("SELECT * FROM finance.auto_verify(@0::bigint, @1::integer)", transactionMasterId, userInfo.UserId);
await db.ExecuteAsync(sql).ConfigureAwait(false);
db.CompleteTransaction();
}
catch (Exception)
{
db.AbortTransaction();
throw;
}
}
return(transactionMasterId);
}
private void DeleteDocument(TransactionDocument document)
{
var person = document.Person;
person.Cancel(document);
}
