public ActionResult EditEvent(CalendarEventViewModel vm)
{
if (!ModelState.IsValid)
{
return(BadRequest("<strong>Error:</strong> Input is invalid."));
}
// Date range check.
if (vm.DateFrom > vm.DateTo)
{
return(BadRequest("<strong>Error:</strong> Start date cannot be after the end date."));
}
// Check if the calendar entry exists.
if (!_schedulerPresentationService.CheckCalendarEventExists(vm.CalendarEventId))
{
return(BadRequest("<strong>Error:</strong> The calendar event could not be found."));
}
// Save event.
_schedulerPresentationService.UpdateCalendarEvent(vm);
return(Json(new
{
message = "<strong>Success:</strong> Calendar event saved.",
backUrl = Url.Action(nameof(Index), "Scheduler", null)
}));
}
/// <summary>
/// Get CalendarEvent by id
/// </summary>
/// <param name="id">CalendarEvent id</param>
/// <returns>CalendarEvent json view model</returns>
public IHttpActionResult Get(int id)
{
try
{
// get
log.Debug("_calendarEventService.GetCalendarEvent - calendarEventId: " + id + " ");
var calendarEvent = new CalendarEventViewModel(_calendarEventService.GetCalendarEvent(id));
log.Debug("_calendarEventService.GetCalendarEvent - " + CalendarEventViewModel.FormatCalendarEventViewModel(calendarEvent));
log.Debug("result: 'success'");
//return Json(calendarEvent, JsonRequestBehavior.AllowGet);
//return Content(JsonConvert.SerializeObject(calendarEvent), "application/json");
//return calendarEvent;
//return JsonConvert.SerializeObject(calendarEvent);
return(Ok(calendarEvent));
}
catch (Exception e)
{
// error
log.Error(e.ToString());
throw;
}
}
public ActionResult BookingLesson(CalendarEventViewModel viewModel)
{
ViewBag.ViewModel = viewModel;
if (viewModel.KeyID != null)
{
viewModel.UID = viewModel.DecryptKeyValue();
}
var item = models.GetTable <UserProfile>().Where(u => u.UID == viewModel.UID).FirstOrDefault();
if (item == null)
{
return(Json(new { result = false, message = "學員資料錯誤!!" }));
}
if (!viewModel.StartDate.HasValue)
{
viewModel.StartDate = DateTime.Today.AddHours(8);
}
else if (viewModel.StartDate.Value.TimeOfDay.Hours == 0)
{
viewModel.StartDate = viewModel.StartDate.Value.Date.AddHours(8);
}
return(View("~/Views/ConsoleEvent/EventModal/BookingLesson.cshtml", item));
}
public ActionResult CreateEvent(CalendarEventViewModel vm)
{
if (!ModelState.IsValid)
{
return(BadRequest("<strong>Error:</strong> Input is invalid."));
}
// Date range check.
if (vm.DateFrom > vm.DateTo)
{
return(BadRequest("<strong>Error:</strong> Start date cannot be after the end date."));
}
// Save event.
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var id = _schedulerPresentationService.CreateCalendarEvent(vm, userId);
// Return calendar record for fullCalendar.js.
return(Json(new
{
message = "<strong>Success:</strong> Calendar event created.",
calEntry = new
{
id,
title = vm.Title,
start = vm.DateFrom,
end = vm.DateTo,
allDay = vm.AllDay
},
backUrl = Url.Action(nameof(Index), "Scheduler", null)
}));
}
// GET: Events/Details/5
public async Task <IActionResult> Details(int?id, string modal = null, string redir = null)
{
if (id == null)
{
return(NotFound());
}
var @event = await _context.Event.SingleOrDefaultAsync(m => m.ID == id);
ViewBag.Redir = redir;
ViewBag.Modal = modal; /* show event detail with modal */
if (@event == null)
{
return(NotFound());
}
var acks = await _context.Acknowledgement.Where(m => m.EventID == id).OrderBy(m => m.UpdatedDate).ToListAsync();
var attachs = await _context.Attachment.Where(m => m.EventID == id).OrderBy(m => m.UpdatedDate).ToListAsync();
CalendarEventViewModel CalendarEvent = new CalendarEventViewModel(@event, acks, attachs);
/*
* var attachs = await _context.Attachment.Where(m => m.EventID == id).OrderBy(m => m.UpdatedDate).ToListAsync();
* CalendarEvent = new CalendarEventViewModel(@event, null, attachs);
*/
return(View(CalendarEvent));
}
public void UpdateCalendarEvent(CalendarEventViewModel eventVm)
{
var calEvent = ConvertCalendarEventViewModelToDomainModel(eventVm);
// Save event.
_scheduleRepository.EditCalendarEvent(calEvent);
}
public CalendarViewModel GetCalendarInfo(int month, int year)
{
var viewModel = new CalendarViewModel();
var eventLis = new List <CalendarEventViewModel>();
viewModel.Month = month;
viewModel.Year = year;
var curMonthEvents = this.contestRepository.All().Where(x => x.StartTime.Month == month);
foreach (var contest in curMonthEvents)
{
var curEvent = new CalendarEventViewModel()
{
Date = contest.StartTime.Date,
Title = contest.Name,
Type = CalendarType,
};
eventLis.Add(curEvent);
}
viewModel.Events = eventLis;
return(viewModel);
}
public ActionResult EditEntry(CalendarEventViewModel vm)
{
if (!ModelState.IsValid)
{
return(SiteErrorHandler.GetBadRequestActionResult("<strong>Error:</strong> Input is invalid.", ""));
}
// Date range check.
if (vm.DateFrom > vm.DateTo)
{
return(SiteErrorHandler.GetBadRequestActionResult("<strong>Error:</strong> Start date cannot be after the end date.", ""));
}
// Check if the calendar entry exists.
if (!_scheduleRepository.DoesCalEntryExist(vm.CalendarEntryId))
{
return(SiteErrorHandler.GetBadRequestActionResult("<strong>Error:</strong> The calendar event could not be found.", ""));
}
var entry = _mapper.Map <CalEntry>(vm);
// Save event.
_scheduleRepository.EditCalendarEntry(entry);
return(Json(new
{
message = "<strong>Success:</strong> Calendar event saved."
}, JsonRequestBehavior.AllowGet));
}
private CalendarEventDTO Create(CalendarEventViewModel viewModel)
{
try
{
log.Debug(CalendarEventViewModel.FormatCalendarEventViewModel(viewModel));
CalendarEventDTO calendarEvent = new CalendarEventDTO();
// copy values
viewModel.UpdateDTO(calendarEvent, null); //RequestContext.Principal.Identity.GetUserId());
// audit
calendarEvent.CreateBy = null; //RequestContext.Principal.Identity.GetUserId();
calendarEvent.CreateOn = DateTime.UtcNow;
// add
log.Debug("_calendarEventService.AddCalendarEvent - " + CalendarEventDTO.FormatCalendarEventDTO(calendarEvent));
int id = _calendarEventService.AddCalendarEvent(calendarEvent);
calendarEvent.CalendarEventId = id;
log.Debug("result: 'success', id: " + id);
return(calendarEvent);
}
catch (Exception e)
{
// error
log.Error(e.ToString());
throw;
}
}
public JsonResult CalendarEventAdd(int calendarId, string eventName, string startDate, string endDate, string eventUrl)
{
CalendarEvent calendarEvent = new CalendarEvent();
calendarEvent.EventName = eventName;
calendarEvent.StartDate = DateTime.Parse(startDate);
calendarEvent.EndDate = DateTime.Parse(endDate);
calendarEvent.CreateDate = DateTime.Now.Date;
calendarEvent.EventUrl = eventUrl;
calendarEvent.CalendarId = calendarId;
db.CalendarEvents.Add(calendarEvent);
db.SaveChanges();
CalendarEventViewModel calendarEventViewModel = new CalendarEventViewModel()
{
Id = calendarEvent.Id,
CalendarId = calendarEvent.CalendarId,
EventName = calendarEvent.EventName,
StartDate = calendarEvent.StartDate.ToString("yyyy-MM-dd"),
EndDate = calendarEvent.EndDate.ToString("yyyy-MM-dd"),
EventUrl = calendarEvent.EventUrl
};
return(Json(calendarEventViewModel));
}
public ActionResult EditCustomEventView(int customEventId, string color)
{
switch (color)
{
case CalendarEventColors.CustomEvent:
var customEvent = _customEventService.GetById(customEventId);
var customEventModel = Mapper.Map <CustomEventViewModel>(customEvent);
return(PartialView("EditCustomEventView", customEventModel));
case CalendarEventColors.MedicalReport:
var medicalEx = _medicalReportService.GetById(customEventId);
CalendarEventViewModel medicalExModel = new CalendarEventViewModel
{
Description = medicalEx.Notes,
Title = "Koniec badań lekarskich",
StartDate = medicalEx.CompletionDate,
EndDate = medicalEx.NextCompletionDate,
EmployeeName = medicalEx.Employee.FullName
};
return(PartialView("CalendarEventView", medicalExModel));
case CalendarEventColors.Leave:
case CalendarEventColors.SickLeave:
var leave = _leaveService.GetById(customEventId);
CalendarEventViewModel leaveModel = new CalendarEventViewModel
{
Description = leave.Notes,
Title = CreateLeaveTitle(leave),
StartDate = leave.DateFrom,
EndDate = leave.DateTo,
EmployeeName = leave.Employee.FullName
};
return(PartialView("CalendarEventView", leaveModel));
case CalendarEventColors.OSHTraining:
var oshTraining = _oshTrainingService.GetById(customEventId);
CalendarEventViewModel model = new CalendarEventViewModel
{
Description = oshTraining.Notes,
Title = "Koniec szkolenia BHP",
StartDate = oshTraining.CreatedDate,
EndDate = oshTraining.NextCompletionDate,
EmployeeName = oshTraining.Employee.FullName
};
return(PartialView("CalendarEventView", model));
}
;
throw new Exception("Brak widoku do wyświetlenia!");
}
private void UIElement_OnMouseMove(object sender, MouseEventArgs e)
{
Rectangle selectedRectangle = (Rectangle)sender;
CalendarEventViewModel selectedEvent = (CalendarEventViewModel)selectedRectangle.DataContext;
_displayCalendarViewModel.SelectedEvent = selectedEvent;
}
private void UIElement_OnMouseMove(object sender, MouseEventArgs e)
{
if (sender is Rectangle selectedRectangle)
{
CalendarEventViewModel selectedEvent = selectedRectangle.DataContext as CalendarEventViewModel;
displayCalendarViewModel.SelectedEvent = selectedEvent;
}
}
public ActionResult ManCalendar()
{
CalendarEventViewModel cvm = new CalendarEventViewModel();
var username = HttpContext.User.Identity.Name;
var user = _UserRepository.GetUserByUsername(username);
cvm.User = user;
return(View(cvm));
}
public JsonResult updateEventId(FormCollection updatedCalendarEvent)
{
CalendarEventViewModel cevm = new CalendarEventViewModel();
CalendarEvent events = new CalendarEvent();
string lead = updatedCalendarEvent[19].Substring(0, 5);
int LeadId = Int32.Parse(lead);
LeadId = Int32.Parse(lead);
AppointmentSheetViewModel avm = new AppointmentSheetViewModel();
AppointmentSheet asvm = new AppointmentSheet()
{
ParentLeadId = LeadId
};
string starttemp = updatedCalendarEvent[14].Remove(0, 4);
starttemp = starttemp.Remove(20);
string endtemp = updatedCalendarEvent[15].Remove(0, 4);
endtemp = endtemp.Remove(20);
DateTime tempstart = DateTime.Parse(starttemp);
events.start = tempstart.ToString("yyyy-MM-ddTHH':'mm':'ss'.'fff'-'05':'00");
DateTime tempend = DateTime.Parse(endtemp);
events.end = tempend.ToString("yyyy-MM-ddTHH':'mm':'ss'.'fff'-'05':'00");
events.id = Int32.Parse(updatedCalendarEvent[0]);
events.title = updatedCalendarEvent[1].ToString();
events.street = updatedCalendarEvent[6].ToString();
events.city = updatedCalendarEvent[7].ToString();
events.state = updatedCalendarEvent[8].ToString();
events.Parent_User_Id = Int32.Parse(updatedCalendarEvent[17]);
events.Parent_Appointment_Id = Int32.Parse(updatedCalendarEvent[18]);
events.Appointment_Reference = updatedCalendarEvent[19].ToString();
events.zipcode = Int32.Parse(updatedCalendarEvent[10]);
events.appointment = Boolean.Parse(updatedCalendarEvent[4]);
events.creator = Int32.Parse(updatedCalendarEvent[12]);
asvm.Street = updatedCalendarEvent[6].ToString();;
asvm.City = updatedCalendarEvent[7].ToString();
asvm.State = updatedCalendarEvent[8].ToString();
asvm.Event_Reference = updatedCalendarEvent[19].ToString();
asvm.ZipCode = Int32.Parse(updatedCalendarEvent[10]);
asvm.AssignedSalesAgent = Int32.Parse(updatedCalendarEvent[17]);
asvm.AppointmentDateFrom = tempstart;
asvm.AppointmentDateTo = tempend;
asvm.AppointmentSheetId = events.Parent_Appointment_Id;
string parentlead = events.Appointment_Reference.Substring(0, 5);
asvm.ParentLeadId = Int32.Parse(parentlead);
asvm.DayOfAppointment = tempstart;
asvm.LastUpdated = Convert.ToDateTime(DateTime.Now);
asvm.CreatorId = events.creator;
avm.appointmentSheet = asvm;
cevm.calendarEvent = events;
_eventsRepository.SaveCalendarEvent(cevm.calendarEvent);
_appointmentsRepository.SaveAppointmentSheetFromCalendar(avm.appointmentSheet);
return(null);
}
// GET: Quick create view.
public ActionResult _QuickCreate(DateTime start, DateTime end)
{
var vm = new CalendarEventViewModel()
{
DateFrom = start,
DateTo = end
};
return(PartialView(vm));
}
public ActionResult EventsAdd()
{
var model = new CalendarEventViewModel();
model = BuildModel(model);
return(View("EventManager", model));
}
public Guid CreateCalendarEvent(CalendarEventViewModel eventVm, string userId)
{
eventVm.UserId = userId;
var calEvent = ConvertCalendarEventViewModelToDomainModel(eventVm);
// Save event.
var id = _scheduleRepository.CreateCalendarEvent(calEvent);
return(id);
}
private void UIElement_OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
Rectangle selectedRectangle = (Rectangle)sender;
CalendarEventViewModel selectedEvent = (CalendarEventViewModel)selectedRectangle.DataContext;
string message = "Hora Inicio: " + selectedEvent.GetStartTime() + "\n";
message += "Hora Fin: " + selectedEvent.GetFinishTime();
MessageBox.Show(message, selectedEvent.Title);
}
private CalendarEventViewModel BuildModel(CalendarEventViewModel model)
{
var locations = _locationsRepository.GetAll();
//var productions = _productionRepository.GetAll();
// IEnumerable<Production> nullproduction = new List<Production>();
var eventtypes = _eventtypeRepository.GetAll();
model.ImageUploadMaxLengthInBytes = _imageService.ImageUploadMaxLengthInBytes;
model.Locations = new SelectList(
locations
, "Id"
, "Name"
);
//if (model.Id == 0)
//{
// model.Productions = new SelectList(
// nullproduction // productions
// , "Id"
// , "Name"
// );
// model.StartDate = DateTime.Now;
// model.EndDate = DateTime.Now;
// model.StartTime = DateTime.Now;
// model.EndTime = DateTime.Now;
//}
//else
//{
// model.Productions = new SelectList(
// productions
// , "Id"
// , "Name"
// );
//}
model.EventTypes = new SelectList(
eventtypes
, "Id"
, "Name"
);
return(model);
}
// GET: Create view with filled in options.
public ActionResult CreateMoreOptions(string title, DateTime start, DateTime end)
{
var entry = new CalendarEventViewModel()
{
Title = title,
DateFrom = start,
DateTo = end
};
return(View("Create", entry));
}
public JsonResult GetEvents()
{
using (var context = HttpContext.GetOwinContext().Get <ApplicationDbContext>())
{
var userId = User.Identity.GetUserId();
List <CalendarEventViewModel> events = new List <CalendarEventViewModel>();
if (this.User.IsInRole("Student"))
{
// query enrollments for a list of all enrollments and include assignments
var currentEnrollmentsWithAssignments = context.Enrollments.Where(x => x.User.Id == userId).Include(x => x.User).Include(x => x.Course).Include("Course.Assignments").ToList();
// get allAssignments in a list to pass to AllAssignmentsViewModel
var allAssignments = currentEnrollmentsWithAssignments.Select(x => x.Course).SelectMany(y => y.Assignments).ToList();
foreach (Assignment a in allAssignments)
{
var relevantInfo = new CalendarEventViewModel
{
AssignmentTitle = a.AssignmentTitle,
AssignmentDescription = a.AssignmentDescription,
DueDate = a.DueDate,
Department = a.Course.Department,
CourseNumber = a.Course.CourseNumber
};
events.Add(relevantInfo);
}
}
if (this.User.IsInRole("Instructor"))
{
var currentCoursesWithAssignments = context.Courses.Where(x => x.Instructor.Id == userId).Include("Assignments").ToList();
var allAssignments = currentCoursesWithAssignments.SelectMany(y => y.Assignments).ToList();
foreach (Assignment a in allAssignments)
{
var relevantInfo = new CalendarEventViewModel
{
AssignmentTitle = a.AssignmentTitle,
AssignmentDescription = a.AssignmentDescription,
DueDate = a.DueDate,
Department = a.Course.Department,
CourseNumber = a.Course.CourseNumber
};
events.Add(relevantInfo);
}
}
return(new JsonResult {
Data = events, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
private void UIElement_OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
Rectangle selectedRectangle = (Rectangle)sender;
CalendarEventViewModel selectedEvent = (CalendarEventViewModel)selectedRectangle.DataContext;
string message = "";
message += String.Format(applicationCulture, "Author: {0}\n", selectedEvent.Owner);
message += String.Format(applicationCulture, "Starting hour: {0}\n", selectedEvent.GetStartTime());
message += String.Format(applicationCulture, "Ending hour: {0}", selectedEvent.GetFinishTime());
if (selectedEvent.Owner == displayCalendarViewModel.GetLoggedUser())
{
MessageBoxResult result = MessageBox.Show(message, Properties.Resources.editEventPrompt, MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No);
if (result == MessageBoxResult.Yes)
{
NewEventView editDialog = new NewEventView(selectedEvent);
bool? editDialogResult = editDialog.ShowDialog();
if (editDialogResult == true)
{
if (editDialog.DeleteRequested)
{
displayCalendarViewModel.DeleteCalendarEvent(selectedEvent);
return;
}
List <string> ignoredUsers = DeleteScheduleConflicts(editDialog);
if (ignoredUsers.Count != 0)
{
string errorMessageString =
"Conflict detected on following user agendas: {0}. Invitation to conflict users has been ignored.";
string errorMessage = String.Format(
applicationCulture,
errorMessageString,
String.Join(",", ignoredUsers.ToArray()));
MessageBox.Show(errorMessage);
}
CalendarEvent calendarEvent = selectedEvent.CalendarEvent;
displayCalendarViewModel.UpdateCalendarEvent(calendarEvent, editDialog.TitleInput.Text, editDialog.PickedDate, editDialog.InvitedUsers,
editDialog.Description, editDialog.EndingHour, editDialog.EndingMinutes, editDialog.StartingHour,
editDialog.StartingMinutes);
}
}
}
else
{
MessageBox.Show(message, Properties.Resources.userIsInvited, MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.No);
}
}
public static void TestProperties()
{
int startingHour = 0;
int endingHour = 1;
int startingMinutes = 0;
int endingMinutes = 30;
string owner = "rodrigo";
string title = "Test";
CalendarEvent calendarEvent = new CalendarEvent(title, DateTime.Today, startingHour, startingMinutes, endingHour, endingMinutes, owner, "description", "");
CalendarEventViewModel viewModel = new CalendarEventViewModel(calendarEvent);
Assert.AreEqual(viewModel.Owner, owner);
Assert.AreEqual(viewModel.Title, title);
}
/// <summary>
/// Convert a <see cref="CalendarEventViewModel"/> to a <see cref="CalEventDm"/>.
/// </summary>
/// <param name="eventVm">The model to convert.</param>
/// <returns>The converted <see cref="CalEventDm"/>.</returns>
private CalEventDm ConvertCalendarEventViewModelToDomainModel(CalendarEventViewModel eventVm)
{
var calEvent = new CalEventDm()
{
CalendarEntryId = eventVm.CalendarEventId,
Title = eventVm.Title.Trim(),
Description = string.IsNullOrEmpty(eventVm.Description) ? null : eventVm.Description.Trim(),
DateFrom = eventVm.DateFrom,
DateTo = eventVm.DateTo,
AllDay = eventVm.AllDay,
UserId = eventVm.UserId
};
return(calEvent);
}
// GET: Create view.
public ActionResult Create()
{
DateTime today = DateTime.UtcNow;
TimeSpan amountToRound = TimeSpan.FromMinutes(15);
// Rounds date to the nearest specified minute.
// "+ amountToRound.Ticks - 1" makes sure today will round up if necessary. E.g. (12 + 5 - 1) = 16, 16 / 5 = 3, 3 * 5 = 15.
DateTime laterToday = new DateTime(((today.Ticks + amountToRound.Ticks - 1) / amountToRound.Ticks) * amountToRound.Ticks);
var entry = new CalendarEventViewModel()
{
DateFrom = laterToday,
DateTo = laterToday.AddMinutes(15)
};
return(View(entry));
}
private static IEnumerable <CalendarEventViewModel> GetCalendarEvents(IEnumerable <IEvent> events)
{
var eventViewModels = new List <CalendarEventViewModel>();
foreach (var @event in events)
{
var viewModel = new CalendarEventViewModel
{
Title = @event.Title,
MongoId = @event.MongoId
};
viewModel.TimeFromBson(@event.StartDateTime);
eventViewModels.Add(viewModel);
}
return(eventViewModels);
}
public ActionResult EventsEdit([ModelBinder(typeof(CalendarEventViewModelBinder))] CalendarEventViewModel model)
{
if (ModelState.IsValid)
{
var entity = Mapper.Map <Event>(model);
entity = _eventsRepository.Update(entity);
_timelineService.RegisterActivity(Realm.BG, ActivityType.EventUpdated, User.Id);
Feedback.AddMessageSuccess(CalendarResources.EventEditSuccessMessage);
return(RedirectToAction(nameof(EventsIndex), nameof(CalendarController).RemoveControllerSuffix()));
}
model = BuildModel(model);
return(View("EventManager", model));
}
//[ValidateAntiForgeryToken]
/// <summary>
/// Updates data for an existing CalendarEvent, or creates a new CalendarEvent if the Id is 0
/// </summary>
/// <param name="viewModel">CalendarEvent data</param>
/// <returns>CalendarEvent id</returns>
public IHttpActionResult Upsert(CalendarEventViewModel viewModel)
{
log.Debug("Upsert");
if (viewModel.CalendarEventId > 0)
{
var t = Update(viewModel);
//return Json(true);
//return JsonConvert.SerializeObject(t.CalendarEventId);
return(Ok(t.CalendarEventId));
}
else
{
var t = Create(viewModel);
//return Json(t.CalendarEventId);
//return JsonConvert.SerializeObject(t.CalendarEventId);
return(Ok(t.CalendarEventId));
}
}
public ActionResult CreateEntry(CalendarEventViewModel vm)
{
if (!ModelState.IsValid)
{
return(SiteErrorHandler.GetBadRequestActionResult("<strong>Error:</strong> Input is invalid.", ""));
}
// Date range check.
if (vm.DateFrom > vm.DateTo)
{
return(SiteErrorHandler.GetBadRequestActionResult("<strong>Error:</strong> Start date cannot be after the end date.", ""));
}
var entry = new CalEntry()
{
Title = vm.Title.Trim(),
Description = vm.Description == null ? null : vm.Description.Trim(),
DateFrom = vm.DateFrom,
DateTo = vm.DateTo,
AllDay = vm.AllDay,
UserId = User.Identity.GetUserId()
};
// Save event.
var id = _scheduleRepository.CreateCalendarEntry(entry);
// Return calendar record for fullCalendar.js.
return(Json(new
{
message = "<strong>Success:</strong> Calendar event created.",
calEntry = new
{
id,
title = entry.Title,
start = entry.DateFrom,
end = entry.DateTo,
allDay = entry.AllDay
}
}, JsonRequestBehavior.AllowGet));
}
