public JsonResult PostHoliday(HolidayViewModel holiday)
{
Guard.Against.Null(holiday, nameof(holiday));
IList <TmHoliday> list = new List <TmHoliday>();
if (holiday.Holidays != null)
{
foreach (var day in holiday.Holidays)
{
TmHoliday model = new TmHoliday();
model.CaseUid = holiday.CaseUid;
model.Holiday = day;
DayOfWeek dw = Convert.ToDateTime(day).DayOfWeek;
if (dw == DayOfWeek.Sunday)
{
model.HodidayNote = "星期天";
}
else if (dw == DayOfWeek.Saturday)
{
model.HodidayNote = "星期六";
}
else
{
model.HodidayNote = "节假日";
}
list.Add(model);
}
}
_timeService.AddHoliday(holiday.CaseUid, list);
return(Json(ResponseViewModelUtils.Sueecss()));
}
public IActionResult UpdateHolidayStatus(int holidayId, string holidayStatus)
{
try
{
int userId = (int)HttpContext.Session.GetInt32("UserId");
ViewBag.UserRole = HttpContext.Session.GetString("UserRole");
_holiday.UpdateHolidayStatus(holidayId, holidayStatus);
HolidayViewModel employeesRequests = new HolidayViewModel
{
MyHolidaysList = _holiday.DisplayEmployeesHolidayRequests(holidayStatus).ToList()
};
if (employeesRequests != null)
{
return(RedirectToAction("ListEmployeesVacationsRequests"));
}
else
{
return(View("ListEmployeesVacationsRequests"));
}
}
catch (Exception exe)
{
return(View("ListEmployeesVacationsRequests", ViewBag.Error = exe.Message.ToString()));
}
}
public Holiday(HolidayViewModel vm)
{
HolidayId = vm.HolidayId;
Name = vm.Name;
StartDate = vm.StartDate;
EndDate = vm.EndDate;
}
public async Task LoadHoliday(string country, int year)
{
var holidays = await HolidayViewModel.GetHoliday(country, year);
HolidayBox.ItemsSource = holidays.ToString();
}
public async Task <IActionResult> EditHoliday(HolidayViewModel holidayVM)
{
try
{
//Update Holiday
var HolidayData = _unitOfWork.Holiday.GetSingleOrDefault(d => d.Id == holidayVM.ID);
if (HolidayData != null)
{
HolidayData.FestivalName = holidayVM.FestivalName;
HolidayData.FestivalDate = Utilities.FormatDateTimeByZone(holidayVM.FestivalDate);
HolidayData.FestivalDay = Utilities.FormatDateTimeByZone(holidayVM.FestivalDate).ToString("dddd");
HolidayData.FestivalDescription = holidayVM.FestivalDescription;
HolidayData.IsNationalFestival = holidayVM.IsNationalFestival;
HolidayData.BelongToCommunity = holidayVM.BelongToCommunity;
}
_unitOfWork.Holiday.Update(HolidayData);
await _unitOfWork.CompleteAsync();
}
catch (Exception Ex)
{
return(new BadRequestObjectResult(Errors.AddError(Ex, ModelState)));
}
return(new OkObjectResult(holidayVM));
}
public HolidayViewModel MapToViewModel(Holiday holiday)
{
HolidayViewModel holidayVM = new HolidayViewModel();
holidayVM.division = new HolidayDivisionViewModel();
holidayVM._id = holiday.Id;
holidayVM.UId = holiday.UId;
holidayVM._deleted = holiday._IsDeleted;
holidayVM._active = holiday.Active;
holidayVM._createdDate = holiday._CreatedUtc;
holidayVM._createdBy = holiday._CreatedBy;
holidayVM._createAgent = holiday._CreatedAgent;
holidayVM._updatedDate = holiday._LastModifiedUtc;
holidayVM._updatedBy = holiday._LastModifiedBy;
holidayVM._updateAgent = holiday._LastModifiedAgent;
holidayVM.code = holiday.Code;
holidayVM.date = holiday.Date.Value.ToLocalTime();
holidayVM.name = holiday.Name;
holidayVM.division._id = holiday.DivisionId;
holidayVM.division.name = holiday.DivisionName;
holidayVM.description = holiday.Description;
return(holidayVM);
}
// [TypeFilter(typeof(AuthorizeAction), Arguments = new object[] { "Write" })]
public IActionResult Index()
{
HolidayViewModel model = new HolidayViewModel();
InitAccessModel(model);
return(View(model));
}
public List <HolidayViewModel> GetHolidaysOfYear(int year)
{
try
{
List <HolidayViewModel> listOfholidays = null;
IEnumerable <Holiday> holidayList = _businessDaysRepository.GetHolidaysOfYear(year);
if (holidayList != null)
{
listOfholidays = new List <ViewModel.Admin.HolidayViewModel>();
foreach (Holiday holiday in holidayList)
{
HolidayViewModel holidayViewModel = new HolidayViewModel();
holidayViewModel.HolidayDate = holiday.HolidayDate;
holidayViewModel.HolidayName = holiday.HolidayName;
holidayViewModel.DateKey = holiday.DateKey;
listOfholidays.Add(holidayViewModel);
}
}
return(listOfholidays);
}
catch (Exception ex)
{
_logger.Log(ex, LogLevel.Error, ex.Message);
return(null);
}
}
public ActionResult Create(HolidayViewModel viewModel)
{
var userId = User.Identity.Name;
var entity = viewModel.Holiday;
try
{
if (CheckExist(entity))
{
dbContext.Holidays.InsertOne(entity);
#region Activities
//var activity = new TrackingUser
//{
// UserId = userId,
// Function = Constants.Collection.BHYTHospitals,
// Action = Constants.Action.Create,
// Value = entity.Code,
// Content = entity.Code + Constants.Flag + entity.Name
//};
//dbContext.TrackingUsers.InsertOne(activity);
#endregion
return(Json(new { entity, result = true, message = "Add new successfull." }));
}
else
{
return(Json(new { entity, result = false, message = entity.Date + " is exist. Try another key or contact IT." }));
}
}
catch (Exception ex)
{
return(Json(new { entity, result = false, message = ex.Message }));
}
}
// [TypeFilter(typeof(AuthorizeAction), Arguments = new object[] { "Read" })]
public IActionResult SummaryView()
{ // returns listing view
HolidayViewModel model = new HolidayViewModel();
InitAccessModel(model);
return(View(model));
}
public Holiday MapToModel(HolidayViewModel holidayVM)
{
Holiday holiday = new Holiday();
holiday.Id = holidayVM._id;
holiday._IsDeleted = holidayVM._deleted;
holiday.Active = holidayVM._active;
holiday._CreatedUtc = holidayVM._createdDate;
holiday._CreatedBy = holidayVM._createdBy;
holiday._CreatedAgent = holidayVM._createAgent;
holiday._LastModifiedUtc = holidayVM._updatedDate;
holiday._LastModifiedBy = holidayVM._updatedBy;
holiday._LastModifiedAgent = holidayVM._updateAgent;
holiday.Code = holidayVM.code;
holiday.Date = holidayVM.date;
holiday.Name = holidayVM.name;
if (!Equals(holidayVM.division, null))
{
holiday.DivisionId = holidayVM.division._id;
holiday.DivisionName = holidayVM.division.name;
}
else
{
holiday.DivisionId = null;
holiday.DivisionName = null;
}
holiday.Description = holidayVM.description;
return(holiday);
}
public async Task <HolidayViewModel> UpdateAsync(HolidayViewModel holidayViewModel)
{
var locationHoliday = m_mapper.Map <LocationHoliday>(holidayViewModel);
locationHoliday = await m_holidayRepository.UpdateAsync(locationHoliday);
return(m_mapper.Map <HolidayViewModel>(locationHoliday));
}
public ActionResult DeleteConfirmed(int id)
{
HolidayViewModel holidayViewModel = db.AspNetHolidays.Find(id);
db.AspNetHolidays.Remove(holidayViewModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task Update()
{
Holiday holiday = await DataUtil.GetTestDataAsync();
HolidayViewModel VM = Service.MapToViewModel(holiday);
var response = await this.Client.PutAsync(string.Concat(URI, "/", VM._id), new StringContent(JsonConvert.SerializeObject(VM).ToString(), Encoding.UTF8, "application/json"));
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
//[HttpPost]
//public ActionResult FileUpload(AddImagesModel model)
//{
// string text = "";
// if (model.file != null)
// {
// string path = System.IO.Path.Combine(
// Server.MapPath("~/Images"), "");
// ObjectFactory factory = new ObjectFactory(repository);
// IAddImage addImage = factory.CreateObject(model.type.ToString());
// text = addImage.AddPathToEntity(model.Id, path);
// if (text == "")
// {
// return View("AddImagesToMany");
// }
// model.file.SaveAs(path + text);
// }
// if (text.Contains("Hotel"))
// {
// return RedirectToAction("EditHotel", new { id = text[6] });
// }
// else
// {
// return RedirectToAction("EditResort", new { id = text[7] });
// }
//}
// GET: Owner
public ActionResult Index()
{
HolidayViewModel model = new HolidayViewModel();
model = repository.GetModelByUser(User.Identity.GetUserId());
return(View(model));
}
public async Task Delete()
{
Holiday holiday = await DataUtil.GetTestDataAsync();
HolidayViewModel VM = Service.MapToViewModel(holiday);
var response = await this.Client.DeleteAsync(string.Concat(URI, "/", VM._id));
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
public IActionResult Index()
{
HolidayViewModel holidayViewModel = new HolidayViewModel
{
Holidays = unitOfWork.Holiday.GetAll().ToList()
};
return(View(holidayViewModel));
}
public ActionResult Index()
{
HolidayViewModel model = new HolidayViewModel();
model = repository.GetRandomPlaces();
return(View("Index", model));
}
public ActionResult HolidayDetail(int?id)
{
HolidayViewModel model = new HolidayViewModel();
if (id.HasValue)
{
model = new HolidayRepository().GetByID((int)id);
}
return(PartialView("_Holiday", model));
}
public ActionResult Edit([Bind(Include = "Id,FirstName,LastName,Email,TeamLeaderName,StartDate,EndDate,DaysOff,TLEmail,HolidayType,SickLeaveIndex,Flag")] HolidayViewModel holidayViewModel)
{
if (ModelState.IsValid)
{
db.Entry(holidayViewModel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(holidayViewModel));
}
public ActionResult Create([Bind(Include = "Id,FirstName,LastName,Email,TeamLeaderName,StartDate,EndDate,DaysOff,TLEmail,HolidayType,SickLeaveIndex,Flag")] HolidayViewModel holidayViewModel)
{
if (ModelState.IsValid)
{
db.AspNetHolidays.Add(holidayViewModel);
db.SaveChanges();
return(RedirectToAction("SuccessHoliday", "Success"));
}
return(View(holidayViewModel));
}
public IHttpActionResult PostHoliday(HolidayViewModel holiday)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.UpdateHoliday(holiday.MapTo <Holiday>());
return(Ok(holiday));
}
public async Task <IActionResult> Delete(HolidayViewModel viewmodel)
{
try
{
var response = await Mediator.Send(new DeleteHolidayCommand { Id = viewmodel.Id });
}
catch (Exception ex)
{
ModelState.AddModelError("Error", ex.Message);
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Insert([Bind("Date")] HolidayViewModel viewmodel)
{
try
{
var response = await Mediator.Send(new InsertHolidayCommand { Date = viewmodel.Date });
}
catch (Exception ex)
{
ModelState.AddModelError("Error", ex.Message);
}
return(RedirectToAction(nameof(Index)));
}
// [TypeFilter(typeof(AuthorizeAction), Arguments = new object[] { "Write" })]
public IActionResult AddUpdate(HolidayViewModel model)
{ // Inserts or Udates Data
if (ModelState.IsValid)
{
return(Json(_interface.AddUpdate(model.holyday)));
}
else
{
resp.Message = Constants.ControllerMessage.All_Fields_Mandatory;
return(Json(resp));
}
}
/// <summary>
/// Maps Holiday View Model to Holiday Business model
/// </summary>
/// <param name="holiday"></param>
/// <returns></returns>
public static Holiday MapHolidayViewModelToBusinessModel(HolidayViewModel holiday)
{
Holiday hld = new Holiday();
if (holiday != null)
{
hld.HolidayDate = holiday.HolidayDate;
hld.HolidayName = holiday.HolidayName;
hld.DateKey = holiday.DateKey;
}
return(hld);
}
public IActionResult HolidayEdit(HolidayViewModel model, int Id)
{
var editingholiday = _ctx.Holiday.SingleOrDefault(a => a.Id == Id);
if (editingholiday != null)
{
editingholiday.StartDate = model.StartDate;
editingholiday.EndDate = model.EndDate;
_ctx.SaveChanges();
}
return(RedirectToAction("HolidayIndex", "Admin"));
}
/// <summary>
/// Deletes Holiday
/// </summary>
/// <param name="holiday"></param>
/// <returns></returns>
public bool DeleteHoliday(HolidayViewModel holiday)
{
try
{
Holiday deleteHoliday = BusinessMapper.MapHolidayViewModelToBusinessModel(holiday);
return(_businessDaysRepository.DeleteHoliday(deleteHoliday));
}
catch (Exception ex)
{
_logger.Log(ex, LogLevel.Error, ex.Message);
return(false);
}
}
public ActionResult Index(int year, int month, DateTime date)
{
// Do later
var datas = dbContext.Holidays.Find(m => m.Enable.Equals(true)).SortByDescending(m => m.Date).ToList();
var viewModel = new HolidayViewModel
{
Holidays = datas
};
return(View(viewModel));
}
// GET: HolidayViewModels/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
HolidayViewModel holidayViewModel = db.AspNetHolidays.Find(id);
if (holidayViewModel == null)
{
return(HttpNotFound());
}
return(View(holidayViewModel));
}
