public HttpResponseMessage Edit([FromBody] Models.Category category)
{
try
{
if (category == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ""));
}
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
Models.Category updatedCategory = new Models.Category();
DB.Models.Category existingCategory = context.Categories.Where(x => x.CategoryID == category.CategoryID).FirstOrDefault();
if (existingCategory != null)
{
existingCategory.TransactionTypeID = category.TransactionTypeID;
existingCategory.CategoryName = category.CategoryName;
existingCategory.Sequence = category.Sequence;
existingCategory.CreatedDate = DateTime.Now;
context.SaveChanges();
updatedCategory = context.Categories.Where(x => x.CategoryID == category.CategoryID).Select(x => new Models.Category()
{
CategoryID = x.CategoryID,
TransactionTypeID = x.TransactionTypeID,
CategoryName = x.CategoryName,
Sequence = x.Sequence,
CreatedDate = x.CreatedDate
}).FirstOrDefault();
}
APIResponse <Models.Category> apiResponse = new APIResponse <Models.Category>()
{
StatusCode = (int)(updatedCategory == null ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK),
StatusRemark = "",
Content = (updatedCategory ?? null),
};
return(Request.CreateResponse((updatedCategory == null ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK), apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public HttpResponseMessage Create([FromBody] Models.SubCategory subCategory)
{
try
{
if (subCategory == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ""));
}
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
DB.Models.SubCategory newSubCategory = new DB.Models.SubCategory
{
SubCategoryID = subCategory.SubCategoryID,
CategoryID = subCategory.CategoryID,
SubCategoryName = subCategory.SubCategoryName,
Sequence = subCategory.Sequence,
CreatedDate = DateTime.Now
};
context.SubCategories.Add(newSubCategory);
context.SaveChanges();
Models.SubCategory createdSubCategory = context.SubCategories.Where(x => x.SubCategoryID == newSubCategory.SubCategoryID).Select(x => new Models.SubCategory()
{
SubCategoryID = x.SubCategoryID,
CategoryID = x.CategoryID,
SubCategoryName = x.SubCategoryName,
Sequence = x.Sequence,
CreatedDate = x.CreatedDate
}).FirstOrDefault();
APIResponse <Models.SubCategory> apiResponse = new APIResponse <Models.SubCategory>()
{
StatusCode = (int)(createdSubCategory == null ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK),
StatusRemark = "",
Content = (createdSubCategory ?? null),
};
return(Request.CreateResponse((createdSubCategory == null ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK), apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public HttpResponseMessage Edit([FromBody] Models.Account account)
{
try
{
if (account == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ""));
}
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
Models.Account updatedAccount = new Models.Account();
DB.Models.Account existingAccount = context.Accounts.Where(x => x.AccountID == account.AccountID).FirstOrDefault();
if (existingAccount != null)
{
existingAccount.AccountTypeID = account.AccountTypeID;
existingAccount.AccountName = account.AccountName;
existingAccount.CreatedDate = DateTime.Now;
context.SaveChanges();
updatedAccount = context.Accounts.Where(x => x.AccountID == account.AccountID).Select(x => new Models.Account()
{
AccountID = x.AccountID,
AccountTypeID = x.AccountTypeID,
AccountName = x.AccountName,
CreatedDate = x.CreatedDate
}).FirstOrDefault();
}
APIResponse <Models.Account> apiResponse = new APIResponse <Models.Account>()
{
StatusCode = (int)(updatedAccount == null ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK),
StatusRemark = "",
Content = (updatedAccount ?? null),
};
return(Request.CreateResponse((updatedAccount == null ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK), apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public HttpResponseMessage GetCategories(string transactionTypeID = "")
{
try
{
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
Guid gTransactionTypeID = Guid.Empty;
if (transactionTypeID != null && transactionTypeID.Trim().Length > 0)
{
gTransactionTypeID = Guid.Parse(transactionTypeID);
}
List <Models.Category> categories = context.Categories.Include(x => x.TransactionType)
.Where(x =>
(
transactionTypeID == null ||
transactionTypeID.Trim().Length == 0 ||
gTransactionTypeID == Guid.Empty ||
x.TransactionTypeID == gTransactionTypeID
)
)
.OrderBy(x => x.Sequence).Select(x => new Models.Category()
{
CategoryID = x.CategoryID,
TransactionTypeID = x.TransactionTypeID,
TransactionTypeName = x.TransactionType.TransactionTypeName,
CategoryName = x.CategoryName,
Sequence = x.Sequence,
CreatedDate = x.CreatedDate
}).ToList();
APIResponse <List <Models.Category> > apiResponse = new APIResponse <List <Models.Category> >
{
StatusCode = (int)HttpStatusCode.OK,
StatusRemark = "",
Content = categories
};
return(Request.CreateResponse(HttpStatusCode.OK, apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public HttpResponseMessage Delete([FromBody] Models.SubCategory subCategory)
{
try
{
if (subCategory == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ""));
}
bool result = false;
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
DB.Models.SubCategory foundSubCategory = context.SubCategories.Where(x => x.SubCategoryID == subCategory.SubCategoryID).FirstOrDefault();
if (foundSubCategory != null)
{
context.SubCategories.Remove(foundSubCategory);
context.SaveChanges();
result = true;
}
else
{
result = false;
}
APIResponse <bool> apiResponse = new APIResponse <bool>()
{
StatusCode = (int)(!result ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK),
StatusRemark = "",
Content = result,
};
return(Request.CreateResponse((!result ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK), apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public HttpResponseMessage GetAccounts()
{
try
{
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
List <Models.Account> accounts = context.Accounts.Include(x => x.AccountType).OrderBy(x => x.AccountType.AccountTypeName).ThenBy(x => x.AccountName).Select(x => new Models.Account()
{
AccountID = x.AccountID,
AccountTypeID = x.AccountTypeID,
AccountTypeName = x.AccountType.AccountTypeName,
AccountName = x.AccountName,
CreatedDate = x.CreatedDate
}).ToList();
APIResponse <List <Models.Account> > apiResponse = new APIResponse <List <Models.Account> >
{
StatusCode = (int)HttpStatusCode.OK,
StatusRemark = "",
Content = accounts
};
return(Request.CreateResponse(HttpStatusCode.OK, apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public HttpResponseMessage GetSubCategories()
{
try
{
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
List <Models.SubCategory> subCategories = context.SubCategories.Select(x => new Models.SubCategory()
{
SubCategoryID = x.SubCategoryID,
CategoryID = x.CategoryID,
SubCategoryName = x.SubCategoryName,
Sequence = x.Sequence,
CreatedDate = x.CreatedDate
}).OrderBy(x => x.Sequence).ToList();
APIResponse <List <Models.SubCategory> > apiResponse = new APIResponse <List <Models.SubCategory> >
{
StatusCode = (int)HttpStatusCode.OK,
StatusRemark = "",
Content = subCategories
};
return(Request.CreateResponse(HttpStatusCode.OK, apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public void InitAccountTypeTable()
{
using (var context = new EMContext())
{
foreach (KeyValuePair <Guid, string> entry in AccountTypes)
{
AccountType foundAccountType = context.AccountTypes.Where(x => x.AccountTypeName == entry.Value).FirstOrDefault();
if (foundAccountType == null)
{
context.AccountTypes.Add(new AccountType()
{
AccountTypeID = entry.Key,
AccountTypeName = entry.Value
});
context.SaveChanges();
}
}
}
}
public HttpResponseMessage GetTransactionTypes()
{
try
{
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
List <Models.TransactionType> transactionTypes = context.TransactionTypes.Select(x => new Models.TransactionType()
{
TransactionTypeID = x.TransactionTypeID,
TransactionTypeName = x.TransactionTypeName
}).ToList();
APIResponse <List <Models.TransactionType> > apiResponse = new APIResponse <List <Models.TransactionType> >
{
StatusCode = (int)HttpStatusCode.OK,
StatusRemark = "",
Content = transactionTypes
};
return(Request.CreateResponse(HttpStatusCode.OK, apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
void Application_Start(object sender, EventArgs e)
{
// Code that runs on application startup
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);
//Database.SetInitializer(new DropCreateDatabaseIfModelChanges<EMContext>());
using (var context = new EMContext())
{
context.Database.Initialize(true);
}
InitAccountType initAccountType = new InitAccountType();
InitTransactionType initTransactionType = new InitTransactionType();
initAccountType.InitAccountTypeTable();
initTransactionType.InitTransactionTypeTable();
}
public VIPController(EMContext context)
{
_context = context;
}
public DogadjajController(EMContext context)
{
_context = context;
}
public KomentarController(EMContext context)
{
_context = context;
}
public HttpResponseMessage Delete(string id)
{
try
{
if (id == null || (id != null && id.Trim().Length == 0))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ""));
}
bool result = false;
string error = string.Empty;
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
Guid accountID = Guid.Parse(id);
DB.Models.Transaction foundTransaction = context.Transactions.Where(x => x.FromAccountID == accountID || x.ToAccountID == accountID).FirstOrDefault();
if (foundTransaction == null)
{
DB.Models.Account foundAccount = context.Accounts.Where(x => x.AccountID == accountID).FirstOrDefault();
if (foundAccount != null)
{
context.Accounts.Remove(foundAccount);
context.SaveChanges();
result = true;
}
else
{
result = false;
}
}
else
{
result = false;
error = "Error, found that this account in used in transaction.";
}
APIResponse <bool> apiResponse = new APIResponse <bool>()
{
StatusCode = (int)(!result ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK),
StatusRemark = error,
Content = result,
};
return(Request.CreateResponse((!result ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK), apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public SistemController(EMContext context)
{
_context = context;
}
public NacinPlacanjaController(EMContext context)
{
_context = context;
}
public RezervacijaController(EMContext context)
{
_context = context;
}
public EmployeeController(EMContext _db)
{
db = _db;
}
public HttpResponseMessage Update([FromBody] Models.Transaction transaction)
{
try
{
if (transaction == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ""));
}
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
DB.Models.Transaction existingTransaction = context.Transactions.Include(x => x.FromTransaction).Include(x => x.TransactionType).Where(x => x.TransactionID == transaction.TransactionID).FirstOrDefault();
DB.Models.TransactionType transactionType = context.TransactionTypes.Where(x => x.TransactionTypeID == transaction.TransactionTypeID).FirstOrDefault();
if (existingTransaction != null && transactionType != null)
{
DB.Models.Transaction foundTransaction = new DB.Models.Transaction();
Models.Transaction createdTransaction = new Models.Transaction();
switch (transactionType.TransactionTypeName)
{
case "Income":
existingTransaction.TransactionTypeID = transaction.TransactionTypeID;
existingTransaction.FromAccountID = transaction.FromAccountID;
existingTransaction.CategoryID = transaction.CategoryID;
existingTransaction.Operator = true;
existingTransaction.TransactionDate = transaction.TransactionDate;
existingTransaction.TransactionTime = transaction.TransactionTime;
existingTransaction.Amount = transaction.Amount;
existingTransaction.Note = transaction.Note;
existingTransaction.CreatedDate = DateTime.Now;
if (transaction.SubCategoryID != null && transaction.SubCategoryID != Guid.Empty)
{
existingTransaction.SubCategoryID = transaction.SubCategoryID;
}
else
{
existingTransaction.SubCategoryID = null;
}
context.SaveChanges();
foundTransaction = context.Transactions.Where(x => x.TransactionID == existingTransaction.TransactionID).FirstOrDefault();
context.Entry(foundTransaction).Reference(x => x.FromAccount).Load();
context.Entry(foundTransaction).Reference(x => x.Category).Load();
if (transaction.SubCategoryID != null && transaction.SubCategoryID != Guid.Empty)
{
context.Entry(foundTransaction).Reference(x => x.SubCategory).Load();
}
createdTransaction = new Models.Transaction
{
TransactionID = foundTransaction.TransactionID,
TransactionTypeID = foundTransaction.TransactionTypeID,
FromAccountID = foundTransaction.FromAccountID,
CategoryID = foundTransaction.CategoryID,
SubCategoryID = foundTransaction.SubCategoryID,
Operator = foundTransaction.Operator,
TransactionDate = foundTransaction.TransactionDate,
TransactionTime = foundTransaction.TransactionTime,
Amount = foundTransaction.Amount,
Note = foundTransaction.Note,
CreatedDate = foundTransaction.CreatedDate
};
break;
case "Expense":
existingTransaction.TransactionTypeID = transaction.TransactionTypeID;
existingTransaction.FromAccountID = transaction.FromAccountID;
existingTransaction.CategoryID = transaction.CategoryID;
existingTransaction.Operator = false;
existingTransaction.TransactionDate = transaction.TransactionDate;
existingTransaction.TransactionTime = transaction.TransactionTime;
existingTransaction.Amount = transaction.Amount;
existingTransaction.Note = transaction.Note;
existingTransaction.CreatedDate = DateTime.Now;
if (transaction.SubCategoryID != null && transaction.SubCategoryID != Guid.Empty)
{
existingTransaction.SubCategoryID = transaction.SubCategoryID;
}
else
{
existingTransaction.SubCategoryID = null;
}
context.SaveChanges();
foundTransaction = context.Transactions.Where(x => x.TransactionID == existingTransaction.TransactionID).FirstOrDefault();
context.Entry(foundTransaction).Reference(x => x.FromAccount).Load();
context.Entry(foundTransaction).Reference(x => x.Category).Load();
if (transaction.SubCategoryID != null && transaction.SubCategoryID != Guid.Empty)
{
context.Entry(foundTransaction).Reference(x => x.SubCategory).Load();
}
createdTransaction = new Models.Transaction
{
TransactionID = foundTransaction.TransactionID,
TransactionTypeID = foundTransaction.TransactionTypeID,
FromAccountID = foundTransaction.FromAccountID,
CategoryID = foundTransaction.CategoryID,
SubCategoryID = foundTransaction.SubCategoryID,
Operator = foundTransaction.Operator,
TransactionDate = foundTransaction.TransactionDate,
TransactionTime = foundTransaction.TransactionTime,
Amount = foundTransaction.Amount,
Note = foundTransaction.Note,
CreatedDate = foundTransaction.CreatedDate
};
break;
case "Transfer":
existingTransaction.TransactionTypeID = transaction.TransactionTypeID;
existingTransaction.FromAccountID = transaction.FromAccountID;
existingTransaction.ToAccountID = transaction.ToAccountID;
existingTransaction.Operator = false;
existingTransaction.TransactionDate = transaction.TransactionDate;
existingTransaction.TransactionTime = transaction.TransactionTime;
existingTransaction.Amount = transaction.Amount;
existingTransaction.Note = transaction.Note;
existingTransaction.CreatedDate = DateTime.Now;
context.SaveChanges();
DB.Models.Transaction existingToTransaction = context.Transactions.Where(x => x.FromTransactionID == existingTransaction.TransactionID).FirstOrDefault();
if (existingToTransaction != null)
{
existingToTransaction.TransactionTypeID = transaction.TransactionTypeID;
existingToTransaction.FromAccountID = transaction.ToAccountID ?? Guid.Empty;
existingToTransaction.ToAccountID = transaction.FromAccountID;
existingToTransaction.Operator = true;
existingToTransaction.TransactionDate = transaction.TransactionDate;
existingToTransaction.TransactionTime = transaction.TransactionTime;
existingToTransaction.Amount = transaction.Amount;
existingToTransaction.Note = transaction.Note;
existingToTransaction.CreatedDate = DateTime.Now;
context.SaveChanges();
}
foundTransaction = context.Transactions.Where(x => x.TransactionID == existingTransaction.TransactionID).FirstOrDefault();
context.Entry(foundTransaction).Reference(x => x.FromAccount).Load();
context.Entry(foundTransaction).Reference(x => x.ToAccount).Load();
createdTransaction = new Models.Transaction
{
TransactionID = foundTransaction.TransactionID,
TransactionTypeID = foundTransaction.TransactionTypeID,
FromAccountID = foundTransaction.FromAccountID,
ToAccountID = foundTransaction.ToAccountID,
Operator = foundTransaction.Operator,
TransactionDate = foundTransaction.TransactionDate,
TransactionTime = foundTransaction.TransactionTime,
Amount = foundTransaction.Amount,
Note = foundTransaction.Note,
CreatedDate = foundTransaction.CreatedDate
};
break;
default:
return(Request.CreateResponse(HttpStatusCode.BadRequest, ""));
}
APIResponse <Models.Transaction> apiResponse = new APIResponse <Models.Transaction>()
{
StatusCode = (int)(createdTransaction == null ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK),
StatusRemark = "",
Content = (createdTransaction ?? null),
};
return(Request.CreateResponse((createdTransaction == null ? HttpStatusCode.ExpectationFailed : HttpStatusCode.OK), apiResponse));
}
return(Request.CreateResponse(HttpStatusCode.ExpectationFailed, ""));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public FileRepository(EMContext emcontext) : base(emcontext)
{
_emcontext = emcontext;
}
public UstanovaController(EMContext context)
{
_context = context;
}
public TipFizickogLicaController(EMContext context)
{
_context = context;
}
public HttpResponseMessage GetReportsByDate(string startDate = "", string endDate = "", string transactionTypeID = "")
{
try
{
using (var context = new EMContext())
{
context.Configuration.LazyLoadingEnabled = false;
DateTime firstDate = new DateTime(int.Parse(startDate.Substring(0, 4)), int.Parse(startDate.Substring(5, 2)), int.Parse(startDate.Substring(8, 2)));
DateTime lastDate = new DateTime(int.Parse(endDate.Substring(0, 4)), int.Parse(endDate.Substring(5, 2)), int.Parse(endDate.Substring(8, 2)));
Guid gTransactionTypeID = Guid.Parse(transactionTypeID);
Guid gAccountID = Guid.Empty;
List <Models.Transaction> transactions = context.Transactions
.Include(x => x.TransactionType)
.Include(x => x.FromAccount)
.Include(x => x.ToAccount)
.Include(x => x.Category)
.Where(x => (
x.TransactionDate >= firstDate &&
x.TransactionDate <= lastDate
) &&
(
transactionTypeID == null ||
transactionTypeID.Trim().Length == 0 ||
gTransactionTypeID == Guid.Empty ||
x.TransactionTypeID == gTransactionTypeID
)
)
.OrderByDescending(x => x.TransactionDate).ThenBy(x => x.TransactionTime)
.Select(x => new Models.Transaction()
{
TransactionID = x.TransactionID,
TransactionTypeID = x.TransactionTypeID,
TransactionTypeName = x.TransactionType.TransactionTypeName,
FromAccountID = x.FromAccountID,
FromAccountName = x.FromAccount.AccountName,
ToAccountID = x.ToAccountID,
ToAccountName = x.ToAccount.AccountName,
CategoryID = x.CategoryID,
CategoryName = x.Category.CategoryName,
Operator = x.Operator,
TransactionDate = x.TransactionDate,
TransactionTime = x.TransactionTime,
Amount = x.Amount,
Note = x.Note,
CreatedDate = x.CreatedDate
}).ToList();
List <Report> reports = transactions.GroupBy(x => new { x.CategoryID, x.CategoryName }).Select(x => new Report
{
CategoryID = x.Key.CategoryID ?? Guid.Empty,
CategoryName = x.Key.CategoryName,
Amount = x.Sum(y => y.Amount)
}).ToList();
decimal total = reports.Sum(x => x.Amount);
foreach (Report report in reports)
{
report.Percentage = report.Amount * 100 / total;
report.Transactions = transactions.Where(x => x.CategoryID == report.CategoryID).ToList();
}
APIResponse <List <Models.Report> > apiResponse = new APIResponse <List <Models.Report> >
{
StatusCode = (int)HttpStatusCode.OK,
StatusRemark = "",
Content = reports
};
return(Request.CreateResponse(HttpStatusCode.OK, apiResponse));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
if (HttpContext.Current.IsDebuggingEnabled)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ""));
}
}
}
public ArhivaKorisnikaFLController(EMContext context)
{
_context = context;
}
public MessageRepository(EMContext emcontext) : base(emcontext)
{
_emcontext = emcontext;
}
public FizickoLiceController(EMContext context)
{
_context = context;
}
public KorisnikController(EMContext context)
{
_context = context;
}
public ArhivaDogadjajaController(EMContext context)
{
_context = context;
}
public CourseRepository(EMContext emcontext) : base(emcontext)
{
_emcontext = emcontext;
}
public ResumeRepository(EMContext emcontext) : base(emcontext)
{
_emcontext = emcontext;
}
