internal async Task <long> GetPatternIDAsync(Entries.EntryVM value)
{
return(await this.GetDataQuery()
.Where(x => x.Type == (short)value.Type && x.CategoryID == (value.CategoryID ?? 0) && x.Text == value.Text)
.Select(x => x.PatternID)
.FirstOrDefaultAsync());
}
internal async Task <ActionResult <bool> > CreateAsync(TransferVM value)
{
try
{
var entriesService = this.GetService <Entries.EntriesService>();
var transferID = Guid.NewGuid().ToString("N");
// VALIDATE
// var validateMessage = await this.ValidateAsync(viewModel);
// var validateResult = this.GetValue(validateMessage);
// if (!validateResult) { return validateMessage.Result; }
// ACCOUNTS
var accountIDs = new long[] { value.ExpenseAccountID, value.IncomeAccountID };
var accounts = await this.dbContext.Accounts.Where(x => accountIDs.Contains(x.AccountID)).ToListAsync();
// EXPENSE
var expenseAccount = accounts.Where(x => x.AccountID == value.ExpenseAccountID).Select(x => x.Text).FirstOrDefault();
var expenseEntry = new Entries.EntryVM
{
TransferID = transferID,
DueDate = value.TransferDate,
EntryValue = value.TransferValue,
Paid = true,
PayDate = value.TransferDate,
AccountID = value.ExpenseAccountID,
Type = Categories.enCategoryType.Expense
};
// INCOME
var incomeAccount = accounts.Where(x => x.AccountID == value.IncomeAccountID).Select(x => x.Text).FirstOrDefault();
var incomeEntry = new Entries.EntryVM
{
TransferID = transferID,
DueDate = value.TransferDate,
EntryValue = value.TransferValue,
Paid = true,
PayDate = value.TransferDate,
AccountID = value.IncomeAccountID,
Type = Categories.enCategoryType.Income
};
// DESCRIPTION
expenseEntry.Text = this.GetTranslation("TRANSFERS_TO_ACCOUNT_DESCRIPTION").Replace("{accountText}", incomeAccount);
incomeEntry.Text = this.GetTranslation("TRANSFERS_FROM_ACCOUNT_DESCRIPTION").Replace("{accountText}", expenseAccount);
// APPLY
await entriesService.CreateAsync(expenseEntry);
await entriesService.CreateAsync(incomeEntry);
// RESULT
return(this.OkResponse(true));
}
catch (Exception ex) { return(this.ExceptionResponse(ex)); }
}
internal async Task <long?> AddAsync(Entries.EntryVM value)
{
var startTime = DateTime.Now;
try
{
if (!value.CategoryID.HasValue)
{
return(null);
}
// TRY TO LOCATE PATTERN
var data = await this.GetDataQuery()
.Where(x => x.Type == (short)value.Type && x.CategoryID == value.CategoryID.Value && x.Text == value.Text)
.FirstOrDefaultAsync();
// ADD NEW IF DOESNT FOUND
if (data == null)
{
data = new PatternData
{
ResourceID = this.GetService <Helpers.User>().ResourceID,
Type = (short)value.Type,
CategoryID = value.CategoryID.Value,
Text = value.Text,
Count = 0,
RowStatus = 1
};
await this.dbContext.Patterns.AddAsync(data);
}
// INCREASE QUANTITY AND SAVE IT
data.Count++;
await this.dbContext.SaveChangesAsync();
// RESULT
return(data.PatternID);
}
catch (Exception) { throw; }
finally { this.TrackMetric("Add Pattern", Math.Round(DateTime.Now.Subtract(startTime).TotalMilliseconds, 0)); }
}
internal async Task <bool> AddEntriesAsync(long recurrencyID)
{
var startTime = DateTime.Now;
try
{
var entriesService = this.GetService <Entries.EntriesService>();
// RECURRENCY
var recurrency = await this.GetDataQuery()
.Where(x => x.RecurrencyID == recurrencyID)
.FirstOrDefaultAsync();
if (recurrency == null)
{
return(false);
}
// PATTERN
var patternMessage = await this.GetService <Patterns.PatternsService>().GetPatternAsync(recurrency.PatternID);
var pattern = this.GetValue(patternMessage);
if (pattern == null)
{
return(false);
}
// DEFINE QUANTITY TO GENERATE
var totalQuantity = recurrency.Count;
if (totalQuantity == 0)
{
totalQuantity = 3;
}
// LOOP
var generatedQuantity = 1;
while (generatedQuantity < totalQuantity)
{
// FREQUENCY
recurrency.EntryDate = this.AddEntriesAsync_NextDate((enRecurrencyType)recurrency.Type, recurrency.EntryDate);
// MODEL
var entryVM = new Entries.EntryVM
{
Text = pattern.Text,
Type = pattern.Type,
CategoryID = pattern.CategoryID,
DueDate = recurrency.EntryDate,
EntryValue = Math.Abs(recurrency.EntryValue),
AccountID = recurrency.AccountID,
PatternID = recurrency.PatternID,
RecurrencyID = recurrency.RecurrencyID,
Paid = false
};
var entryMessage = await entriesService.CreateAsync(entryVM);
var entryResult = this.GetValue(entryMessage);
// NEXT
generatedQuantity++;
}
// RESULT
return(true);
}
catch (Exception) { throw; }
finally { this.TrackMetric("Add Entries to Recurrency", Math.Round(DateTime.Now.Subtract(startTime).TotalMilliseconds, 0)); }
}
internal async Task <ActionResult <bool> > CreateEntriesAsync(ImportVM value)
{
try
{
var entriesService = this.GetService <Entries.EntriesService>();
if (value.Entries == null || value.Entries.Count == 0)
{
return(this.OkResponse(true));
}
value.Entries = value.Entries.OrderBy(x => x.Account).ThenBy(x => x.DueDate).ToList();
// NUMBER OF ROWS TO LOG AT EACH 10 PERCENTE
var eachNthRows = Math.Floor((double)(value.Entries.Count / 10));
// LOOP THROUGH ENTRIES
for (int i = 0; i < value.Entries.Count; i++)
{
var entry = value.Entries[i];
if ((i % eachNthRows) == 0)
{
this.TrackEvent("Import Data - Importing Entries", $"UserID:{value.UserID}", $"Percent:{i / eachNthRows * 10}%");
}
var createParam = new Entries.EntryVM
{
Text = entry.Text,
Type = entry.Type,
AccountID = entry.AccountID,
CategoryID = entry.CategoryID,
DueDate = entry.DueDate,
EntryValue = Math.Round(Math.Abs(entry.Value), 2),
Paid = entry.Paid,
PayDate = entry.PayDate,
RecurrencyID = entry.RecurrencyID,
EntryID = 0
};
if (!string.IsNullOrEmpty(entry.Recurrency) && !createParam.RecurrencyID.HasValue)
{
createParam.Recurrency = new Recurrencies.RecurrencyVM
{
Type = Recurrencies.enRecurrencyType.Monthly,
Count = 1
};
}
var createMessage = await entriesService.CreateAsync(createParam);
var createResult = this.GetValue(createMessage);
if (createResult == null)
{
return(createMessage.Result);
}
if (createParam.Recurrency != null)
{
value.Entries
.Where(x => x.Recurrency == entry.Recurrency && !x.RecurrencyID.HasValue)
.ToList()
.ForEach(x => x.RecurrencyID = createResult.RecurrencyID);
}
}
// RESULT
return(this.OkResponse(true));
}
catch (Exception ex) { return(this.ExceptionResponse(ex)); }
}
