private static void SaveTransaction(RecurringTransaction recurringTransaction)
{
try {
DateTime date = DateTime.Now;
if (recurringTransaction.Recurrence == (int)TransactionRecurrence.Monthly)
{
date = DateTime.Now.AddDays(recurringTransaction.StartDate.Day - DateTime.Today.Day);
}
var newTransaction = new FinancialTransaction {
ChargedAccount = recurringTransaction.ChargedAccount,
TargetAccount = recurringTransaction.TargetAccount,
Date = date,
IsRecurring = true,
Amount = recurringTransaction.Amount,
AmountWithoutExchange = recurringTransaction.AmountWithoutExchange,
Currency = recurringTransaction.Currency,
CategoryId = recurringTransaction.CategoryId,
Type = recurringTransaction.Type,
ReccuringTransactionId = recurringTransaction.Id,
Note = recurringTransaction.Note
};
transactionRepository.Save(newTransaction);
} catch (Exception ex) {
InsightHelper.Report(ex);
}
}
public void RecurringTransactionRepository_AddMultipleToCache()
{
var repository = new RecurringTransactionRepository(_recurringTransactionDataAccessMock);
var account = new Account {
Name = "TestAccount"
};
var transaction = new RecurringTransaction {
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
var secondTransaction = new RecurringTransaction {
ChargedAccount = account,
Amount = 60,
AmountWithoutExchange = 60
};
repository.Save(transaction);
repository.Save(secondTransaction);
Assert.AreEqual(2, repository.Data.Count);
Assert.AreSame(transaction, repository.Data[0]);
Assert.AreSame(secondTransaction, repository.Data[1]);
}
public AddEditTransaction(RecurringTransaction temporaryRecurringTransaction)
{
InitializeComponent();
isRecurring = true;
recurringTransaction = temporaryRecurringTransaction;
lbl_title.Text = Strings.EditRecurringTransaction;
Text = Strings.EditRecurringTransaction;
btn_action.Text = Strings.Edit;
tbx_name.Text = temporaryRecurringTransaction.Name;
cbx_type.Text = temporaryRecurringTransaction.TypeName;
nud_amount.Value = temporaryRecurringTransaction.Amount;
dtp_date.Value = temporaryRecurringTransaction.CreatedDate;
rtbx_note.Text = temporaryRecurringTransaction.Note;
cbx_frequency.Text = temporaryRecurringTransaction.Status;
if (temporaryRecurringTransaction.EndDate == DateTime.MinValue)
{
dtp_end_date.Enabled = false;
chbx_infinite.Checked = true;
}
else
{
dtp_end_date.Value = temporaryRecurringTransaction.EndDate;
}
gbx_recurring.Visible = true;
chbx_recurring.Visible = false;
btn_action.Top -= 10;
}
public MessageStatus DeleteRecurringTransaction(RecurringTransaction recurringTransaction)
{
Query = "DELETE FROM RecurringTransactions WHERE [Id] = @Id AND [UserId] = @UserId;";
try
{
SqlConnection.Open();
SqlCommand sqlCommand = new SqlCommand(Query, SqlConnection);
sqlCommand.Parameters.Add("@Id", SqlDbType.Int).Value = recurringTransaction.Id;
sqlCommand.Parameters.Add("@UserId", SqlDbType.Int).Value = recurringTransaction.UserId;
var i = sqlCommand.ExecuteNonQuery();
if (i > 0)
{
MessageStatus.Message = "Transaction Deleted Successfully!!";
MessageStatus.ErrorStatus = false;
}
else
{
throw new Exception("Error, Data Not Deleted!");
}
}
catch (Exception ex)
{
_logger.Error(ex);
MessageStatus.Message = ex.Message;
MessageStatus.ErrorStatus = true;
}
finally
{
SqlConnection.Close();
}
return(MessageStatus);
}
public void RecurringTransactionRepository_Update()
{
using (var db = SqlConnectionFactory.GetSqlConnection()) {
db.DeleteAll <RecurringTransaction>();
}
var repository = new RecurringTransactionRepository(new RecurringTransactionDataAccess());
var account = new Account {
Name = "TestAccount"
};
var transaction = new RecurringTransaction {
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
repository.Save(transaction);
Assert.AreEqual(1, repository.Data.Count);
Assert.AreSame(transaction, repository.Data[0]);
transaction.Amount = 789;
repository.Save(transaction);
Assert.AreEqual(1, repository.Data.Count);
Assert.AreEqual(789, repository.Data[0].Amount);
}
/// <summary>
/// Adds the specified entity operation.
/// </summary>
/// <param name="entity">entitiy for the batch operation.</param>
public void Add(IEntity entity)
{
// Create and Add a new BatchItem
if (entity == null)
{
IdsException exception = new IdsException(Resources.ParameterNotNullMessage, new ArgumentNullException(Resources.EntityString));
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(Diagnostics.TraceLevel.Error, string.Format(CultureInfo.InvariantCulture, Resources.ExceptionGeneratedMessage, exception.ToString()));
IdsExceptionManager.HandleException(exception);
}
if (this.recurringTxnRequests.Count > 25)
{
IdsException exception = new IdsException(Resources.batchItemsExceededMessage, new BatchItemsExceededException(Resources.batchItemsExceededMessage));
this.serviceContext.IppConfiguration.Logger.CustomLogger.Log(Diagnostics.TraceLevel.Error, string.Format(CultureInfo.InvariantCulture, Resources.ExceptionGeneratedMessage, exception.ToString()));
IdsExceptionManager.HandleException(exception);
}
RecurringTransaction recurrTxnItem = new RecurringTransaction();
//tring entityTypeToParseTo = entity.GetType().Name;
//IEntity mappedEntity = "Intuit.Ipp.Data." + entityTypeToParseTo;
RecurrTransactionChoiceType result;
entity.GetType();
if (Enum.TryParse(entity.GetType().Name, out result))
{
recurrTxnItem.AnyIntuitObject = entity as result;
}
this.batchRequests.Add(batchItem);
}
private static bool CheckIfRepeatable(RecurringTransaction recTrans, FinancialTransaction relTransaction)
{
switch (recTrans.Recurrence)
{
case (int)TransactionRecurrence.Daily:
return(DateTime.Today.Date != relTransaction.Date.Date);
case (int)TransactionRecurrence.DailyWithoutWeekend:
return(DateTime.Today.Date != relTransaction.Date.Date &&
DateTime.Today.DayOfWeek != DayOfWeek.Saturday &&
DateTime.Today.DayOfWeek != DayOfWeek.Sunday);
case (int)TransactionRecurrence.Weekly:
TimeSpan days = DateTime.Now - relTransaction.Date;
return(days.Days >= 7);
case (int)TransactionRecurrence.Monthly:
return(DateTime.Now.Month != relTransaction.Date.Month);
case (int)TransactionRecurrence.Yearly:
return(DateTime.Now.Year != relTransaction.Date.Year &&
DateTime.Now.Month == relTransaction.Date.Month);
}
return(false);
}
public bool DeleteTransaction(RecurringTransaction temporaryTransaction)
{
string query = "DELETE FROM RecurringTransactions WHERE [UserID] = @UserID AND [ID] = @ID";
string connectionString = ConfigurationManager.ConnectionStrings["AzureConnection"].ConnectionString;
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
sqlConnection.Open();
SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
sqlCommand.Parameters.Add("@UserID", SqlDbType.Int).Value = temporaryTransaction.UserID;
sqlCommand.Parameters.Add("@ID", SqlDbType.Int).Value = temporaryTransaction.ID;
var result = sqlCommand.ExecuteNonQuery();
return((result > 0) ? true : false);
}
catch (Exception ex)
{
Logger.Error(ex.Message);
return(false);
}
finally
{
sqlConnection.Dispose();
}
}
public static void ProjectIndividualPayment(RecurringTransaction transaction)
{
var UpsideDb = new DatabaseContext();
var nextPaymentDate = transaction.FirstPaymentDate;
var endProjectionDate = DateTime.Now.AddMonths(6);
//loop through transaction and project
while (nextPaymentDate <= endProjectionDate)
{
if (transaction.TransactionType == "Revenue")
{
//check if revenue already exists
if (!UpsideDb.Revenues.Any(rev => rev.RevenueCategory == transaction.TransactionCategory &&
rev.RevenueDate == nextPaymentDate &&
rev.UserID == transaction.UserID))
{
//if not, add revenue to table
var newRevenue = new Revenue()
{
RevenueCategory = transaction.TransactionCategory,
RevenueName = transaction.TransactionName,
RevenueDate = nextPaymentDate,
RevenueAmount = transaction.TransactionAmount,
UserID = transaction.UserID,
RecurringTransactionID = transaction.ID,
};
UpsideDb.Revenues.Add(newRevenue);
}
}
else if (transaction.TransactionType == "Expense")
{
//check if expense already exists
if (!UpsideDb.Expenses.Any(exp => exp.ExpenseCategory == transaction.TransactionCategory &&
exp.ExpenseDate == nextPaymentDate &&
exp.UserID == transaction.UserID))
{
//if not, add expense to table
var newExpense = new Expense()
{
ExpenseCategory = transaction.TransactionCategory,
ExpenseName = transaction.TransactionName,
ExpenseDate = nextPaymentDate,
ExpenseAmount = transaction.TransactionAmount,
UserID = transaction.UserID,
RecurringTransactionID = transaction.ID,
};
UpsideDb.Expenses.Add(newExpense);
}
}
//increment nextPaymentDate
nextPaymentDate = IncrementDate(nextPaymentDate, transaction.RecurringFrequency);
}
UpsideDb.SaveChanges();
}
public async Task <ActionResult> AddUserRevenue(IncomingRevenueData incomingRevenue)
{
//If Revenue Amount equals 0, return BadRequest. Revenues must be greater than 0.
if (incomingRevenue.RevenueAmount == 0)
{
return(BadRequest("Amount must be greater than 0."));
}
//Else, get User ID from Claims
var userId = int.Parse(User.Claims.FirstOrDefault(claim => claim.Type == "ID").Value);
//Create new Revenue
var newRevenue = new Revenue
{
RevenueCategory = incomingRevenue.RevenueCategory,
RevenueName = incomingRevenue.RevenueName,
RevenueDate = incomingRevenue.RevenueDate,
RevenueAmount = incomingRevenue.RevenueAmount,
UserID = userId
};
//If Revenue is recurring, create new Recurring Transaction and project it.
if (incomingRevenue.RecurringFrequency != "One Time")
{
var newRecurringTransaction = new RecurringTransaction
{
TransactionType = "Revenue",
TransactionCategory = incomingRevenue.RevenueCategory,
TransactionName = incomingRevenue.RevenueName,
FirstPaymentDate = incomingRevenue.RevenueDate,
TransactionAmount = incomingRevenue.RevenueAmount,
RecurringFrequency = incomingRevenue.RecurringFrequency,
UserID = userId
};
_context.RecurringTransactions.Add(newRecurringTransaction);
await _context.SaveChangesAsync();
RecurringTransactionManager.ProjectIndividualPayment(newRecurringTransaction);
newRevenue.RecurringTransactionID = newRecurringTransaction.ID;
}
//Else, save One Time Revenue record
else
{
_context.Revenues.Add(newRevenue);
await _context.SaveChangesAsync();
}
//Return new Revenue
return(new ContentResult()
{
Content = JsonConvert.SerializeObject(newRevenue),
ContentType = "application/json",
StatusCode = 201
});
}
public ActionResult DeleteConfirmed(int id)
{
RecurringTransaction recurringtransaction = db.RecurringTransactions.Find(id);
db.RecurringTransactions.Remove(recurringtransaction);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void Should_EnumerateNothing_If_FrequencyListsNoDates()
{
RecurringTransaction t = new RecurringTransaction(new Income(500), Tester.MockFrequency.Object, new DateTime(2019, 1, 1), null);
t.EnumerateElementsUntilDate(new DateTime(2018, 1, 1));
Assert.AreEqual(0, t.Elements.Count());
}
public void RecurringTransactionQueryUsingoAuth()
{
QueryService <RecurringTransaction> entityQuery = new QueryService <RecurringTransaction>(qboContextoAuth);
RecurringTransaction existing = Helper.FindOrAdd <RecurringTransaction>(qboContextoAuth, new RecurringTransaction());
//List<RecurringTransaction> entities = entityQuery.Where(c => c.Id == existing.Id).ToList();
int count = entityQuery.ExecuteIdsQuery("Select * from RecurringTransaction where Id='" + existing.AnyIntuitObject.Id + "'").Count;
Assert.IsTrue(count > 0);
}
public async Task DeleteAsync(RecurringTransaction transaction)
{
await Database.DeleteAsync(transaction);
var item = Summaries.Single(s => s.Id == transaction.Id);
Summaries.Remove(item);
MessagingCenter.Send(this, Messages.Delete, new ModelAction <RecurringTransaction>(transaction, ActionType.Delete));
}
public void RecurringTransactionAddAsyncTestsUsingoAuth()
{
//Creating the RecurringTransaction for Add
RecurringTransaction entity = QBOHelper.CreateRecurringTransaction(qboContextoAuth);
RecurringTransaction added = Helper.AddAsync <RecurringTransaction>(qboContextoAuth, entity);
QBOHelper.VerifyRecurringTransaction(entity, added);
}
public bool EditTransaction(RecurringTransaction temporaryTransaction)
{
string query = "UPDATE RecurringTransactions SET [Name] = @Name, [ContactID] = @ContactID, [Type] = @Type, [Amount] = @Amount, [Note] = @Note, [AddedDate] = @CreatedDate, [Status] = @Status, [EndDate] = @EndDate WHERE [ID] = @ID AND [UserID] = @UserID";
string connectionString = ConfigurationManager.ConnectionStrings["AzureConnection"].ConnectionString;
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
sqlConnection.Open();
SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
sqlCommand.Parameters.Add("@ID", SqlDbType.Int).Value = temporaryTransaction.ID;
sqlCommand.Parameters.Add("@UserID", SqlDbType.Int).Value = temporaryTransaction.UserID;
sqlCommand.Parameters.Add("@Name", SqlDbType.NVarChar).Value = temporaryTransaction.Name;
sqlCommand.Parameters.Add("@Type", SqlDbType.Bit).Value = temporaryTransaction.Type;
sqlCommand.Parameters.Add("@Amount", SqlDbType.Money).Value = temporaryTransaction.Amount;
sqlCommand.Parameters.Add("@Note", SqlDbType.NVarChar).Value = temporaryTransaction.Note;
sqlCommand.Parameters.Add("@CreatedDate", SqlDbType.DateTime).Value = temporaryTransaction.CreatedDate;
sqlCommand.Parameters.Add("@Status", SqlDbType.NVarChar).Value = temporaryTransaction.Status;
SqlParameter transactionContact = new SqlParameter("@ContactID", SqlDbType.Int);
if (temporaryTransaction.ContactID == 0)
{
transactionContact.Value = DBNull.Value;
}
else
{
transactionContact.Value = temporaryTransaction.ContactID;
}
sqlCommand.Parameters.Add(transactionContact);
SqlParameter transactionEndDate = new SqlParameter("@EndDate", SqlDbType.DateTime);
if (temporaryTransaction.EndDate == DateTime.MinValue)
{
transactionEndDate.Value = DBNull.Value;
}
else
{
transactionEndDate.Value = temporaryTransaction.EndDate;
}
sqlCommand.Parameters.Add(transactionEndDate);
var result = sqlCommand.ExecuteNonQuery();
return((result > 0) ? true : false);
}
catch (Exception ex)
{
Logger.Error(ex.Message);
return(false);
}
finally
{
sqlConnection.Dispose();
}
}
public void Should_ComputeValue_From_Dates()
{
RecurringTransaction t = new RecurringTransaction(new Income(500), Tester.MockFrequency.Object, new DateTime(2019, 1, 1), new DateTime(2019, 1, 30));
Tester.MockFrequency.DateCollection.Add(new DateTime(2019, 1, 4));
Tester.MockFrequency.DateCollection.Add(new DateTime(2019, 1, 11));
Assert.AreEqual(1000, t.GetValueBetweenDates(new DateTime(2019, 1, 1), new DateTime(2019, 2, 24)));
}
public void RecurringTransactionDeleteAsyncTestsUsingoAuth()
{
//Creating the RecurringTransaction for Adding
RecurringTransaction entity = QBOHelper.CreateRecurringTransaction(qboContextoAuth);
//Adding the RecurringTransaction
RecurringTransaction added = Helper.Add <RecurringTransaction>(qboContextoAuth, entity);
Helper.DeleteAsync <RecurringTransaction>(qboContextoAuth, added);
}
public void Should_TruncateElapsedEventsRequest_If_End_Is_BeforeToDate()
{
RecurringTransaction t = new RecurringTransaction(new Income(500), Tester.MockFrequency.Object, new DateTime(2019, 1, 1), new DateTime(2019, 1, 30));
Tester.MockFrequency.DateCollection.Add(new DateTime(2019, 1, 4));
Tester.MockFrequency.DateCollection.Add(new DateTime(2020, 1, 11));
Assert.AreEqual(500, t.GetValueBetweenDates(new DateTime(2018, 1, 1), new DateTime(2020, 2, 24)));
}
public void RecurringTransactionAddTestUsingoAuth()
{
//Creating the RecurringTransaction for Add
RecurringTransaction recurringTransaction = QBOHelper.CreateRecurringTransaction(qboContextoAuth);
//Adding the RecurringTransaction
RecurringTransaction added = Helper.Add <RecurringTransaction>(qboContextoAuth, recurringTransaction);
//Verify the added RecurringTransaction
QBOHelper.VerifyRecurringTransaction(recurringTransaction, added);
}
//
// GET: /RecurringTransaction/Details/5
public ActionResult Details(int id = 0)
{
RecurringTransaction recurringtransaction = db.RecurringTransactions.Find(id);
if (recurringtransaction == null)
{
return(HttpNotFound());
}
return(View(recurringtransaction));
}
public void Should_EnumerateElement_On_StartDate()
{
RecurringTransaction t = new RecurringTransaction(new Income(500), Tester.MockFrequency.Object, new DateTime(2019, 1, 1), null);
Tester.MockFrequency.DateCollection.Add(new DateTime(2019, 1, 1));
t.EnumerateElementsUntilDate(new DateTime(2019, 3, 1));
Assert.AreEqual(1, t.Elements.Count());
}
public void RecurringTransactionFindByIdAsyncTestsUsingoAuth()
{
//Creating the RecurringTransaction for Adding
RecurringTransaction entity = QBOHelper.CreateRecurringTransaction(qboContextoAuth);
//Adding the RecurringTransaction
RecurringTransaction added = Helper.Add <RecurringTransaction>(qboContextoAuth, entity);
added.Id = added.AnyIntuitObject.Id;//mapping search entity id to recurring txn id
//FindById and verify
Helper.FindByIdAsync <RecurringTransaction>(qboContextoAuth, added);
}
//
// GET: /RecurringTransaction/Edit/5
public ActionResult Edit(int id = 0)
{
RecurringTransaction recurringtransaction = db.RecurringTransactions.Find(id);
if (recurringtransaction == null)
{
return(HttpNotFound());
}
ViewBag.Category = new SelectList(db.Categories, "CategoryID", "Name", recurringtransaction.Category);
return(View(recurringtransaction));
}
public ActionResult Edit(RecurringTransaction recurringtransaction)
{
if (ModelState.IsValid)
{
db.Entry(recurringtransaction).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Category = new SelectList(db.Categories, "CategoryID", "Name", recurringtransaction.Category);
return(View(recurringtransaction));
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
Budget.Configure(modelBuilder);
Transaction.Configure(modelBuilder);
Income.Configure(modelBuilder);
User.Configure(modelBuilder);
TransactionBudget.Configure(modelBuilder);
TransactionIncome.Configure(modelBuilder);
RecurringTransaction.Configure(modelBuilder);
RecurringIncome.Configure(modelBuilder);
}
public void CreateRecurringTransactionsRespectingEndDate()
{
List <TransactionLine> lines = new List <TransactionLine>();
RecurringTransaction transaction = TransactionLineBuilder.BuildRecurringTransaction(TransactionLineBuilder.DefaultAmount);
transaction.EndYearMonth = new YearMonth(2019, 2);
transaction.IncludeLines(lines, new YearMonth(2019, 1), new YearMonth(2019, 6));
Assert.Equal(2, lines.Count);
}
public ActionResult Create(RecurringTransaction recurringtransaction)
{
if (ModelState.IsValid)
{
db.RecurringTransactions.Add(recurringtransaction);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Category = new SelectList(db.Categories, "CategoryID", "Name", recurringtransaction.Category);
return(View(recurringtransaction));
}
public void RecurringTransactionFindbyIdTestUsingoAuth()
{
//Creating the RecurringTransaction for Adding
RecurringTransaction recurringTransaction = QBOHelper.CreateRecurringTransaction(qboContextoAuth);
//Adding the RecurringTransaction
RecurringTransaction added = Helper.Add <RecurringTransaction>(qboContextoAuth, recurringTransaction);
added.Id = added.AnyIntuitObject.Id;
RecurringTransaction found = Helper.FindById <RecurringTransaction>(qboContextoAuth, added);
QBOHelper.VerifyRecurringTransaction(found, added);
}
/// <summary>
/// Save a new item or update an existin one.
/// </summary>
/// <param name="item">item to save</param>
public void Save(RecurringTransaction item)
{
if (item.ChargedAccount == null)
{
throw new InvalidDataException("charged accout is missing");
}
if (item.Id == 0)
{
_data.Add(item);
}
_dataAccess.Save(item);
}
