public ActionResult MakeAppointment(AppointmentFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.DoctorsList = _unitofWork.Doctors.DoctorsToSelectList();
return(View("AttendanceForm", viewModel));
}
var appoint = new Appointment()
{
DoctorId = viewModel.Doctor,
Doctor = _unitofWork.Doctors.GetDoctor(viewModel.Doctor),
Detail = viewModel.Detail,
PatientId = viewModel.Patient,
StartDateTime = viewModel.GetStartDateTime(),
AppointmentStatus = AppointmentStatus.Pending,
DStatus = true
};
if (_unitofWork.Appointments.ValidateAppointment(viewModel.GetStartDateTime(), viewModel.Doctor))
{
viewModel.DoctorsList = _unitofWork.Doctors.DoctorsToSelectList();
ViewBag.ApptError = "Appointment not available in the choosen Datetime";
return(View(viewModel));
}
_unitofWork.Appointments.AddAppointment(appoint);
_unitofWork.Complete();
return(RedirectToActionPermanent("AllAppointments", "Appointments"));
}
public ActionResult Create(AppointmentFormViewModel viewModel)
{
if (viewModel.GetStartDateTime() < DateTime.Now.AddDays(-1))
{
viewModel.Doctors = _unitOfWork.Doctors.GetAvailableDoctors();
return(View(viewModel));
}
var appointment = new Appointment()
{
StartDateTime = viewModel.GetStartDateTime(),
Detail = viewModel.Detail,
Status = true,
PatientId = viewModel.Patient,
DoctorId = viewModel.Doctor
};
//Check if the slot is available
if (_unitOfWork.Appointments.ValidateAppointment(appointment.StartDateTime, viewModel.Doctor))
{
return(View("InvalidAppointment"));
}
_unitOfWork.Appointments.Add(appointment);
_unitOfWork.Complete();
return(RedirectToAction("Index", "Appointments"));
}
public ActionResult Edit(AppointmentFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.Doctors = _unitOfWork.Doctors.GetDoctors();
viewModel.Patients = _unitOfWork.Patients.GetPatients();
return(View(viewModel));
}
//if (viewModel.GetStartDateTime() < DateTime.Now.AddDays(-1))
//{
// viewModel.Doctors = _unitOfWork.Doctors.GetAvailableDoctors();
// return View(viewModel);
//}
var appointmentInDb = _unitOfWork.Appointments.GetAppointment(viewModel.Id);
//appointmentInDb.Id = viewModel.Id;
//appointmentInDb.StartDateTime = viewModel.GetStartDateTime();
//appointmentInDb.Detail = viewModel.Detail;
appointmentInDb.Status = viewModel.Status;
//appointmentInDb.PatientId = viewModel.Patient;
//appointmentInDb.DoctorId = viewModel.Doctor;
if (!_unitOfWork.Appointments.ValidateAppointment(appointmentInDb.StartDateTime, viewModel.Doctor))
{
return(View("InvalidAppointment"));
}
_unitOfWork.Appointments.Add(appointmentInDb);
_unitOfWork.Complete();
return(RedirectToAction("Index"));
}
public ActionResult Create(AppointmentFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.Profesors = _unitOfWork.Profesors.GetAvailableProfesors();
return(View(viewModel));
}
var appointment = new Appointment()
{
StartDateTime = viewModel.GetStartDateTime(),
Detail = viewModel.Detail,
Status = false,
PatientId = viewModel.Patient,
Profesor = _unitOfWork.Profesors.GetProfesor(viewModel.Profesor)
};
//Check if the slot is available
if (_unitOfWork.Appointments.ValidateAppointment(appointment.StartDateTime, viewModel.Profesor))
{
return(View("InvalidAppointment"));
}
_unitOfWork.Appointments.Add(appointment);
_unitOfWork.Complete();
return(RedirectToAction("Index", "Appointments"));
}
public ActionResult Create(AppointmentFormViewModel viewModel)
{
var currentlyLoggedInUserId = (((System.Security.Claims.ClaimsPrincipal)System.Web.HttpContext.Current.User).Claims).ToList()[0].Value;
var appointment = new Appointment()
{
StartDateTime = viewModel.GetStartDateTime(),
EndDate = viewModel.GetStartDateTime().AddMinutes(30),
Detail = viewModel.Detail,
Status = false,
ApplicationUser = context.Users.SingleOrDefault(p => p.Id == currentlyLoggedInUserId),
Product = context.Products.SingleOrDefault(p => p.Id == viewModel.Product)
};
bool isZero = appointment.Product.isZero();
context.Appointments.Add(appointment);
context.SaveChanges();
if (isZero == true)
{
return(RedirectToAction("AppointmentsOfPatient", "Appointments"));
}
else
{
return(RedirectToAction("NewAppointmentOfPatient", "Appointments"));
}
}
public ActionResult Create(AppointmentFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.Doctors = _unitOfWork.Doctors.GetAvailableDoctors();
return(View(viewModel));
}
var appointment = new AppointmentCreateDto()
{
StartDateTime = viewModel.GetStartDateTime(),
Detail = viewModel.Detail,
Status = false,
PatientId = viewModel.Patient,
DoctorId = viewModel.Doctor
};
var appointmentApi = new AppointmentController(_unitOfWork); // since it is from the same assemnly (need to check the dependency injection)
var result = appointmentApi.CreateAppointment(appointment);
if (result is OkResult)
{
return(RedirectToAction("Index", "Appointments"));
}
// Should with errors being displayed
return(View("Index", viewModel));
}
public ActionResult Create(AppointmentFormViewModel viewModel)
{
//if (!modelstate.isvalid)
//{
// // availabledoctor
// viewmodel.doctors = _context.doctors
// .where(a => a.isavailable == true)
// .tolist();
// return view(viewmodel);
//}
var currentlyLoggedInUserId = (((System.Security.Claims.ClaimsPrincipal)System.Web.HttpContext.Current.User).Claims).ToList()[0].Value;
var appointment = new Appointment()
{
StartDateTime = viewModel.GetStartDateTime(),
Detail = viewModel.Detail,
Status = true,
ApplicationUser = _context.Users.SingleOrDefault(p => p.Id == currentlyLoggedInUserId),
Product = _context.Products.SingleOrDefault(p => p.Id.ToString() == viewModel.Product),
Doctor = _context.Doctors.SingleOrDefault(d => d.Id == viewModel.Doctor)
//Doctor = _unitOfWork.Doctors.GetDoctor(viewModel.Doctor)
};
//Check if the slot is available
//if (_unitOfWork.Appointments.ValidateAppointment(appointment.StartDateTime))
//if (_context.Appointments.Any(a => a.StartDateTime == appntDate && a.DoctorId == id))
// return View("InvalidAppointment");
_context.Appointments.Add(appointment);
_context.SaveChanges();
return(RedirectToAction("AppointmentsOfPatient", "Appointments"));
}
public ActionResult BookDoctor(int id)
{
if (id == null)
{
return(RedirectToAction("index", "Doctors"));
}
else
{
var existingDoctor = _unitOfWork.Doctors.GetDoctor(id);
if (existingDoctor != null)
{
ViewBag.DoctorName = existingDoctor.Name;
var userId = HttpContext.Session.GetString("USERID");
var sessionModel = JsonConvert.DeserializeObject <UserViewModel>(userId);
if (sessionModel != null)
{
var viewModel = new AppointmentFormViewModel
{
Patient = sessionModel.ClientId,
Doctor = id,
Heading = "New Appointment"
};
return(View("Create", viewModel));
}
}
return(RedirectToAction("index", "Doctors"));
}
}
void Scheduler_RecurrenceFormShowing(object sender, DevExpress.Xpf.Scheduler.RecurrenceFormEventArgs e)
{
AppointmentFormViewModel viewModel = e.AppointmentFormViewModel;
e.ViewModel = ViewModelSource.Create(() =>
new CustomRecurrenceDialogViewModel(viewModel, e.ReadOnly)
);
}
public CustomRecurrenceDialogViewModel(AppointmentFormViewModel viewModel, bool readOnly)
: base(viewModel, readOnly)
{
if (viewModel.IsNewAppointment)
{
SetPredefinedValues();
HideRecurrenceTypes();
}
}
public ActionResult Create(string id)
{
var viewModel = new AppointmentFormViewModel
{
ApplicationUser = id,
Products = context.Products.ToList(),
Heading = "New Appointment"
};
return(View(viewModel));
}
//public ActionResult Patients(int id)
//{
// var viewModel = new ProfesorDetailViewModel()
// {
// Appointments = _unitOfWork.Appointments.GetAppointmentByProfesor(id),
// };
// //var upcomingAppnts = _unitOfWork.Appointments.GetAppointmentByProfesor(id);
// return View(viewModel);
//}
public ActionResult Create(int id)
{
var viewModel = new AppointmentFormViewModel
{
Patient = id,
Profesors = _unitOfWork.Profesors.GetAvailableProfesors(),
Heading = "New Appointment"
};
return(View(viewModel));
}
public ActionResult MakeAppointment(int id)
{
var viewModel = new AppointmentFormViewModel
{
Patient = id,
Doctors = _unitofWork.Doctors.GetAvailableDoctors(),
Heading = "New Appointment"
};
viewModel.DoctorsList = _unitofWork.Doctors.DoctorsToSelectList();
return(View(viewModel));
}
public IActionResult SignUpForm(AppointmentFormViewModel a, int timeId) //Adds a new appointment to the database and marks the time slot used by that appointment as unavailable
{
if (ModelState.IsValid)
{
context.Times.Single(t => t.TimeId == timeId).Available = false;
context.Appointments.Add(a.Appointment);
context.SaveChanges();
return(RedirectToAction("Index")); //redirects to the home page
}
else
{
return(View(new AppointmentFormViewModel
{
TimeSlot = context.Times.Single(t => t.TimeId == timeId)
}));
}
}
public ActionResult Create(string id)
{
var viewModel = new AppointmentFormViewModel
{
ApplicationUser = id,
//ApplicationUsers = _context.ApplicationUsers.ToList(),
Products = _context.Products.ToList(),
// AvailableDoctor
Doctors = _context.Doctors
.Where(a => a.IsAvailable == true)
.ToList(),
Heading = "New Appointment"
};
return(View(viewModel));
}
public ActionResult Edit(int id)
{
var appointment = _context.Appointments.Find(id);
var viewModel = new AppointmentFormViewModel()
{
Heading = "New Appointment",
Id = appointment.Id.ToString(),
Date = appointment.StartDateTime.ToString("dd/MM/yyyy"),
Time = appointment.StartDateTime.ToString("HH:mm"),
Detail = appointment.Detail,
Status = appointment.Status,
ApplicationUser = appointment.ApplicationUserId,
//Patients = _unitOfWork.Patients.GetPatients(),
Doctors = _context.Doctors.ToList()
};
return(View(viewModel));
}
public ActionResult Edit(int id)
{
var appointment = _unitOfWork.Appointments.GetAppointment(id);
var viewModel = new AppointmentFormViewModel()
{
Heading = "New Appointment",
Id = appointment.Id,
Date = appointment.StartDateTime.ToString("dd/MM/yyyy"),
Time = appointment.StartDateTime.ToString("HH:mm"),
Detail = appointment.Detail,
Status = appointment.Status,
Patient = appointment.PatientId,
Profesor = appointment.ProfesorId,
//Patients = _unitOfWork.Patients.GetPatients(),
Profesors = _unitOfWork.Profesors.GetProfesors()
};
return(View(viewModel));
}
public ActionResult Edit(AppointmentFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.Profesors = _unitOfWork.Profesors.GetProfesors();
viewModel.Patients = _unitOfWork.Patients.GetPatients();
return(View(viewModel));
}
var appointmentInDb = _unitOfWork.Appointments.GetAppointment(viewModel.Id);
appointmentInDb.Id = viewModel.Id;
appointmentInDb.StartDateTime = viewModel.GetStartDateTime();
appointmentInDb.Detail = viewModel.Detail;
appointmentInDb.Status = viewModel.Status;
appointmentInDb.PatientId = viewModel.Patient;
appointmentInDb.ProfesorId = viewModel.Profesor;
_unitOfWork.Complete();
return(RedirectToAction("Index"));
}
public ActionResult Charge(string stripeToken, string stripeEmail)
{
Stripe.StripeConfiguration.SetApiKey("stripePublishableKey");
Stripe.StripeConfiguration.ApiKey = "stripeSecretKey";
AppointmentFormViewModel GetProductPrice = new AppointmentFormViewModel();
var myCharge = new Stripe.ChargeCreateOptions();
// always set these properties
myCharge.Amount = 100 * (long)context.Products.SingleOrDefault(p => p.Id == GetProductPrice.Product).Price;
myCharge.Currency = "eur";
myCharge.ReceiptEmail = stripeEmail;
myCharge.Description = GetProductPrice.Product.ToString();
myCharge.Source = stripeToken;
myCharge.Capture = true;
var chargeService = new Stripe.ChargeService();
Charge stripeCharge = chargeService.Create(myCharge);
return(View());
}
public ActionResult Edit(AppointmentFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
//viewModel.Doctors = _context.Doctors.ToList();
viewModel.ApplicationUsers = _context.Users.ToList();
return(View(viewModel));
}
var appointmentInDb = _context.Appointments.Find(viewModel.Id);
appointmentInDb.Id = Convert.ToInt32(viewModel.Id);
appointmentInDb.StartDateTime = viewModel.GetStartDateTime();
appointmentInDb.Detail = viewModel.Detail;
appointmentInDb.Status = viewModel.Status;
appointmentInDb.ApplicationUserId = viewModel.ApplicationUser;
//appointmentInDb.DoctorId = viewModel.Doctor;
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult Create(int id)
{
var allDoctor = _unitOfWork.doctorRepository.GetAvailableDoctors();
_logger.LogWarning("{allDoctor} is inside this method", allDoctor);
var viewmodel = new AppointmentFormViewModel
{
Patient = id,
Heading = "New Appointment",
};
foreach (var doctor in allDoctor)
{
viewmodel.DoctorList.Add(new SelectListItem()
{
Value = doctor.Id.ToString(),
Text = doctor.Name
});
}
return(View(viewmodel));
}
public async Task <IActionResult> Create(AppointmentFormViewModel model)
{
if (!ModelState.IsValid)
{
var allDoctor = _unitOfWork.doctorRepository.GetAvailableDoctors();
var viewmodel = new AppointmentFormViewModel
{
Patient = model.Patient,
Heading = "New Appointment",
};
foreach (var doctor in allDoctor)
{
viewmodel.DoctorList.Add(new SelectListItem()
{
Value = doctor.Id.ToString(),
Text = doctor.Name
});
}
return(View(viewmodel));
}
var appointment = new Appointment
{
DateTime = model.GetStartDateTime(),
Details = model.Detail,
contactStatus = ContactStatus.Submitted,
PatientId = model.Patient,
DoctorId = model.Doctor,
};
/* if(_unitOfWork.appoinmentRepository.ValidateAppointment(appointment.DateTime, model.Doctor))
* {
* return View("Invalid Appointment");
* }*/
_unitOfWork.appoinmentRepository.Add(appointment);
_unitOfWork.Complete();
return(RedirectToAction("Appointments", "Appointment"));
}
public ActionResult Create()
{
var userId = HttpContext.Session.GetString("USERID");
var sessionModel = JsonConvert.DeserializeObject <UserViewModel>(userId);
if (sessionModel != null)
{
var viewModel = new AppointmentFormViewModel
{
Patient = sessionModel.ClientId,
Doctors = _unitOfWork.Doctors.GetAvailableDoctors(),
Heading = "New Appointment"
};
return(View(viewModel));
}
else
{
//change this to redirect to the login screen becasuse the only reason is that you are not authorized
return(Redirect("Index"));
}
}
public CustomRecurrenceDialogViewModel(AppointmentFormViewModel viewModel)
: base(viewModel)
{
}
public CustomRecurrenceDialogViewModel(AppointmentFormViewModel viewModel, DevExpress.XtraScheduler.RecurrenceType[] availableRecurrenceTypes, bool readOnly)
: base(viewModel, availableRecurrenceTypes, readOnly)
{
}