public async Task <ActionResult> Edit(VacationDto dto)
{
try
{
if (ModelState.IsValid)
{
_vacationDao.Edit(dto);
if (User.IsEditAllowed(dto))
{
await _vacationDao.SaveAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
ModelState.AddModelError("", Resources.EditNotAllowed);
}
}
}
catch (DbUpdateConcurrencyException dcex)
{
_logger.Error(dcex, "Error in VacationController.Edit(id={0})", dto.ID);
ModelState.AddModelError("", Resources.OptimisticConcurrencyError);
}
catch (Exception ex)
{
_logger.Error(ex, "Error in VacationController.Edit(id={0})", dto.ID);
ModelState.AddModelError("", ex.GetInnerMessage());
}
return(View(dto));
}
public async Task CreateTransactionByVacationAsync(VacationDto vacation, ClaimsPrincipal user)
{
var balance = (int)vacation.EndVocationDate.Subtract(vacation.StartVocationDate).TotalDays;
if (balance <= 0)
{
throw new ArgumentOutOfRangeException("Start Date >= End Date");
}
var transacrion = new Transaction()
{
TransactionId = new Guid(),
TransactionTypeId = _context.TransactionType.FirstOrDefault(t => t.Name == "ByVacation").TransactionTypeId,
EmployeeId = vacation.EmployeeId,
Days = -balance,
Comment = vacation.TransactionComment,
AuthorId = (await _usersService.GetUserAsync(user)).EmployeeId,
VacationId = vacation.VacationId,
TransactionDate = DateTime.UtcNow
};
var employee = _context.Employee.Find(vacation.EmployeeId);
employee.Balance += transacrion.Days;
await _context.Transaction.AddAsync(transacrion);
_context.Employee.Update(employee);
await _context.SaveChangesAsync();
}
public Customer RegisterVacation(VacationDto vacation)
{
Tuple <Payment, int> registered = paymentService.RegisterVacation(vacation);
Payment payment = registered.Item1;
int newVacationDays = registered.Item2;
Customer customer = FindById(payment.IdCustomer);
customer.PaymentList.OrderBy(x => x.PeriodStartDate);
bool adjustDates = false;
customer.PaymentList.ForEach(pay =>
{
if (adjustDates)
{
pay.PeriodStartDate = pay.PeriodStartDate.AddDays(newVacationDays);
pay.ExpectedDate = pay.ExpectedDate.AddDays(newVacationDays);
}
if (pay.Id == payment.Id)
{
adjustDates = true;
}
if (adjustDates)
{
pay.PeriodEndDate = pay.PeriodEndDate.AddDays(newVacationDays);
}
});
Save(customer);
return(customer);
}
public VacationDto GetVacationData()
{
var dateDepart = DepartureDatePicker.Date;
DateTime departureTime = dateDepart.Value.DateTime;
var dateReturn = ReturnDatePicker.Date;
DateTime returnTime = dateReturn.Value.DateTime;
var newVac = new VacationDto()
{
AddedOn = DateTime.Now, Name = TxtVacationName.Text, Locations = Locations.Select(loc => new VacationLocationDto
{
CityName = loc.CityName,
DateDeparture = loc.DateDeparture,
VacationLocationId = loc.VacationLocationId,
AddedOn = loc.AddedOn,
CountryName = loc.CountryName,
DateArrival = loc.DateArrival,
}).ToList(),
DateDeparture = departureTime, DateReturn = returnTime
};
return(newVac);
}
public async Task PutAsync(VacationDto vacationDto, ClaimsPrincipal user)
{
if (vacationDto.VacationStatusId == null)
{
throw new ArgumentException("");
}
var vacation = new Vacation
{
VacationId = vacationDto.VacationId,
StartVocationDate = vacationDto.StartVocationDate,
EndVocationDate = vacationDto.EndVocationDate,
VacationStatusId = vacationDto.VacationStatusId ?? new Guid(),
VacationTypesId = vacationDto.VacationTypesId,
Comment = vacationDto.Comment,
EmployeeId = vacationDto.EmployeeId,
};
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
_context.Vacation.Update(vacation);
if (vacation.VacationStatusId == _vacationStatusService.Get().FirstOrDefault(vs => vs.Name == "Approved").VacationStatusId)
{
await _transactionService.CreateTransactionByVacationAsync(vacationDto, user);
}
await _context.SaveChangesAsync();
scope.Complete();
}
await VacationStatusSendEmail(vacationDto, (await _context.Employee.FirstOrDefaultAsync(e => e.EmployeeId == vacation.EmployeeId)).WorkEmail);
}
public async Task <ActionResult> Create(VacationDto dto)
{
try
{
if (ModelState.IsValid)
{
dto.EmployeeOwnerID = User.GetUserId();
_vacationDao.Add(dto);
if (User.IsEditAllowed(dto))
{
await _vacationDao.SaveAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
ModelState.AddModelError("", Resources.EditNotAllowed);
}
}
}
catch (Exception ex)
{
_logger.Error(ex, "Error in VacationController.Create");
ModelState.AddModelError("", ex.GetInnerMessage());
}
return(View(dto));
}
public СomparisonResult ProjectsVacationMatches(VacationDto dto, Guid vacationId)
{
var currentDeveloper = _unitOfWork.GetRepository <Developer>().Where(x => x.Id == dto.DeveloperId).FirstOrDefault();
IEnumerable <VacationDto> vacations = List().Where(v => v.DeveloperId != dto.DeveloperId);
if (vacationId != Guid.Empty)
{
vacations = vacations.Where(x => x.Id != vacationId);
}
foreach (var vacation in vacations)
{
if (DateHelper.DatesIntersect(dto.StartDate, dto.EndDate, vacation.StartDate, vacation.EndDate))
{
var developer = _unitOfWork.GetRepository <Developer>().Where(x => x.Id == vacation.DeveloperId).Include(p => p.Projects).FirstOrDefault();
if (currentDeveloper.Projects.Any(l => developer.Projects.Select(s => s.Id).Contains(l.Id)))
{
СomparisonResult result = new СomparisonResult {
developerId = developer.Id,
vacationId = vacation.Id
};
return(result);
}
}
}
return(null);
}
private async Task VacationStatusSendEmail(VacationDto vacation, string email)
{
var callbackUrl =
$"{_configuration["Domain:RequestScheme"]}://{_configuration["Domain:DomainName"]}/profile";
await _emailSender.SendEmailAsync(email, "Vacation Status Updated",
$"Your vacation with {vacation.StartVocationDate} - {vacation.EndVocationDate} has been {vacation.VacationStatusName}." +
$"<a href='{callbackUrl}'>https://btangular.azurewebsites.net/profile</a>");
}
private async Task VacationRequestSendEmail(VacationDto vacation, string email)
{
var callbackUrl =
$"{_configuration["Domain:RequestScheme"]}://{_configuration["Domain:DomainName"]}/vacation-requests";
await _emailSender.SendEmailAsync(email, "New Vacation Request",
$"You have new vacation request from {vacation.EmployeeName} {vacation.EmployeeSurname}." +
$"<a href='{callbackUrl}'>https://btangular.azurewebsites.net/profile</a>");
}
public async Task <VacationDto> CreateVacation(VacationDto vacation, CancellationToken?cancellationToken = null)
{
var responce = await Post <ApiResponceDto <VacationDto> >(ControllerUrl, ToStringContent(vacation), cancellationToken);
ThrowApiExceptionIfNeeded(responce);
return(responce.Result);
}
public string Post(VacationDto vacation)
{
vacation.CreateTime = DateTime.Now;
vacation.NID = Guid.NewGuid().ToString();
var model = EmitCore.Convert <VacationDto, Vacation>(vacation);
vacationService.Insert(model);
return(CommonMethods.Start(vacation.NID, "001001", vacation.UID, String.Format("{0}请假{1}天", vacation.Name, vacation.Day)));
}
public async Task VacationDetails()
{
VacationController controller = DependencyResolver.Current.GetService <VacationController>();
ViewResult result = await controller.Details(1) as ViewResult;
VacationDto model = result.Model as VacationDto;
Assert.IsTrue(model.EmployeeID == 1);
}
public async Task VacationEdit()
{
VacationController controller = DependencyResolver.Current.GetService <VacationController>();
VacationDto model = await EditVacation(controller);
model.DateTo = model.DateTo.Value.AddDays(1);
ActionResult result = await controller.Edit(model);
Assert.IsTrue(result is RedirectToRouteResult);
}
public async Task VacationEditMergeAndDelete()
{
VacationController controller = DependencyResolver.Current.GetService <VacationController>();
VacationDto model = await EditVacation(controller, 4);
model.EmployeeFirstName = "First1";
model.EmployeeLastName = "Last1";
ActionResult result = await controller.Edit(model);
Assert.IsTrue(result is RedirectToRouteResult);
}
public async Task VacationDelete()
{
VacationController controller = DependencyResolver.Current.GetService <VacationController>();
ViewResult getResult = await controller.Delete(3) as ViewResult;
VacationDto model = getResult.Model as VacationDto;
ActionResult postResult = await controller.Delete(model);
Assert.IsTrue(postResult is RedirectToRouteResult);
}
public async Task PutAsync(VacationDto vacationDto, ClaimsPrincipal user)
{
if (vacationDto.VacationStatusId == null)
{
throw new ArgumentException("");
}
var vacation = new Vacation
{
VacationId = vacationDto.VacationId,
StartVocationDate = vacationDto.StartVocationDate,
EndVocationDate = vacationDto.EndVocationDate,
VacationStatusId = vacationDto.VacationStatusId ?? new Guid(),
VacationTypesId = vacationDto.VacationTypesId,
Comment = vacationDto.Comment,
EmployeeId = vacationDto.EmployeeId,
};
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
_context.Vacation.Update(vacation);
if (vacation.VacationStatusId == _vacationStatusService.Get().FirstOrDefault(vs => vs.Name == "Approved").VacationStatusId)
{
await _transactionService.CreateTransactionByVacationAsync(vacationDto, user);
}
await _context.SaveChangesAsync();
scope.Complete();
}
var workEmail = (await _context.Employee
.Include(t => t.Team.TeamLead)
.Select(
e => new
{
e.Team.TeamLead.WorkEmail,
e.EmployeeId
}
).FirstOrDefaultAsync(e => e.EmployeeId == vacationDto.EmployeeId)).WorkEmail;
if (workEmail == null)
{
foreach (var item in await _userManager.GetUsersInRoleAsync("Admin"))
{
await VacationRequestSendEmail(vacationDto, item.Email);
}
}
else
{
await VacationRequestSendEmail(vacationDto, workEmail);
}
}
//Date comparison
public bool DeveloperVacationMatches(VacationDto dto, Guid vacationId)
{
bool isMatch = List().Where(x => x.Id != vacationId && dto.DeveloperId == x.DeveloperId).Any(v
=> DateHelper.DatesIntersect(dto.StartDate, dto.EndDate, v.StartDate, v.EndDate));
if (isMatch)
{
return(true);
}
return(false);
}
public ActionResult <CustomerDto> RegisterVacation([FromBody] VacationDto vacation)
{
try
{
return(Ok(GetDto(Service.RegisterVacation(vacation))));
}
catch (SgException e)
{
return(HandleError(e));
}
}
public async Task <VacationDto> UpsertVacationAsync(VacationDto vacation, CancellationToken token = default)
{
token.ThrowIfCancellationRequested();
if (vacation.Id == Guid.Empty.ToString())
{
vacation.Created = DateTime.MinValue;
}
var response = await _context.PostAsync <VacationDto, BaseResultOfSingleVacationRequest>(string.Empty, vacation, token);
return(response.Result);
}
public static VacationCellViewModel ToVacationCellViewModel(this VacationDto vacationDto)
{
var vacationViewModel = new VacationCellViewModel
{
Id = vacationDto.Id,
Start = vacationDto.Start,
End = vacationDto.End,
Status = vacationDto.VacationStatus,
Type = vacationDto.VacationType
};
return(vacationViewModel);
}
public static VacationDto ToVacationDto(this VacationCellViewModel viewModel)
{
var vacationDto = new VacationDto
{
Id = viewModel.Id,
Start = viewModel.Start,
End = viewModel.End,
VacationStatus = viewModel.Status,
CreatedBy = "string",
VacationType = viewModel.Type
};
return(vacationDto);
}
public async Task <string> PostAsync(VacationDto vacation)
{
vacation.CreateTime = DateTime.Now;
vacation.NID = Guid.NewGuid().ToString();
var model = _mapper.Map <VacationDto, Vacation>(vacation);
_vacationService.Persistent(model);
return(await _workflowService.StartAsync(new Brigde
{
CategoryCode = "001001",
Key = vacation.NID,
Creator = vacation.UID
}));
}
public async Task VacationEditTestDateConstraint()
{
VacationController controller = DependencyResolver.Current.GetService <VacationController>();
VacationDto model = await EditVacation(controller);
DateTime?dateFrom = model.DateFrom;
model.DateFrom = model.DateTo;
model.DateTo = dateFrom;
ViewResult result = await controller.Edit(model) as ViewResult;
Assert.IsNotNull(result);
Assert.IsFalse(controller.ModelState.IsValid);
}
public VacationDto GetExampleVacation()
{
var vacation = new VacationDto
{
VacationStatus = VacationStatus.Approved,
Id = Guid.NewGuid(),
VacationType = VacationType.Undefined,
CreatedBy = "Ark",
End = DateTime.UtcNow,
Start = DateTime.UtcNow
};
return(vacation);
}
private static VacationDto GenerateNewVacation(Guid id)
{
var newVacation = new VacationDto
{
Id = id,
CreateDate = DateTime.Now,
CreatedBy = "new-vacation",
End = DateTime.Now.AddDays(2),
Start = DateTime.Now,
VacationStatus = VacationStatus.Closed,
VacationType = VacationType.Overtime
};
return(newVacation);
}
public async Task VacationEditTestDateTrigger()
{
VacationController controller = DependencyResolver.Current.GetService <VacationController>();
VacationDto model1 = await EditVacation(controller);
VacationDto model2 = await EditVacation(controller, 2);
Assert.IsTrue(model1.EmployeeID == model2.EmployeeID);
model2.DateFrom = model1.DateFrom;
ViewResult result = await controller.Edit(model2) as ViewResult;
Assert.IsNotNull(result);
Assert.IsFalse(controller.ModelState.IsValid);
}
public async Task VacationEditTestConcurrency()
{
VacationController controller = DependencyResolver.Current.GetService <VacationController>();
VacationDto model = await EditVacation(controller);
model.DateTo = model.DateTo.Value.AddDays(1);
ActionResult result1 = await controller.Edit(model);
Assert.IsTrue(result1 is RedirectToRouteResult);
ViewResult result2 = await controller.Edit(model) as ViewResult;
Assert.IsNotNull(result2);
Assert.IsFalse(controller.ModelState.IsValid);
}
public async Task VacationCreateForExistingEmployee()
{
VacationController controller = DependencyResolver.Current.GetService <VacationController>();
VacationDto dto = new VacationDto
{
EmployeeFirstName = "First1",
EmployeeLastName = "Last1",
DateFrom = new DateTime(2018, 6, 4),
DateTo = new DateTime(2018, 6, 7),
VacationType = VacationTypeKind.VacationLeave,
};
ActionResult result = await controller.Create(dto);
Assert.IsTrue(result is RedirectToRouteResult);
}
public ServiceResult Create(VacationDto dto)
{
string message = CheckDates(dto);
if (string.IsNullOrWhiteSpace(message))
{
Vacation entity = new Vacation();
entity = _mapper.Map <Vacation>(dto);
_unitOfWork.GetRepository <Vacation>().Add(entity);
_unitOfWork.Commit();
message = "Vacation successfully added.";
return(ServiceResult.Ok(message));
}
return(ServiceResult.Fail(message));
}
public async Task <VacationViewModel> AddAsync(VacationDto vacationDto)
{
var user = _httpContext.GetUserUsingClaimsOrThrow(_urlopikDbContext);
ValidateVactionTypeOrThrow(vacationDto.TypeId);
var vacation = _mapper.Map <Vacation>(vacationDto);
vacation.VacationerId = user.Id;
vacation.HrAccepted = user.Role == Roles.Hr;
await _urlopikDbContext.AddAsync(vacation);
await _urlopikDbContext.SaveChangesAsync();
return(_mapper.Map <VacationViewModel>(vacation));
}
