public ActionResult GetAmountForCategory(int MonthId)
{
var budgetRepo = new BudgetRepository(Properties.Settings.Default._connectionString);
var List = budgetRepo.CategoryListWithAmounts(MonthId);
var CategoryList = budgetRepo.GetAllCategories();
List <CategoryWithAmountForMonth> CategoriesWithAMount = new List <CategoryWithAmountForMonth>();
foreach (Category C in CategoryList)
{
CategoryWithAmountForMonth CategoryWithSum = new CategoryWithAmountForMonth();
CategoryWithSum.CategoryName = C.CategoryName;
CategoryWithSum.Sum = List.Where(D => D.Category.CategoryName == C.CategoryName).Select(D => D.Amount).Sum();
CategoriesWithAMount.Add(CategoryWithSum);
// CategoryWithSum.Sum = List.Select((D => D.Amount)).Where (D => D.am)
}
return(Json(CategoriesWithAMount.Select(C => new
{
categoryName = C.CategoryName,
amount = C.Sum
}), JsonRequestBehavior.AllowGet));
}
public ActionResult AddDebit(Debit debit)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("login", "Home"));
}
var UserRepo = new UserRepository(Properties.Settings.Default._connectionString);
var budgetRepo = new BudgetRepository(Properties.Settings.Default._connectionString);
debit.UserId = UserRepo.GetUserByEmail(User.Identity.Name).Id;
List <Debit> Debits = budgetRepo.AddDebit(debit);
// = budgetRepo.GetDebitsByMonthId(debit.UserId, debit.MonthId);
//return Json(debit);
return(Json(new
{
debits = Debits.Select(D => new
{
id = D.Id,
amount = D.Amount.ToString("C"),
date = D.Date,
category = D.Category.CategoryName,
detail = D.Details
}),
debitTotal = Debits.Sum(D => D.Amount).ToString("C")
}));
}
// GET: Budget
public ActionResult Budget()
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("login", "Home"));
}
UserRepository UserRepo = new UserRepository(Properties.Settings.Default._connectionString);
User CurrentUser = UserRepo.GetUserByEmail(User.Identity.Name);
BudgetRepository BudgetRepo = new BudgetRepository(Properties.Settings.Default._connectionString);
var BudgetModel = new BudgetViewModel();
BudgetModel.CurrentUser = BudgetRepo.UserWithHistory(CurrentUser.Id);
BudgetModel.MonthsBudgeted = BudgetRepo.MonthYearForUser(CurrentUser.Id);
BudgetModel.AllCategories = BudgetRepo.GetAllCategories();
if (BudgetModel.MonthsBudgeted.Count != 0)
{
//gets debits for last month budgeted
BudgetModel.DebitsForLatestMonth = BudgetRepo.GetDebitsByMonthId(CurrentUser.Id, BudgetModel.MonthsBudgeted[BudgetModel.MonthsBudgeted.Count - 1].Id);
BudgetModel.CreditsForLastMonth = BudgetRepo.GetCreditsByMonthId(CurrentUser.Id, BudgetModel.MonthsBudgeted[BudgetModel.MonthsBudgeted.Count - 1].Id);
BudgetModel.LatestMonth = BudgetRepo.GetMonthInfo(BudgetModel.MonthsBudgeted[BudgetModel.MonthsBudgeted.Count - 1].Id);
}
return(View(BudgetModel));
}
public void DidSaveBudget()
{
// Arrange
var accountRepositoryTester = new AccountRepositoryTester();
accountRepositoryTester.ShouldSaveAccount();
var budgetRepository = new BudgetRepository();
var budget = new Budget
{
AccountId = AccountRepositoryTester.AccountId.ToString(),
Amount = 1000,
CreatedBy = AccountRepositoryTester.Owner,
CreatedOn = DateTime.UtcNow,
CriticalThreshold = 100,
IsDeleted = false,
ModifiedBy = AccountRepositoryTester.Owner,
ModifiedOn = DateTime.UtcNow,
Name = "Food",
Id = BudgetId
};
// Act
var success = budgetRepository.SaveBudget(budget);
// Assert
Assert.True(success);
}
public HrUnitOfWork(IContextFactory <DbContext> contextFactory) // , int companyId, string culture
: base(contextFactory)
{
// Initialize
CompanyRepository = new CompanyRepository(Context); // , companyId, culture
PagesRepository = new PagesRepository(Context);
MenuRepository = new MenuRepository(Context);
PageEditorRepository = new PageEditorRepository(Context);
LookUpRepository = new LookUpRepoitory(Context);
CompanyStructureRepository = new CompanyStructureRepository(Context);
JobRepository = new JobRepository(Context);
PeopleRepository = new PeopleRepository(Context);
PositionRepository = new PositionRepository(Context);
BudgetRepository = new BudgetRepository(Context);
QualificationRepository = new QualificationRepository(Context);
LeaveRepository = new LeaveRepository(Context);
EmployeeRepository = new EmployeeRepository(Context);
CustodyRepository = new CustodyRepository(Context);
TrainingRepository = new TrainingRepository(Context);
BenefitsRepository = new BenefitsRepository(Context);
AudiTrialRepository = new AudiTrialRepository(Context);
TerminationRepository = new TerminationRepository(Context);
DisciplineRepository = new DisciplineRepository(Context);
CheckListRepository = new CheckListRepository(Context);
ComplaintRepository = new ComplaintRepository(Context);
MessageRepository = new MessageRepository(Context);
MedicalRepository = new MedicalRepository(Context);
HrLettersRepository = new HRLettersRepository(Context);
PayrollRepository = new PayrollRepository(Context);
SalaryDesignRepository = new SalaryDesignRepository(Context);
NotificationRepository = new NotificationRepository(Context);
MissionRepository = new MissionRepository(Context);
MeetingRepository = new MeetingRepository(Context);
}
/// <inheritdoc />
public override async Task <IEnumerable <BudgetCategoryBalance> > Handle(Query query, CancellationToken cancellationToken)
{
var repositoryResult = await BudgetRepository.ListAvailableBudgets();
var budget = repositoryResult.FirstOrDefault(x => x.Id == query.BudgetId);
if (budget == null)
{
throw new NotFoundException("Budget was not found");
}
switch (query.BudgetCategoryType)
{
case eBudgetCategoryType.Spending:
return(budget.SpendingCategoriesBalance);
case eBudgetCategoryType.Income:
return(budget.IncomeCategoriesBalance);
case eBudgetCategoryType.Saving:
return(budget.SavingCategoriesBalance);
default:
throw new ArgumentOutOfRangeException();
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
BudgetRepository repo = new BudgetRepository(new CityDBContext());
return(repo.GetBudgetName((int)value));
}
public Budget GetByID(Guid budgetid)
{
using (var budgetRepo = new BudgetRepository())
{
return(budgetRepo.GetById(budgetid));
}
}
/// <inheritdoc />
public override async Task <Response> Handle(Request request, CancellationToken cancellationToken)
{
var availableBudgets = await BudgetRepository.ListAvailableBudgets();
var budgetToUpdate = availableBudgets.FirstOrDefault(x => x.Id != request.BudgetId);
if (budgetToUpdate == null)
{
throw new NotFoundException("Budget was not found");
}
if (budgetToUpdate.BudgetShares.Any(x => x.SharedWithUserId == request.UserId))
{
throw new SaveFailureException("Budget share is already created", request);
}
var shareEntity = Mapper.Map <BudgetShare>(request);
await _budgetShareRepository.AddAsync(shareEntity);
await _budgetShareRepository.SaveChangesAsync(cancellationToken);
return(new Response()
{
Data = new Unit()
});
}
public void TestBudgetRepositoryReturnsValue()
{
BudgetRepository rep = new BudgetRepository(_ctx);
string testBudgetName = rep.GetBudgetName(1);
Assert.IsTrue(testBudgetName == "TestBudget");
}
/// <inheritdoc />
public override async Task <Response> Handle(Command command, CancellationToken cancellationToken)
{
var availableBudgets = await BudgetRepository.ListAvailableBudgets();
var budgetEntity = availableBudgets.FirstOrDefault(x => x.Id == command.BudgetId);
if (budgetEntity == null)
{
throw new NotFoundException("Budget was not found");
}
budgetEntity.Name = command.Name;
budgetEntity.CurrencyCode = command.Currency.CurrencyCode;
budgetEntity.OwnedByUserId = command.OwnedByUserId;
await BudgetRepository.UpdateAsync(budgetEntity);
await BudgetRepository.SaveChangesAsync(cancellationToken);
_ = _mediator.Publish(new Notification()
{
BudgetId = budgetEntity.Id,
}, cancellationToken);
return(new Response()
{
Data = new Unit()
});
}
public BudgetController(BudgetRepository budgetRepo, ExpenseRepository expenseRepo, BudgetConceptRepository conceptRepo, ExpenseGroupRepository groupRepo)
{
this.budgetRepo = budgetRepo;
this.expenseRepo = expenseRepo;
this.conceptRepo = conceptRepo;
this.groupRepo = groupRepo;
}
/// <inheritdoc />
public override async Task <Response> Handle(Command command, CancellationToken cancellationToken)
{
var budgetEntity = Mapper.Map <Domain.Entities.Budget>(command);
budgetEntity.OwnedByUserId = AuthenticationProvider.User.UserId;
var savedBudget = await BudgetRepository.AddAsync(budgetEntity);
var addedRows = await BudgetRepository.SaveChangesAsync(cancellationToken);
if (addedRows.IsNullOrDefault())
{
throw new SaveFailureException(nameof(budgetEntity), budgetEntity);
}
var dto = Mapper.Map <BudgetDto>(savedBudget);
_ = _mediator.Publish(new Notification()
{
BudgetId = dto.BudgetId,
}, cancellationToken);
return(new Response()
{
Data = dto
});
}
public void Update(Budget budget)
{
BudgetRepository budgetRepo = new BudgetRepository(_db);
budget.NewModifyTimeStamp();
budgetRepo.Update(budget);
budgetRepo.Save();
}
public ImportService(
BudgetRepository budgetRepository,
LaunchRepository launchRepository
)
{
this.budgetRepository = budgetRepository;
this.launchRepository = launchRepository;
}
public void ShouldGetBudget()
{
DidSaveBudget();
var budgetRepository = new BudgetRepository();
var budget = budgetRepository.GetBudget(AccountRepositoryTester.AccountId.ToString(), BudgetId.ToString());
Assert.NotNull(budget);
Assert.Equal(budget.Id, BudgetId);
}
public Payment GetRawPaymentByID(string paymentid)
{
Payment payment;
List <BudgetTransaction> transactions = new List <BudgetTransaction>();
using (PaymentRepository paymentRepo = new PaymentRepository())
{
payment = paymentRepo.GetById(paymentid);
if (payment == null)
{
throw new Exception("ไม่พบข้อมูลการเบิกจ่ายที่เลือก");
}
}
//var manager = new BudgetTransactionManager();
//payment.BudgetTransactions = manager.SumTransaction(payment.BudgetTransactions.ToList());
payment.BudgetTransactions = payment.BudgetTransactions.Where(t => t.Status == RecordStatus.Active).ToList();
//Get budget data
using (BudgetRepository budgetRepo = new BudgetRepository())
{
payment.BudgetTransactions.ToList().ForEach(t => t.Budget = budgetRepo.GetById(t.BudgetID));
payment.BudgetTransactions = payment.BudgetTransactions.OrderBy(t => t.Budget.AccountID).ToList();
}
foreach (var item in payment.BudgetTransactions)
{
List <BudgetTransaction> listTransInBudget = item.Budget.BudgetTransactions
.Where(t => t.Status == RecordStatus.Active && t.CreatedAt < item.CreatedAt).ToList();
item.PreviousAmount = 0;
listTransInBudget.ForEach(t => item.PreviousAmount += t.Amount);
item.RemainAmount = item.Budget.BudgetAmount - item.PreviousAmount - item.Amount;
}
// Get Controller name for printing
using (EmployeeRepository empRepo = new EmployeeRepository())
{
try
{
var controllerby = empRepo.GetById(payment.CreatedBy);
if (controllerby != null)
{
payment.CreatedBy = payment.CreatedBy + " - " + controllerby.FullName;
}
}
catch (Exception ex)
{
payment.CreatedBy = "ไม่พบข้อมูล";
}
}
return(payment);
}
public string CalculateBudget(double income, double expenses)
{
BudgetRepository budgetRepo = new BudgetRepository();
double calculatedBudget = budgetRepo.CalculateDisposableIncome(Income, Expenses);
return("\nDit rådighedsbeløb er: " + calculatedBudget);
//Console.WriteLine("\nDit rådighedsbeløb er: " + calculatedBudget);
}
public void ShouldGetBudgets()
{
DidSaveBudget();
var budgetRepository = new BudgetRepository();
var budgets = budgetRepository.GetBudgets(AccountRepositoryTester.AccountId.ToString());
Assert.NotNull(budgets);
Assert.True(budgets.Any());
Assert.True(budgets.Any(b => b.Id == BudgetId));
}
/// <inheritdoc />
public override async Task <Response> Handle(Query request, CancellationToken cancellationToken)
{
if (!await BudgetRepository.IsAccessibleToUser(request.BudgetId))
{
throw new NotFoundException("Budget was not found");
}
var budgetEntity = await BudgetRepository.GetByIdAsync(request.BudgetId);
var categoryReports = budgetEntity.BudgetCategories
.Select(x => new BudgetCategoryReport(x, request.DateStart, request.DateEnd))
.ToList();
var reportDto = new MonthlyBudgetReportDto();
reportDto.BudgetCategoryReports = categoryReports.Select(x => new BudgetCategoryMonthlyReportDto()
{
BudgetCategoryId = x.Category.Id,
BudgetCategoryType = x.Category.Type,
MonthlyReports = x.MonthByMonth
.Data
.Select(t => new MonthReportDto()
{
Month = new Month()
{
MonthNumber = t.Month,
Year = t.Year
},
ReportData = new ReportDataDto()
{
AllocationsSum = t.AllocationsSum,
AveragePerDay = t.AveragePerDay,
TransactionsSum = t.TransactionsSum
}
})
})
.ToList();
reportDto.TotalMonthlyReports = reportDto.BudgetCategoryReports
.SelectMany(x => x.MonthlyReports)
.GroupBy(x => x.Month)
.Select(t => new MonthReportDto()
{
Month = t.Key,
ReportData = new ReportDataDto()
{
AllocationsSum = t.Sum(g => g.ReportData.AllocationsSum),
TransactionsSum = t.Sum(g => g.ReportData.TransactionsSum),
AveragePerDay = t.Sum(g => g.ReportData.AveragePerDay)
}
});
return(new Response()
{
Data = reportDto
});
}
/// <inheritdoc />
public override async Task <Response> Handle(Query request, CancellationToken cancellationToken)
{
var repositoryResult = await BudgetRepository.ListAvailableBudgets();
var data = Mapper.Map <IEnumerable <BudgetDto> >(repositoryResult);
return(new Response()
{
Data = data
});
}
private void ShowBudget()
{
Console.Clear();
BudgetRepository budgetRepo = new BudgetRepository();
Console.Write("Skriv navnet på det budget du vil hente: ");
string path = Console.ReadLine();
budgetRepo.LoadBudget(path);
Console.ReadKey();
}
public void SaveBudget()
{
BudgetRepository budgetRepo = new BudgetRepository();
Console.WriteLine("Vil du gemme dit budget? Y/N");
string save = Console.ReadLine();
if (save is "y" || save is "Y")
{
budgetRepo.SaveBudget(incomeColumn, expenseColumn, Income, Expenses);
Console.ReadKey();
}
public ActionResult Budget(string id, string year, string costcenterid)
{
if (id == null)
{
return(Budgets(year, costcenterid));
}
try
{
Budget budget;
using (BudgetRepository budgetRep = new BudgetRepository())
{
budget = budgetRep.GetById(id);
if (budget == null)
{
throw new Exception("ไม่พบข้อมูลงบประมาณที่เลือก");
}
}
//budget.BudgetTransactions = budget.BudgetTransactions.Where(t => t.Status == RecordStatus.Active).OrderBy(t => t.CreatedAt).ToList();
//decimal previousAmount = 0;
//decimal total = 0;
//foreach (var item in budget.BudgetTransactions)
//{
// using (var paymentRepo = new PaymentRepository())
// {
// item.Payment = paymentRepo.GetById(item.PaymentID);
// }
// total += item.Amount;
// item.PreviousAmount = previousAmount;
// item.RemainAmount = budget.BudgetAmount - item.PreviousAmount - item.Amount;
// previousAmount = item.Amount + item.PreviousAmount;
//}
//budget.WithdrawAmount = total;
//budget.RemainAmount = budget.BudgetAmount - budget.WithdrawAmount;
var bm = new BudgetManager();
budget = bm.GetWithTransaction(id);
returnobj.SetSuccess(budget);
}
catch (Exception ex)
{
returnobj = new ReturnObject(false, ex.Message, null);
}
return(Content(Utility.ParseToJson(returnobj), "application/json"));
}
public HomeViewModel()
{
App.Database.SeedsAsync();
expenseRep = new ExpenseRepository();
budgetRep = new BudgetRepository();
SetBudgetCommand = new Command(async() =>
{
var budget = new Budget();
budget.MonthlyBudget = Convert.ToDouble(TheBudgetValue);
budget.Date = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
await budgetRep.SaveBudgetAsync(budget);
});
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
EventAggregator eventAggregator = new EventAggregator();
FormReportMain reportForm = new FormReportMain(eventAggregator, null);
OutputLogger logger = new OutputLogger();
ExcelOutput excelOutput = new ExcelOutput(eventAggregator, logger);
excelOutput.Connect();
ImportImpl import = new ImportImpl();
IFileDialog fileDialog = new WinFormDialog();
var categoryJsonSerializer = new JsonSerializer <CategoryCollection>();
var categoryFileSerializer = new FileSerializer <CategoryCollection>(categoryJsonSerializer);
var optionsJsonSerializer = new JsonSerializer <Options>();
var optionsFileSerializer = new FileSerializer <Options>(optionsJsonSerializer);
TransactionReportCollection reports = new TransactionReportCollection();
var reportsJsonSerializer = new JsonSerializer <TransactionReportCollection>();
var reportsFileSerializer = new FileSerializer <TransactionReportCollection>(reportsJsonSerializer);
Options options = new Options()
{
CategoryPath = @"..\..\..\Budget.UnitTests\Resources\categories_new_16.bgt"/*,
* DocumentPath = @"..\..\..\Budget.UnitTests\Resources\Raport_Listopad_2016.rpt"*/
};
IBudgetRepository fileData = new BudgetRepository();
fileData.Categories = new FileRepository <CategoryCollection>(categoryFileSerializer, fileDialog);
fileData.Options = new FileRepository <Options>(options, optionsFileSerializer, fileDialog);
fileData.Reports = new FileRepository <TransactionReportCollection>(reports, reportsFileSerializer,
fileDialog);
AppEngine engine = new AppEngine(excelOutput, eventAggregator, reportForm, import, fileData);
Application.Run(reportForm);
}
public UnitOfWork(AppDbContext context)
{
_dbContext = context;
Countries = new CountryRepository(context);
BudgetHeads = new BudgetHeadRepository(context);
CostCodes = new CostCodeRepository(context);
Currencies = new CurrencyRepository(context);
Divisions = new DivisionRepository(context);
Budgets = new BudgetRepository(context);
Employees = new EmployeeRepository(context);
Vendors = new VendorRepository(context);
NumberingSequences = new NumberingSequenceRepository(context);
BudgetCategories = new BudgetCategoriesRepository(context);
Departments = new DepartmentRepository(context);
}
public void ShouldUpdateBudget()
{
DidSaveBudget();
var budgetRepository = new BudgetRepository();
var budget = budgetRepository.GetBudget(AccountRepositoryTester.AccountId.ToString(), BudgetId.ToString());
budget.TransactionLimit = 1000;
var result = budgetRepository.SaveBudget(budget);
var budgetAfterUpdate = budgetRepository.GetBudget(AccountRepositoryTester.AccountId.ToString(), BudgetId.ToString());
Assert.True(result);
Assert.Equal(decimal.Parse("1000"), budgetAfterUpdate.TransactionLimit);
}
/// <inheritdoc />
public override async Task <Response> Handle(Query request, CancellationToken cancellationToken)
{
var repositoryResult = await BudgetRepository.ListAvailableBudgets();
var budget = repositoryResult.FirstOrDefault(x => x.Id == request.BudgetId);
if (budget == null)
{
throw new NotFoundException("Budget was not found");
}
return(new Response()
{
Data = budget.UnassignedFunds()
});
}
/// <inheritdoc />
public override async Task <Response> Handle(Query request, CancellationToken cancellationToken)
{
if (!await BudgetRepository.IsAccessibleToUser(request.BudgetId))
{
throw new NotFoundException("Budget was not found");
}
var repositoryResult = await BudgetRepository.GetByIdAsync(request.BudgetId);
var dto = Mapper.Map <BudgetDto>(repositoryResult);
return(new Response()
{
Data = dto
});
}
