public void Update(HolidayRequest request)
{
var holidayRequestEntity = _mapper.Map <HolidayRequestEntity>(request);
// attach to DbContext and save
_database[holidayRequestEntity.Number] = holidayRequestEntity;
}
public void findSuggestions(HolidayRequest holidayRequest)
{
currentRequest = holidayRequest;
suggesstionConfirmedButton.Visible = false;
this.Cursor = Cursors.WaitCursor;
SuggestionsComponent suggestions = new SuggestionsComponent(currentRequest.UserID
, new DateRange(currentRequest.StartDate, currentRequest.EndDate), currentRequest.User.RemainingDays);
label1.ForeColor = Color.Black;
label1.Text = "Generating Suggestions. Please wait";
List <DateRange> suggestionsFound = suggestions.getSuggestions();
if (suggestionsFound.Count == 0)
{
label1.Text = "No suggestions found";
label1.ForeColor = Color.Red;
suggesstionConfirmedButton.Visible = false;
}
else
{
label1.Text = "Please select one suggestion";
foreach (var suggestion in suggestionsFound)
{
string[] arr = new string[4];
arr[0] = suggestion.StartDate.ToShortDateString();
arr[1] = suggestion.EndDate.ToShortDateString();
ListViewItem item = new ListViewItem(arr);
suggestionsListView.Items.Add(item);
}
}
this.Cursor = Cursors.Default;
}
public static async Task DoTest()
{
var daysOffManager = new DaysOffManager();
var notifier = new Notifier();
var repository = new HolidayRequestRepository(daysOffManager, notifier);
var holidayRequest = new HolidayRequest(new TimeSpan(1, 0, 0, 0), notifier, daysOffManager);
var holidayRequestNumber = holidayRequest.Number;
repository.Create(holidayRequest);
holidayRequest.SendToBoss();
repository.Update(holidayRequest);
var anotherHolidayRequest = await repository.GetBy(holidayRequestNumber);
anotherHolidayRequest.Accept();
repository.Update(anotherHolidayRequest);
var finalHolidayRequest = await repository.GetBy(holidayRequestNumber);
finalHolidayRequest.Finish();
repository.Update(finalHolidayRequest);
var finalFinalHolidayRequest = await repository.GetBy(holidayRequestNumber);
Console.WriteLine(finalFinalHolidayRequest.HolidayRequestStatus.GetType().Name);
}
public Composer(HolidayRequest request, IComposerConfig config)
{
_request = request;
_config = config;
ValidateRequest();
}
public IActionResult SubmitRequest(HolidaysViewModel holidaysViewModel)
{
base.CheckForLogin();
if (ModelState.IsValid)
{
bool approved = false;
if (new UserRepository(new UserSQLContext()).GetUser(Convert.ToInt32(HttpContext.Session.GetInt32("id"))).Role.Rights.Any(f => f.Id == 8))
{
approved = true;
}
if (holidaysViewModel.DateStart != DateTime.MinValue && holidaysViewModel.DateEnd != DateTime.MinValue && holidaysViewModel.DateStart < holidaysViewModel.DateEnd && !string.IsNullOrEmpty(holidaysViewModel.Description))
{
HolidayRequest holidayRequest = new HolidayRequest(Convert.ToInt32(HttpContext.Session.GetInt32("id")), (DateTime)holidaysViewModel.DateStart, (DateTime)holidaysViewModel.DateEnd, holidaysViewModel.Description, approved);
new UserRepository(new UserSQLContext()).AddHolidayRequest(holidayRequest);
ConfirmHoliday();
}
else
{
WrongHoliday();
}
}
UserRepository userRep = new UserRepository(new UserSQLContext());
holidaysViewModel.HasApproveHolidayRight = (userRep.GetUser(Convert.ToInt32(HttpContext.Session.GetInt32("id"))).Role.Rights.Any(f => f.Id == 8) ? true : false);
holidaysViewModel.AllholidayRequests = userRep.GetAllHolidayRequests();
holidaysViewModel.UnapprovedholidayRequests = userRep.GetUnapprovedHolidayRequests();
holidaysViewModel.UserholidayRequests = userRep.GetUserHolidayRequests(Convert.ToInt32(HttpContext.Session.GetInt32("id")));
return(View("Holidays", holidaysViewModel));
}
public void Create(HolidayRequest request)
{
var holidayRequestEntity = _mapper.Map <HolidayRequestEntity>(request);
// attach to DbContext and save
_database.Add(request.Number, holidayRequestEntity);
}
public async Task <bool> AddRequestAsync(HolidayRequest request)
{
_context.HolidayRequests.Add(request);
int additions = await _context.SaveChangesAsync();
return(additions > 0);
}
public async Task <IActionResult> Create([Bind("HolidayRequestId,StartDate,EndDate,Type,NoOfDaysLeft")] HolidayRequestCreateEditViewModel holidayRequest)
{
if (HolidayRequestService.GetNumberOfWorkingDays(holidayRequest.StartDate, holidayRequest.EndDate) >
(holidayRequest.NoOfDaysLeft))
{
ModelState.AddModelError(string.Empty, "Number of Holidays requested is bigger than available days.");
}
var usersHolidays = await GetUsersHolidays();
if (HolidayRequestService.CheckIfUserHasHolidayRequestInPeriod(usersHolidays, holidayRequest.StartDate, holidayRequest.EndDate))
{
ModelState.AddModelError(string.Empty, $"There are holidays between {holidayRequest.StartDate.ToString("dd/MM/yyyy")} and {holidayRequest.EndDate.ToString("dd/MM/yyyy")}. Please re-enter");
}
if (ModelState.IsValid)
{
var dbHolidayRequest = new HolidayRequest();
dbHolidayRequest.Employee = _context.Users.FirstOrDefault(x => x.UserName == User.Identity.Name);
dbHolidayRequest.ModifiedDate = DateTime.Now;
dbHolidayRequest.Status = Constants.Status.Pending;
dbHolidayRequest.StartDate = holidayRequest.StartDate;
dbHolidayRequest.EndDate = holidayRequest.EndDate;
dbHolidayRequest.Type = holidayRequest.Type;
dbHolidayRequest.NoOfDays = HolidayRequestService.GetNumberOfWorkingDays(holidayRequest.StartDate, holidayRequest.EndDate);
_context.Add(dbHolidayRequest);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(holidayRequest));
}
public static bool isOverlappingHoliday(HolidayRequest existing, HolidayRequest newAdded)
{
return(existing.EndDate > DateTime.Now &&
((existing.EndDate >= newAdded.StartDate && existing.EndDate <= newAdded.EndDate) ||
(existing.StartDate <= newAdded.EndDate && existing.StartDate >= newAdded.StartDate) ||
(existing.StartDate <= newAdded.StartDate && existing.EndDate >= newAdded.EndDate)));
}
protected void submitHolidayRequest(object sender, EventArgs e)
{
DateTime startDate = startDateCalendar.SelectedDate;
DateTime endDate = endDateCalendar.SelectedDate;
int workingDays = GeneralUtils.CalculateWorkingDays(startDate, endDate);
startDate = GeneralUtils.simplifyStartDate(startDate);
endDate = GeneralUtils.simplifyEndDate(endDate);
if (workingDays == 0)
{
displayHolidaySummary("You selected weekend days, no need for holiday allowance", GeneralUtils.DANGER_COLOR);
return;
}
else if (workingDays > GeneralUtils.MAX_POSSIBLE_HOLIDAY)
{
displayHolidaySummary("Too many days selected, it exceeds the maximum allowance", GeneralUtils.DANGER_COLOR);
return;
}
if (startDate.Year > DateTime.Now.Year || endDate.Year > DateTime.Now.Year)
{
displayHolidaySummary("Sorry, not accepting holiday requests for next year yet", GeneralUtils.DANGER_COLOR);
return;
}
try
{
using (HBSModel _entity = new HBSModel())
{
int userId = (int)Session["userId"];
HolidayRequest holidayRequest = new HolidayRequest()
{
StartDate = startDate,
EndDate = endDate,
UserID = userId,
NumberOfDays = workingDays
};
var usr = _entity.Users.Find(userId);
if (usr.HolidayRequests.Where(x => x.StatusRequest.Status == GeneralUtils.APPROVED ||
x.StatusRequest.Status == GeneralUtils.PENDING)
.Any(x => GeneralUtils.isOverlappingHoliday(x, holidayRequest)))
{
displayHolidaySummary("There is an overlap with your current pending or approved requests", GeneralUtils.DANGER_COLOR);
return;
}
holidayRequest.RequestStatusID = _entity.StatusRequests
.FirstOrDefault(status => status.Status == GeneralUtils.PENDING).ID;
holidayRequest.ConstraintsBroken = new ConstraintChecking(usr, holidayRequest).getBrokenConstraints();
holidayRequest.DaysPeakTime = PrioritiseRequests
.daysFallPeakTimesCount(holidayRequest.StartDate, holidayRequest.EndDate);
_entity.HolidayRequests.Add(holidayRequest);
_entity.SaveChanges();
Response.Redirect("/EmployeeHome?HolidayRequest=Success");
}
}
catch
{
Response.Write("Server encountered an issue while submitting your request");
}
}
public ActionResult Save(HolidayRequest holidayRequest)
{
bool status = false;
if (ModelState.IsValid)
{
if (holidayRequest.Id > 0)
{
//Edit
var holiday = db.Holidays.FirstOrDefault(h => h.Id == holidayRequest.Id);
if (holiday != null)
{
holiday.Day = holidayRequest.Day;
holiday.Title = holidayRequest.Title;
}
}
else
{
var holiday = new Holiday
{
Day = holidayRequest.Day,
Title = holidayRequest.Title
};
//Save
db.Holidays.Add(holiday);
}
status = true;
db.SaveChanges();
}
return(new JsonResult {
Data = new { status = status }
});
}
public ConstraintChecking(User user, HolidayRequest holidayRequest)
{
entity = new HBSModel();
this.holidayRequest = holidayRequest;
this.user = user;
usersFromDepartment = entity.Users.Where(x => x.DepartmentID == user.DepartmentID && x.id != user.id).ToList();
}
public ConstraintChecking(int userId, DateTime holidayStartDate, DateTime holidayEndDate)
{
entity = new HBSModel();
this.holidayRequest = entity.HolidayRequests
.FirstOrDefault(x => x.EndDate == holidayEndDate && x.StartDate == holidayStartDate && x.UserID == userId);
this.user = entity.Users.Find(userId);
usersFromDepartment = entity.Users.Where(x => x.DepartmentID == user.DepartmentID && x.id != user.id).ToList();
}
public void DefaultRequestInterval_ThrowsException()
{
var employee = GetEmployee("firstName", "lastName");
var request = new HolidayRequest(employee, employee, new TimeInterval());
new Composer(request, GetConfig());
}
public void ToIntervalLowerThanFromDate_ThrowsException()
{
var now = DateTime.Now;
var employee = GetEmployee("firstName", "lastName");
var request = new HolidayRequest(employee, employee, new TimeInterval {
From = now, To = now.AddDays(-1)
});
new Composer(request, GetConfig());
}
public async Task <HolidayRequest> GetBy(string number)
{
var holidayRequestEntity = await GetHolidayRequestEntityBy(number);
var holidayRequest = new HolidayRequest(holidayRequestEntity.HolidayPeriod, _notifier, _daysOffManager);
_mapper.Map(holidayRequestEntity, holidayRequest);
await Task.Yield(); // can do awesome async stuff here
return(holidayRequest);
}
public JsonResult Delete(long id)
{
HolidayRequest request = _context.HolidayRequest
.Include(b => b.Approver)
.Include(b => b.User)
.Where(b => b.Id == id)
.FirstOrDefault();
_context.Entry(request).State = EntityState.Deleted;
_context.SaveChanges();
return(Json(Ok()));
}
static void Main(string[] args)
{
var employeeConfig = new EmployeeConfig();
var requester = new Employee("John", "Watson", employeeConfig);
var manager = new Employee("Sherlock", "Holmes", employeeConfig);
var request = new HolidayRequest(requester, manager, OneWeekHolidayStartingTomorrow());
var composer = new Composer(request, new ComposerConfig());
SendMail(composer.ComposeByStatus(RequestStatus.Approved));
SendMail(composer.ComposeByStatus(RequestStatus.Rejected));
SendMail(composer.ComposeByStatus(RequestStatus.Requested));
}
private HolidayRequestResult Map(HolidayRequest x)
{
return(new HolidayRequestResult
{
Success = true,
Approved = x.Approved,
Deleted = x.Deleted,
Id = x.Id,
DateFrom = x.DateFrom,
DateTo = x.DateTo,
ApproverEmail = x.Approver?.Email,
UserEmail = x.User.Email
});
}
public async Task <IHttpActionResult> Post([FromBody] HolidayRequest holidayRequest)
{
var parts = holidayRequest.DateRange.Split(new[] { " - " }, StringSplitOptions.RemoveEmptyEntries);
var absence = new Models.Absence()
{
StartDate = DateTime.Parse(parts[0]),
EndDate = DateTime.Parse(parts[1])
};
var absenceRepository = new Repositories.AbsenceRepository();
await absenceRepository.Create(absence);
return(Ok());
}
public void RejectedRequest_IsCorrect()
{
var now = DateTime.Now;
var requester = GetEmployee("John", "Watson");
var manager = GetEmployee("Sherlock", "Holmes");
var request = new HolidayRequest(requester, manager, new TimeInterval {
From = now.AddDays(1), To = now.AddDays(8)
});
var composer = new Composer(request, GetConfig());
MailMessage mail = composer.ComposeByStatus(RequestStatus.Rejected);
Assert.IsTrue(mail.Subject.StartsWith("[Rejected]"));
Assert.AreEqual(mail.From.Address, manager.GetEmployeeEmail().Address);
Assert.AreEqual(mail.To[0].Address, requester.GetEmployeeEmail().Address);
}
public IActionResult Put(string id, [FromBody] HolidayRequestDto t)
{
ApplicationUser user = GetUserIncludingCerts(id);
HolidayRequest hol = user.AddHolidayRequest(t, _userManager).Result;
hol.Created(_mediator);
if (hol != null)
{
return(Ok(hol.Id));
}
else
{
return(BadRequest());
}
}
public async Task <HolidayRequestResult> RegisterHolidayRequestAsync(string email, DateTime from, DateTime to)
{
var user = await _userDal.FindByEmailAsync(email);
if (user == null)
{
return(new HolidayRequestResult
{
Errors = new string[] { "The user does not exists" }
});
}
var otherRequests = await _holidayManager.GetAllFromUserAsync(user, from.Year, to.Year);
foreach (var r in otherRequests.Where(x => !x.Deleted))
{
if (from.Date < r.DateFrom.Date && to.Date > r.DateTo.Date)
{
return(new HolidayRequestResult
{
Errors = new string[]
{ "Cannot perform request because it contains days from other already existing requests" }
});
}
}
var toAdd = new HolidayRequest
{
Approved = false,
Approver = null,
User = user,
DateFrom = from,
DateTo = to
};
var res = await _holidayManager.AddRequestAsync(toAdd);
if (!res)
{
return(new HolidayRequestResult
{
Errors = new string[] { "Could not add request" }
});
}
return(Map(toAdd));
}
public async Task <bool> UpdateRequestAsync(HolidayRequest request)
{
var reference = _context.HolidayRequests.FirstOrDefault(x => x.Id == request.Id);
if (reference != null)
{
reference.Approved = request.Approved;
reference.Approver = request.Approver;
reference.User = request.User;
reference.DateFrom = request.DateFrom;
reference.DateTo = request.DateTo;
await _context.SaveChangesAsync();
return(true);
}
return(false);
}
public ActionResult GetHolidaysForm(int id)
{
HolidayRequest holidayViewModel;
if (id == 0)
{
holidayViewModel = new HolidayRequest();
}
else
{
var holiday = db.Holidays.FirstOrDefault(i => i.Id == id);
holidayViewModel = new HolidayRequest
{
Id = holiday.Id,
Day = holiday.Day,
Title = holiday.Title
};
}
return(View(holidayViewModel));
}
public IActionResult Put([FromBody] HolidayRequestDto hr)
{
HolidayRequest request = _context.HolidayRequest
.Include(b => b.Approver)
.Include(b => b.User)
.Where(b => b.Id == hr.Id)
.FirstOrDefault();
if (hr.IsApproved())
{
request.Approve(_mediator);
}
else if (hr.IsRejected())
{
request.Reject(_mediator);
}
_context.SaveChanges();
return(new NoContentResult());
}
/// <summary>
/// Gets the holidays asynchronous.
/// </summary>
/// <param name="filter">The filter.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>IEnumerable<IHoliday>.</returns>
public async Task <IEnumerable <IHoliday> > GetHolidaysAsync(HolidayFilter filter, CancellationToken cancellationToken)
{
var request = new HolidayRequest
{
Key = _apiKey,
Country = filter.Country,
Year = filter.Year,
Day = filter.Day,
Month = filter.Month,
Language = filter.Language,
Previous = filter.Previous,
Public = filter.Public,
Search = filter.Search,
Subdivisions = filter.Subdivisions,
Upcoming = filter.Upcoming
};
var response = await Execute <HolidayRequest, HolidayResponse>(request, cancellationToken).ConfigureAwait(false);
return(response.Holidays);
}
public int HolidayRequest(DateTime startDate, DateTime endDate, int workingDays, string username, string password)
{
if (startDate > endDate || startDate < DateTime.Now.AddDays(2) || workingDays == 0)
{
return(-4);
}
try
{
using (HBSModel _entity = new HBSModel())
{
var _user = _entity.Users.FirstOrDefault(x => x.Username == username);
if (_user == null)
{
return(-1);
}
if (!GeneralUtils.VerifyPasswordHash(password, _user.Pwd, _user.PwdSalt) || _user.Role.RoleName == GeneralUtils.ADMIN_ROLE)
{
return(-2);
}
HolidayRequest holidayRequest = new HolidayRequest()
{
StartDate = startDate,
EndDate = endDate,
UserID = _user.id,
NumberOfDays = workingDays
};
holidayRequest.RequestStatusID = _entity.StatusRequests
.FirstOrDefault(status => status.Status == GeneralUtils.PENDING).ID;
holidayRequest.ConstraintsBroken = new ConstraintChecking(_user, holidayRequest).getBrokenConstraints();
holidayRequest.DaysPeakTime = PrioritiseRequests
.daysFallPeakTimesCount(holidayRequest.StartDate, holidayRequest.EndDate);
_entity.HolidayRequests.Add(holidayRequest);
_entity.SaveChanges();
}
}
catch
{
return(-3);
}
return(1);
}
public HolidayRequest CreateHolidayRequest(HolidayRequest holidayRequest)
{
this._holidayRequestRepository.Add(holidayRequest);
this.SaveHolidayRequest();
//we also need to save new holiday request transaction when creating one
var holidayRequestJournalEntry = new HolidayRequestJournalEntry()
{
CreatedDate = DateTime.Now
, Employee = holidayRequest.Employee
, EmployeeId = holidayRequest.EmployeeId
, HolidayRequestId = holidayRequest.HolidayRequestId
, HolidayRequest = holidayRequest
, OperationDescription = "Utworzenie wniosku o urlop"
};
this._holidayRequestJournalEntryRepository.Add(holidayRequestJournalEntry);
this.SaveHolidayRequest();
return(holidayRequest);
}
public async Task <ActionResult> Edit(int id, HolidayRequest holidayRequest)
{
if (_context.Users.Where(x => x.Email == User.Identity.Name).FirstOrDefault().IsAdmin == false)
{
return(Unauthorized());
}
try
{
var dbHoliday = _context.HolidayRequests.Where(x => x.HolidayRequestId == id).FirstOrDefault();
dbHoliday.Status = holidayRequest.Status;
dbHoliday.Approver = _context.Users.Where(x => x.Email == User.Identity.Name).FirstOrDefault();
dbHoliday.ModifiedDate = DateTime.Now;
_context.Update(dbHoliday);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(StatusCode(500));
}
return(RedirectToAction(nameof(Index)));
}
public override void Process(HolidayRequest request)
{
new EmailSender().SendMail(request.EmployeeEmail);
}
public RequestHandler(HolidayRequest request)
{
request.Process(new PendingRequestState());
}
public void Reject(HolidayRequest request)
{
request.Process(new RejectedRequestState());
}
public void Aprove(HolidayRequest request)
{
request.Process(new ApprovedRequestState());
}
public override void Process(HolidayRequest request)
{
new EmailSender().SendMail(request.ManagerEmail);
}
public abstract void Process(HolidayRequest request);
public override void Process(HolidayRequest request)
{
new EmailSender().NotifyHR();
}
