public IActionResult GetFiltered(string filter)
{
var filteredList = taskBLL.getFilteredTasks(filter);
IList <Task> Result = ModelToDto.DTOToModel(filteredList);
return(Ok(Result));
}
public IActionResult Sort(string sort)
{
var sortedList = taskBLL.getSortedTasks(sort);
IList <Task> Result = ModelToDto.DTOToModel(sortedList);
return(Ok(Result));
}
public void TimesheetToDTO_Should_ReturnValidDTO()
{
var mockTimesheet = CreateMockTimesheet();
var sut = ModelToDto.TimesheetToDto(mockTimesheet);
Assert.AreEqual(sut.Id, 1);
Assert.AreEqual(sut.Date, _sampleDate);
Assert.AreEqual(sut.UserId, _sampleUserId);
Assert.AreEqual(sut.Rows.Count(), 2);
Assert.AreEqual(sut.Rows.ElementAt(0).Id, 1);
Assert.AreEqual(sut.Rows.ElementAt(1).Id, 2);
Assert.AreEqual(sut.Rows.ElementAt(0).RateTypeId, 1);
Assert.AreEqual(sut.Rows.ElementAt(1).RateTypeId, 2);
Assert.AreEqual(sut.Rows.ElementAt(0).TimesheetId, 1);
Assert.AreEqual(sut.Rows.ElementAt(1).TimesheetId, 1);
Assert.AreEqual(sut.Rows.ElementAt(0).Days.Count(), 2);
Assert.AreEqual(sut.Rows.ElementAt(1).Days.Count(), 2);
Assert.AreEqual(sut.Rows.ElementAt(0).Days.ElementAt(0).Date, _sampleDate);
Assert.AreEqual(sut.Rows.ElementAt(0).Days.ElementAt(1).Date, _sampleDate);
Assert.AreEqual(sut.Rows.ElementAt(1).Days.ElementAt(0).Date, _sampleDate);
Assert.AreEqual(sut.Rows.ElementAt(1).Days.ElementAt(1).Date, _sampleDate);
Assert.AreEqual(sut.Rows.ElementAt(0).Days.ElementAt(0).ReportedHours, 8);
Assert.AreEqual(sut.Rows.ElementAt(0).Days.ElementAt(1).ReportedHours, 7);
Assert.AreEqual(sut.Rows.ElementAt(1).Days.ElementAt(0).ReportedHours, 8);
Assert.AreEqual(sut.Rows.ElementAt(1).Days.ElementAt(1).ReportedHours, 7);
}
public IActionResult getPagination(int pageNumber, int pageSize)
{
var FilteredLIstList = taskBLL.getPagination(pageNumber, pageSize);
IEnumerable <Task> Result = ModelToDto.DTOToModel(FilteredLIstList);
return(Ok(Result));
}
public async Task <ActionResult <TimesheetDTO> > PostTimesheet(TimesheetDTO timesheet)
{
var user = await _userManager.FindByNameAsync(User?.Identity?.Name);
if (user != null)
{
timesheet.UserId = user.Id;
}
var isTimesheetForValidMonth = !_context.Timesheet.Any(t => t.Date.Year.Equals(timesheet.Date.Year) && t.Date.Month.Equals(timesheet.Date.Month) && t.UserId.Equals(user.Id));
if (!isTimesheetForValidMonth)
{
return(BadRequest(new { Message = "Timesheet for selected month already exists!" }));
}
var timesheetObj = DtoToModel.DtoToTimesheet(timesheet);
var validStates = States.GetStatesValues();
if (!validStates.Contains(timesheet.State))
{
return(BadRequest("Provided status does not exist!"));
}
await _context.Timesheet.AddAsync(timesheetObj);
await _context.SaveChangesAsync();
var dto = ModelToDto.TimesheetToDto(timesheetObj);
return(CreatedAtAction("GetTimesheet", new { id = timesheet.Id }, dto));
}
public IActionResult getSearchResult(string searchString)
{
var FilteredLIstList = taskBLL.getSearchResult(searchString);
IEnumerable <Task> Result = ModelToDto.DTOToModel(FilteredLIstList);
return(Ok(Result));
}
public IActionResult GetTodoModels()
{
var tasksList = taskBLL.getTasks();
IList <Task> Result = ModelToDto.DTOToModel(tasksList);
return(Ok(Result));
}
public IActionResult Get()
{
//NO AUTH
var response = JsonConvert.SerializeObject(ModelToDto.ConvertMovieList(context.Movies.ToList()));
return(Ok(response));
}
public async Task <ActionResult <InvoiceSettingsDTO> > GetUserInvoiceSettings()
{
var currentUser = await _userManager.FindByNameAsync(User?.Identity?.Name);
var invoiceSettings = await _context.UserInvoiceSettings.Where(settings => settings.UserId.Equals(currentUser.Id)).FirstOrDefaultAsync();
var dtos = ModelToDto.InvoiceSettingsToDTO(invoiceSettings);
return(dtos);
}
public async Task <IEnumerable <UserRateAmountDTO> > GetUserRateAmount()
{
var currentUser = await _userManager.FindByNameAsync(User?.Identity?.Name);
var rateAmounts = _context.UserRateAmount.Include(rateAmount => rateAmount.RateType)
.Where(rateAmount => rateAmount.UserId.Equals(currentUser.Id)).ToList();
var dtos = ModelToDto.RateAmountsToDtos(rateAmounts);
return(dtos);
}
public void RateAmountsToDTOs_Should_ReturnValidDTOCollection()
{
var mockRateAmounts = CreateMockRateAmounts();
var sut = ModelToDto.RateAmountsToDtos(mockRateAmounts).ToList();
Assert.AreEqual(sut.Count, 2);
Assert.AreEqual(sut.ElementAt(0).RateAmount, 200);
Assert.AreEqual(sut.ElementAt(1).RateAmount, 239);
Assert.AreEqual(sut.ElementAt(0).RateName, "Test Rate Type");
Assert.AreEqual(sut.ElementAt(1).RateName, "Test Rate Type");
}
public void TimesheetsToDTOs_Should_ReturnValidDTOCollection()
{
var mockTimesheet1 = CreateMockTimesheet();
var mockTimesheet2 = CreateMockTimesheet();
var timesheetsCollection = new List <Timesheet> {
mockTimesheet1, mockTimesheet2
};
var sut = ModelToDto.TimesheetsToDtos(timesheetsCollection);
Assert.AreEqual(sut.Count(), 2);
}
public IActionResult PostTodoModels(taskViewModel taskItem)
{
Task postedTask = new Task()
{
Title = taskItem.Title,
TimeLeft = TimeSpan.Parse(taskItem.TimeLeft)
};
SHARED.ViewModals.Task postData = ModelToDto.ModelToDTO(postedTask);
SHARED.ViewModals.Task result = taskBLL.PostTasks(postData);
return(Created("", result));
}
public IActionResult PutTodoModel(int id, taskViewModel todoModel)
{
Task editedTask = new Task()
{
TaskId = todoModel.TaskId,
Title = todoModel.Title,
TimeLeft = TimeSpan.Parse(todoModel.TimeLeft),
IsCompleted = todoModel.IsCompleted,
IsDeleted = todoModel.IsDeleted,
IsExpired = todoModel.IsExpired
};
SHARED.ViewModals.Task editdata = ModelToDto.ModelToDTO(editedTask);
SHARED.ViewModals.Task tasksItem = taskBLL.EditTasks(id, editdata);
return(Created("", tasksItem));
}
public async Task <ActionResult <InvoiceDataDTO> > PostInvoice(InvoiceDTO invoice)
{
var user = await _userManager.FindByNameAsync(User?.Identity?.Name);
if (user == null)
{
return(Forbid());
}
var isInvoiceValid = !_context.Invoice.Any(i => i.TimesheetId.Equals(invoice.TimesheetId)) &&
_context.Timesheet.Any(t =>
t.Id.Equals(invoice.TimesheetId) && t.State.Equals(Const.States.Closed));
if (!isInvoiceValid)
{
return(BadRequest(new { Message = "Cannot create new invoice for provided timesheet!" }));
}
var invoiceTimesheet = await _context.Timesheet.FindAsync(invoice.TimesheetId);
var invoiceObj = DtoToModel.DtoToInvoice(invoice);
invoiceObj.InvoiceNumber = $"1/{invoiceTimesheet.Date.Month}/{invoiceTimesheet.Date.Year}";
invoiceObj.UserId = user.Id;
await _context.Invoice.AddAsync(invoiceObj);
await _context.SaveChangesAsync();
var obj = _context.Invoice.Include(i => i.Timesheet).Include(i => i.Timesheet.Rows)
.First(i => i.Id.Equals(invoiceObj.Id));
var invoiceSettings = await _context.UserInvoiceSettings.FirstAsync(settings => settings.UserId.Equals(user.Id));
var invoiceSettingsDto = ModelToDto.InvoiceSettingsToDTO(invoiceSettings);
var rateTypes = _context.RateTypes.ToList();
var userRateAmounts = _context.UserRateAmount.Where(amount => amount.UserId.Equals(user.Id)).ToList();
var dto = ModelToDto.InvoiceToDto(obj, invoiceSettingsDto, rateTypes, userRateAmounts);
return(dto);
}
public async Task <IEnumerable <TimesheetDTO> > GetTimesheet([FromQuery] string state)
{
var currentUser = await _userManager.FindByNameAsync(User?.Identity?.Name);
List <Timesheet> timesheets;
if (!string.IsNullOrEmpty(state) && state.Equals(States.Closed))
{
timesheets = _context.Timesheet.Include(timesheet => timesheet.Rows).Where(timesheet => timesheet.UserId.Equals(currentUser.Id) && timesheet.State.Equals(States.Closed)).ToList();
}
else
{
timesheets = _context.Timesheet.Include(timesheet => timesheet.Rows).Where(timesheet => timesheet.UserId.Equals(currentUser.Id)).ToList();
}
var dtos = ModelToDto.TimesheetsToDtos(timesheets);
return(dtos);
}
public void InvoiceSettingsToDTO_Should_ReturnValidDTO()
{
var mockUserInvoiceSettings = CreateMockUserInvoiceSettings();
var sut = ModelToDto.InvoiceSettingsToDTO(mockUserInvoiceSettings);
Assert.AreEqual(mockUserInvoiceSettings.BuyerAddressLine1, sut.BuyerAddressLine1);
Assert.AreEqual(mockUserInvoiceSettings.BuyerAddressLine2, sut.BuyerAddressLine2);
Assert.AreEqual(mockUserInvoiceSettings.BuyerName, sut.BuyerName);
Assert.AreEqual(mockUserInvoiceSettings.BuyerPhone, sut.BuyerPhone);
Assert.AreEqual(mockUserInvoiceSettings.BuyerTaxId, sut.BuyerTaxId);
Assert.AreEqual(mockUserInvoiceSettings.IssuedBy, sut.IssuedBy);
Assert.AreEqual(mockUserInvoiceSettings.SellerAccountNumber, sut.SellerAccountNumber);
Assert.AreEqual(mockUserInvoiceSettings.SellerAddressLine1, sut.SellerAddressLine1);
Assert.AreEqual(mockUserInvoiceSettings.SellerAddressLine2, sut.SellerAddressLine2);
Assert.AreEqual(mockUserInvoiceSettings.SellerBankName, sut.SellerBankName);
Assert.AreEqual(mockUserInvoiceSettings.SellerEmail, sut.SellerEmail);
Assert.AreEqual(mockUserInvoiceSettings.SellerName, sut.SellerName);
Assert.AreEqual(mockUserInvoiceSettings.SellerTaxId, sut.SellerTaxId);
}
public async Task <ActionResult <TimesheetDTO> > GetTimesheet(int id)
{
var timesheet = await _context.Timesheet.FindAsync(id);
if (timesheet == null)
{
return(NotFound());
}
var currentUser = await _userManager.FindByNameAsync(User?.Identity?.Name);
var isCorrectUser = _context.Timesheet.Any(t => t.Id == id && t.UserId == currentUser.Id);
if (!isCorrectUser)
{
return(Forbid());
}
var dto = ModelToDto.TimesheetToDto(timesheet);
return(dto);
}
public void InvoiceToDTO_Should_ReturnValidInvoiceDataDTO()
{
var invoice = CreateMockInvoice();
var invoiceSettingsDto = CreateMockUserInvoiceSettingsDTO();
var rateTypes = CreateMockRateTypeCollection().ToList();
var rateAmounts = CreateMockRateAmountsForRateTypes(rateTypes).ToList();
var sut = ModelToDto.InvoiceToDto(invoice, invoiceSettingsDto, rateTypes, rateAmounts);
Assert.AreEqual("1", sut.Id);
Assert.AreEqual("Wroclaw", sut.IssuedPlace);
Assert.AreEqual(invoice.InvoiceNumber, sut.InvoiceNumber);
Assert.AreEqual(invoice.TimesheetId.ToString(), sut.TimesheetId);
Assert.AreEqual(_sampleDate.Month.ToString(), sut.InvoiceForMonth);
Assert.AreEqual(_sampleDate.Year.ToString(), sut.InvoiceForYear);
Assert.AreEqual("23%", sut.TaxRate);
Assert.AreEqual("6000", sut.SummaryNetAmount);
Assert.AreEqual("1380", sut.SummaryTaxAmount);
Assert.AreEqual("7380", sut.SummaryGrossAmount);
Assert.AreEqual(_sampleDate.AddDays(30).ToShortDateString(), sut.PayToDate);
Assert.AreEqual(_sampleDate.ToShortDateString(), sut.IssuedDate);
Assert.AreEqual(invoiceSettingsDto.IssuedBy, sut.IssuedBy);
Assert.AreSame(invoiceSettingsDto, sut.InvoiceSettings);
}
public void TimesheetsToDTOs_WhenPassedEmptyArgument_Should_ReturnEmptyDTOCollection()
{
var sut = ModelToDto.TimesheetsToDtos(new List <Timesheet>());
Assert.AreEqual(sut.Count(), 0);
}
public IActionResult Get()
{
var response = JsonConvert.SerializeObject(ModelToDto.ConvertGenreList(context.Genres.ToList()));
return(Ok(response));
}
