public static GetExpenseItemsResponse GetExpenseItemsByExpenseId(int expenseId)
{
GetExpenseItemsResponse response = new GetExpenseItemsResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
response.ExpenseItemDto = from expenseItem in entity.ExpenseItems
where expenseItem.ExpenseId == expenseId
select new ExpenseItemDto
{
ID = expenseItem.ID,
ExpenseItemDate = expenseItem.ExpenseItemDate,
Description = expenseItem.Description,
Amount = expenseItem.Amount,
ExpenseId = expenseItem.ExpenseId
};
if (response.ExpenseItemDto == null)
{
response.IsSuccess = false;
}
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Get ExpenseItems By ExpenseId Unsuccessful", ex);
}
return(response);
}
public static SaveExpenseResponse SaveExpense(ExpenseSaveRequest request)
{
SaveExpenseResponse response = new SaveExpenseResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
if (request.ExpenseId == 0)
{
CreateExpense(request.UserId, request.ExpenseItemsDto, entity, response);
CreateExpenseHistory(response.ExpenseId, entity, null);
}
else
{
UpdateExpense(request, entity, response);
}
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Save Expense Unsuccessful", ex);
}
finally
{
entity.Dispose();
}
return(response);
}
public static GetRejectReasonResponse GetRejectReason(ExpenseGetRequest request)
{
GetRejectReasonResponse response = new GetRejectReasonResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
response.RejectReason = (from eh in entity.ExpenseHistories
where eh.ExpenseId == request.ExpenseId && eh.ExpenseStatusId == (int)StatusEnum.Rejected
orderby eh.CreatedDate descending
select eh.RejectReason).FirstOrDefault();
if (response.RejectReason == null)
{
return(response);
}
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Get Reject Reason Unsuccessful", ex);
}
finally
{
entity.Dispose();
}
return(response);
}
public static GetExpensesResponse GetExpenseByActionId(IdRequest request)
{
GetExpensesResponse response = new GetExpensesResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
response.ExpenseDto = from expense in entity.Expenses
where expense.LastExpenseActionId == request.ID
select new ExpenseDto
{
ID = expense.ID,
CreatedDate = expense.CreatedDate,
TotalAmount = expense.TotalAmount,
UserId = expense.UserId,
UserName = expense.User.FullName
};
if (response.ExpenseDto == null)
{
response.IsSuccess = false;
}
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Get Expense By UserId Unsuccessful", ex);
}
return(response);
}
public static BaseResponse Logoff()
{
ExpenseAppEntities entity = new ExpenseAppEntities();
BaseResponse response = new BaseResponse();
//Check if session exists
if (HttpContext.Current.Session[SessionConstants.UserEmail] != null)
{
try
{
//int userId = Convert.ToInt32(HttpContext.Current.Session["UserId"]);
//entity.SaveChanges();
HttpContext.Current.Session.Abandon();
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Logoff Unsuccessful", ex);
}
//finally
//{
// entity.Dispose();
//}
return(response);
}
response.IsSuccess = false;
return(response);
}
public static void SendEmail(ExpenseAppEntities entity, User user)
{
MailMessage mail = new MailMessage("*****@*****.**", user.Email);
SmtpClient client = new SmtpClient();
try
{
var config = entity.Configs.Where(c => c.ID == (int)ConfigEnum.PortConfig).First();
String mailTemplate = "";
client.Port = Int32.Parse(config.ConfigKey);
client.Host = config.ConfigValue;
client.Timeout = 10000;
client.DeliveryMethod = SmtpDeliveryMethod.Network;
client.UseDefaultCredentials = false;
mail.IsBodyHtml = true;
mailTemplate = "Hello " + user.FullName + ",<br />" +
"There are expenses waiting for your approval. Please either approve or reject them as soon as possible.<br />" +
"Thank you";
mail.Subject = "Expense Approval";
mail.Body = mailTemplate;
client.Send(mail);
}
catch (Exception ex)
{
log.Error("Sending Email Unsuccessful", ex);
}
finally
{
client.Dispose();
mail.Dispose();
}
}
public static BaseResponse SendExpenseForApproval(IdRequest request)
{
BaseResponse response = new BaseResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
var expenseToBeSentForApproval = (from expense in entity.Expenses
where expense.ID == request.ID
select expense).FirstOrDefault();
if (expenseToBeSentForApproval == null)
{
response.IsSuccess = false;
return(response);
}
expenseToBeSentForApproval.LastExpenseActionId = (int)StatusEnum.WaitingForManagerApproval;
ExpenseHandlers.CreateExpenseHistory(request.ID, entity, null);
response.IsSuccess = true;
entity.SaveChanges();
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Send Expense For Approval Unsuccessful", ex);
}
finally
{
entity.Dispose();
}
return(response);
}
public static GetCurrentExpenseResponse GetCurrentExpenseStatus(int expenseId)
{
GetCurrentExpenseResponse response = new GetCurrentExpenseResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
response.LastExpenseActionId = (from expense in entity.Expenses
where expense.ID == expenseId
select expense.LastExpenseActionId).FirstOrDefault();
if (response.LastExpenseActionId == null)
{
response.IsSuccess = false;
return(response);
}
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Get Current Expense Status Unsuccessful", ex);
}
finally
{
entity.Dispose();
}
return(response);
}
public static BaseResponse PayExpense(IdRequest request)
{
BaseResponse response = new BaseResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
var expenseToBePaid = (from expense in entity.Expenses
where expense.ID == request.ID
select expense).FirstOrDefault();
if (expenseToBePaid == null)
{
response.IsSuccess = false;
return(response);
}
expenseToBePaid.LastExpenseActionId = (int)StatusEnum.Completed;
ExpenseHandlers.CreateExpenseHistory(request.ID, entity, null);
entity.SaveChanges();
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Pay Expense", ex);
}
finally
{
entity.Dispose();
}
return(response);
}
private static void DeleteExpenseHistory(Expense expense, ExpenseAppEntities entity)
{
var expenseHistories = (from histories in entity.ExpenseHistories
where histories.ExpenseId == expense.ID
select histories);
foreach (var history in expenseHistories)
{
entity.ExpenseHistories.Remove(history);
}
entity.SaveChanges();
}
public static BaseResponse DeleteExpenseById(IdRequest request)
{
BaseResponse response = new BaseResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
var expenseInDb = entity.Expenses.FirstOrDefault(e => e.ID == request.ID);
if (expenseInDb == null)
{
response.IsSuccess = false;
return(response);
}
var expenseItemsInDb = from e in entity.ExpenseItems
where e.ExpenseId == request.ID
select e;
if (!expenseItemsInDb.Any())
{
DeleteExpenseHistory(expenseInDb, entity);
DeleteExpense(expenseInDb, entity);
response.IsSuccess = true;
return(response);
}
foreach (var item in expenseItemsInDb)
{
entity.ExpenseItems.Remove(item);
}
DeleteExpenseHistory(expenseInDb, entity);
DeleteExpense(expenseInDb, entity);
response.IsSuccess = true;
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Delete Expense Unsuccessful", ex);
}
finally
{
entity.Dispose();
}
return(response);
}
private static void RejectExpense(ExpenseApprovalRequest request, ExpenseAppEntities entity, ApprovalExpenseResponse response)
{
var expenseToBeRejected = (from expense in entity.Expenses
where expense.ID == request.ExpenseId
select expense).FirstOrDefault();
if (expenseToBeRejected == null)
{
response.IsSuccess = false;
return;
}
expenseToBeRejected.LastExpenseActionId = (int)StatusEnum.Rejected;
entity.SaveChanges();
response.ApprovalStatus = (int)ApprovalStatusEnum.Rejected;
response.IsSuccess = true;
}
public static ShouldCheckEmailResponse CheckIfManagerShouldBeEmailed(ExpenseAppEntities entity)
{
ShouldCheckEmailResponse response = new ShouldCheckEmailResponse();
var unapprovedExpenses = (from e in entity.GetUnApprovedExpenses
select e).DefaultIfEmpty();
if (unapprovedExpenses == null)
{
response.IsNeeded = false;
return(response);
}
else
{
response.IsNeeded = true;
return(response);
}
}
public void Execute(IJobExecutionContext context)
{
BaseResponse response = new BaseResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
ServiceHandler.CheckThenSendEmail(entity, response);
response.IsSuccess = true;
}
catch (Exception ex)
{
log.Error(ex);
}
finally
{
entity.Dispose();
}
}
public static GetExpensesResponse GetExpenseByUserId(int userId)
{
GetExpensesResponse response = new GetExpensesResponse();
ExpenseAppEntities entity = new ExpenseAppEntities();
try
{
response.ExpenseDto = from expense in entity.Expenses.Where(e => e.UserId == userId)
//where expense.UserId == userId
//from user in Entity.Users.Where(user => user.ID == expense.UserId)
//from history in Entity.ExpenseHistories.Where(history => history.ExpenseStatusId == expense.LastExpenseActionId)
from status in entity.ExpenseStatus.Where(status => status.ID == expense.LastExpenseActionId)
select new ExpenseDto
{
ID = expense.ID,
CreatedDate = expense.CreatedDate,
TotalAmount = expense.TotalAmount,
UserId = expense.UserId,
LastExpenseActionId = expense.LastExpenseActionId,
CurrentStatus = status.StatusName
};
var user = (from u in entity.Users
where u.ID == userId
select u).Single();
response.UserId = user.ID;
//test
//var expense = Entity.Expenses
// .Include(e => e.User)
// .Include(e => e.ExpenseHistories)
// .FirstOrDefault(x => x.ID == 4);
//var a = expense.ExpenseHistories.LastOrDefault().ExpenseStatusId;
response.IsSuccess = response.ExpenseDto == null ? false : true;
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Get Expense By UserId Unsuccessful", ex);
}
return(response);
}
private static void UpdateExpense(ExpenseSaveRequest request, ExpenseAppEntities entity, SaveExpenseResponse response)
{
var expenseInDb = (from e in entity.Expenses
where e.ID == request.ExpenseId
select e).FirstOrDefault();
if (expenseInDb == null)
{
response.IsSuccess = false;
return;
}
expenseInDb.TotalAmount = 0;
if (request.DeletedExpenseItems.Any())
{
DeleteExpenseItem(request.DeletedExpenseItems, entity, response);
}
foreach (var item in request.ExpenseItemsDto)
{
expenseInDb.TotalAmount += item.Amount;
var expenseItemInDb = (from e in entity.ExpenseItems
where e.ID == item.ID
select e).FirstOrDefault();
if (expenseItemInDb == null)
{
CreateExpenseItem(expenseInDb, item, entity);
}
else
{
UpdateExpenseItem(expenseItemInDb, item, entity);
}
}
expenseInDb.LastExpenseActionId = (int)StatusEnum.Ongoing;
entity.SaveChanges();
response.IsSuccess = true;
}
public static void CreateExpenseHistory(int expenseId, ExpenseAppEntities entity, string rejectReason)
{
var expense = (from e in entity.Expenses
where e.ID == expenseId
select e).First();
ExpenseHistory expenseHistory = new ExpenseHistory();
expenseHistory.ExpenseId = expense.ID;
expenseHistory.CreatedBy = expense.UserId;
expenseHistory.CreatedDate = DateTime.Now;
switch (expense.LastExpenseActionId)
{
case 1:
expenseHistory.ExpenseStatusId = (int)StatusEnum.Ongoing;
break;
case 2:
expenseHistory.ExpenseStatusId = (int)StatusEnum.WaitingForManagerApproval;
break;
case 3:
expenseHistory.ExpenseStatusId = (int)StatusEnum.WaitingForAccountantApproval;
break;
case 4:
expenseHistory.ExpenseStatusId = (int)StatusEnum.Completed;
break;
case 5:
expenseHistory.ExpenseStatusId = (int)StatusEnum.Rejected;
expenseHistory.RejectReason = rejectReason;
break;
}
entity.SaveChanges();
entity.ExpenseHistories.Add(expenseHistory);
entity.SaveChanges();
}
public static BaseResponse CheckThenSendEmail(ExpenseAppEntities entity, BaseResponse response)
{
var managers = (from u in entity.Users
where u.UserRoleId == (int)UserRoleEnum.Manager
select u).ToList().DefaultIfEmpty();
if (managers == null)
{
response.IsSuccess = false;
return(response);
}
if (CheckIfManagerShouldBeEmailed(entity).IsNeeded)
{
foreach (var m in managers)
{
SendEmail(entity, m);
}
}
response.IsSuccess = true;
return(response);
}
public static ApprovalExpenseResponse ApproveOrRejectExpense(ExpenseApprovalRequest request)
{
ExpenseAppEntities entity = new ExpenseAppEntities();
ApprovalExpenseResponse response = new ApprovalExpenseResponse();
try
{
//to do:switch
if (request.IsApproved)
{
ApproveExpense(request, entity, response);
ExpenseHandlers.CreateExpenseHistory(request.ExpenseId, entity, request.RejectReason);
return(response);
}
else if (!request.IsApproved)
{
RejectExpense(request, entity, response);
ExpenseHandlers.CreateExpenseHistory(request.ExpenseId, entity, request.RejectReason);
return(response);
}
else
{
response.ApprovalStatus = (int)ApprovalStatusEnum.Unknown;
response.IsSuccess = false;
return(response);
}
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Approve or Reject Expense Unsuccessful", ex);
}
finally
{
entity.Dispose();
}
return(response);
}
public static LoginResponse Login(LoginRequest request)
{
ExpenseAppEntities entity = new ExpenseAppEntities();
LoginResponse response = new LoginResponse();
try
{
var user = (from u in entity.Users
where u.Email == request.Email && u.Password == request.Password
select u).SingleOrDefault();
if (user != null)
{
HttpContext.Current.Session[SessionConstants.UserId] = user.ID;
HttpContext.Current.Session[SessionConstants.UserEmail] = user.Email.ToString();
HttpContext.Current.Session[SessionConstants.UserName] = user.FullName.ToString();
HttpContext.Current.Session[SessionConstants.UserRoleId] = user.UserRoleId;
response.UserId = user.ID;
response.UserRoleId = user.UserRoleId;
response.IsSuccess = true;
}
else
{
response.IsSuccess = false;
}
}
catch (Exception ex)
{
response.IsSuccess = false;
log.Error("Login Unsuccessful", ex);
}
finally
{
entity.Dispose();
}
return(response);
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
try
{
var allowedOrigin = context.OwinContext.Get <string>("as:clientAllowedOrigin");
if (allowedOrigin == null)
{
allowedOrigin = "*";
}
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin });
// Validate your user and base on validation return claim identity or invalid_grant error
using (var _dbcontext = new ExpenseAppEntities())
{
var userInfo = _dbcontext.UserMasters.FirstOrDefault(u => u.Email == context.UserName);
if (userInfo != null && userInfo.IsActive == true)
{
byte[] saltBytes = new byte[8];
saltBytes = Convert.FromBase64String(userInfo.PasswordSalt);
if (ENCDEC.ComputeHash(context.Password, "MD5", saltBytes) == userInfo.PasswordHash)
{
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim(ClaimTypes.Name, userInfo.FirstName));
identity.AddClaim(new Claim(ClaimTypes.Role, userInfo.UserTypeMaster.Description));
identity.AddClaim(new Claim(ClaimTypes.Email, userInfo.Email));
identity.AddClaim(new Claim("UserID", userInfo.UserID.ToString()));
identity.AddClaim(new Claim("UserTypeID", userInfo.UserTypeMaster.UserTypeID.ToString()));
var props = new AuthenticationProperties(new Dictionary <string, string>
{
{
"userName", userInfo.FirstName
},
{
"role", userInfo.UserTypeMaster.Description
},
{
"UserID", userInfo.UserID.ToString()
},
{
"UserTypeID", userInfo.UserTypeID.ToString()
}
});
var ticket = new AuthenticationTicket(identity, props);
context.Validated(ticket);
}
else
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
return;
}
}
else
{
if (userInfo.IsActive == false)
{
context.SetError("Not Approved", "The user account disabled by the admin.");
}
else
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
}
return;
}
}
}
catch (Exception ex)
{
throw ex;
}
}
private static void DeleteExpense(Expense expense, ExpenseAppEntities entity)
{
entity.Expenses.Remove(expense);
entity.SaveChanges();
}
private static void UpdateExpenseItem(ExpenseItem expenseItemInDb, ExpenseItemDto expenseItemDto, ExpenseAppEntities entity)
{
expenseItemInDb.ExpenseItemDate = expenseItemDto.ExpenseItemDate;
expenseItemInDb.Description = expenseItemDto.Description;
expenseItemInDb.Amount = expenseItemDto.Amount;
entity.SaveChanges();
}
private static void DeleteExpenseItem(IEnumerable <IdDto> deletedExpenseItems, ExpenseAppEntities entity, SaveExpenseResponse response)
{
foreach (var item in deletedExpenseItems)
{
var itemInDb = (from e in entity.ExpenseItems
where e.ID == item.ID
select e).FirstOrDefault();
if (itemInDb == null)
{
response.IsSuccess = false;
return;
}
entity.ExpenseItems.Remove(itemInDb);
}
}
private static void CreateExpenseItem(Expense expenseInDb, ExpenseItemDto expenseItemDto, ExpenseAppEntities entity)
{
ExpenseItem expenseItem = new ExpenseItem();
expenseItem.ExpenseId = expenseInDb.ID;
entity.ExpenseItems.Add(expenseItem);
expenseItem.ExpenseItemDate = expenseItemDto.ExpenseItemDate;
expenseItem.Description = expenseItemDto.Description;
expenseItem.Amount = expenseItemDto.Amount;
entity.SaveChanges();
}
private static void CreateExpense(int userId, IEnumerable <ExpenseItemDto> expenseItemsDto, ExpenseAppEntities entity, SaveExpenseResponse response)
{
Expense expense = new Expense();
expense.CreatedDate = DateTime.Now;
expense.UserId = userId;
entity.Expenses.Add(expense);
entity.SaveChanges();
foreach (var item in expenseItemsDto)
{
CreateExpenseItem(expense, item, entity);
expense.TotalAmount += item.Amount;
}
expense.LastExpenseActionId = (int)StatusEnum.Ongoing;
entity.SaveChanges();
response.ExpenseId = expense.ID;
response.IsSuccess = true;
}