private static void UpdateAppointments(SchedulerDataObject dataObject)
{
var currentTenant = caCurrent.CurrentTenant();
var appointmentServices = DependencyResolver.Current.GetService <IAppointmentsService>();
var updAppointments = SchedulerExtension.GetAppointmentsToUpdate <Appointments>("Scheduler", dataObject.FetchAppointments, dataObject.Resources,
AppointmentStorage, ResourceStorage);
foreach (var appointment in updAppointments)
{
var origAppointment = appointmentServices.GetAllActiveAppointments(currentTenant.TenantId).FirstOrDefault(a => a.AppointmentId == appointment.AppointmentId);
if (!appointment.ResourceIDs.Contains("<ResourceIds>"))
{
int ResId = Convert.ToInt32(appointment.ResourceIDs);
origAppointment.ResourceId = ResId;
origAppointment.ResourceIDs =
$"<ResourceIds>\r\n<ResourceId Type = \"System.Int32\" Value = \"{ResId}\" />\r\n</ResourceIds>";
}
else
{
origAppointment.ResourceIDs = appointment.ResourceIDs;
}
appointmentServices.UpdateAppointment(appointment);
}
}
private static void DeleteAppointments(SchedulerDataObject dataObject)
{
var currentTenant = caCurrent.CurrentTenant();
var currentUser = caCurrent.CurrentUser();
var appointmentServices = DependencyResolver.Current.GetService <IAppointmentsService>();
var orderServices = DependencyResolver.Current.GetService <IOrderService>();
var delAppointments = SchedulerExtension.GetAppointmentsToRemove <Appointments>("Scheduler", dataObject.FetchAppointments, dataObject.Resources,
AppointmentStorage, ResourceStorage);
foreach (var appointment in delAppointments)
{
// set IsCanceled flag for appointment
if (appointment != null)
{
appointmentServices.DeleteAppointment(appointment);
}
//get order against appointment
Order SchOrder = orderServices.GetOrderById(appointment.OrderId ?? 0);
// set order status for rescheduling
if (SchOrder != null)
{
orderServices.UpdateOrderStatus(SchOrder.OrderID, (int)OrderStatusEnum.ReAllocationRequired, currentUser.UserId);
}
//cancel notification queues
appointmentServices.CancelNotificationQueuesforAppointment(appointment.AppointmentId);
}
}
static void DeleteAppointments()
{
foreach (Appointment appointment in SchedulerExtension.GetAppointmentsToRemove <Appointment>("Scheduler", Appointments, Resources, AppointmentStorage, ResourceStorage))
{
OutlookDataProvider.DeleteAppointment(appointment);
}
}
static void RemoveAppointments(SchedulerDataSource schedulerDataSource)
{
SchedulerAppointment[] appointmentsToRemove = SchedulerExtension.GetAppointmentsToRemove <SchedulerAppointment>("scheduler",
schedulerDataSource.Appointments, schedulerDataSource.Resources,
Settings.Storage.Appointments, Settings.Storage.Resources);
schedulerDataSource.RemoveSchedulerAppointments(appointmentsToRemove.ToList());
}
static void InsertAppointments(SchedulerDataSource schedulerDataSource)
{
SchedulerAppointment[] appointmentsToInsert = SchedulerExtension.GetAppointmentsToInsert <SchedulerAppointment>("scheduler",
schedulerDataSource.Appointments, schedulerDataSource.Resources,
Settings.Storage.Appointments, Settings.Storage.Resources);
schedulerDataSource.InsertSchedulerAppointments(appointmentsToInsert.ToList());
}
void UpdateAppointment()
{
XPAppointmentViewModel insertedAppt = SchedulerExtension.GetAppointmentToInsert <XPAppointmentViewModel>(
SchedulerHelper.Settings,
GetAppointments(),
GetResources()
);
if (insertedAppt != null)
{
Save(insertedAppt);
}
XPAppointmentViewModel[] updatedAppt = SchedulerExtension.GetAppointmentsToUpdate <XPAppointmentViewModel>(
SchedulerHelper.Settings,
GetAppointments(),
GetResources()
);
foreach (var appt in updatedAppt)
{
Save(appt);
}
XPAppointmentViewModel[] removedAppt = SchedulerExtension.GetAppointmentsToRemove <XPAppointmentViewModel>(
SchedulerHelper.Settings,
GetAppointments(),
GetResources()
);
foreach (var appt in removedAppt)
{
Delete(appt);
}
}
static void UpdateAppointment()
{
DBAppointment[] insertedAppt = SchedulerExtension.GetAppointmentsToInsert <DBAppointment>(SchedulerSettingsHelper.CommonSchedulerSettings,
SchedulerDataHelper.FetchAppointmentsHelperMethod,
SchedulerDataHelper.GetResources());
foreach (var appt in insertedAppt)
{
SchedulerDataHelper.InsertAppointment(appt);
}
DBAppointment[] updatedAppt = SchedulerExtension.GetAppointmentsToUpdate <DBAppointment>(SchedulerSettingsHelper.CommonSchedulerSettings,
SchedulerDataHelper.FetchAppointmentsHelperMethod,
SchedulerDataHelper.GetResources());
foreach (var appt in updatedAppt)
{
SchedulerDataHelper.UpdateAppointment(appt);
}
DBAppointment[] removedAppt = SchedulerExtension.GetAppointmentsToRemove <DBAppointment>(SchedulerSettingsHelper.CommonSchedulerSettings,
SchedulerDataHelper.FetchAppointmentsHelperMethod,
SchedulerDataHelper.GetResources());
foreach (var appt in removedAppt)
{
SchedulerDataHelper.RemoveAppointment(appt);
}
}
static void UpdateAppointments(SchedulerDataObject dataObject)
{
var context = DependencyResolver.Current.GetService <IApplicationContext>();
var updAppointments =
SchedulerExtension
.GetAppointmentsToUpdate <Ganedata.Core.Entities.Domain.MarketRouteSchedule>("RouteScheduler",
dataObject.FetchAppointments, dataObject.Resources,
AppointmentStorage, ResourceStorage);
foreach (var appointment in updAppointments)
{
var origAppointment =
context.MarketRouteSchedules.FirstOrDefault(a => a.MarketRouteScheduleId == appointment.MarketRouteScheduleId);
if (string.IsNullOrEmpty(appointment.WarehouseIDs) || !appointment.WarehouseIDs.Contains("<ResourceIds>"))
{
int ResId = Convert.ToInt32(appointment.WarehouseId);
appointment.WarehouseIDs =
$"<ResourceIds>\r\n<ResourceId Type = \"System.Int32\" Value = \"{ResId}\" />\r\n</ResourceIds>";
}
context.Entry(origAppointment).CurrentValues.SetValues(appointment);
}
context.SaveChanges();
}
static void UpdateAppointment()
{
CarScheduling insertedAppt = SchedulerExtension.GetAppointmentToInsert <CarScheduling>(
SchedulerHelper.Settings,
SchedulerDataHelper.GetAppointments(),
SchedulerDataHelper.GetResources()
);
SchedulerDataHelper.InsertAppointment(insertedAppt);
CarScheduling[] updatedAppt = SchedulerExtension.GetAppointmentsToUpdate <CarScheduling>(
SchedulerHelper.Settings,
SchedulerDataHelper.GetAppointments(),
SchedulerDataHelper.GetResources()
);
foreach (var appt in updatedAppt)
{
SchedulerDataHelper.UpdateAppointment(appt);
}
CarScheduling[] removedAppt = SchedulerExtension.GetAppointmentsToRemove <CarScheduling>(
SchedulerHelper.Settings,
SchedulerDataHelper.GetAppointments(),
SchedulerDataHelper.GetResources()
);
foreach (var appt in removedAppt)
{
SchedulerDataHelper.RemoveAppointment(appt);
}
}
private static void UpdateAppointments()
{
var appointments = AppointmentContext.MarketRouteSchedules.ToList();
var markets = AppointmentContext.Markets.ToList();
var updAppointments = SchedulerExtension.GetAppointmentsToUpdate <MarketRouteSchedule>("Scheduler", appointments, markets,
AppointmentStorage, ResourceStorage);
foreach (var appointment in updAppointments)
{
var origAppointment = appointments.FirstOrDefault(a => a.MarketRouteScheduleId == appointment.MarketRouteScheduleId);
if (!appointment.VehicleIDs.Contains("<VehicleIds>"))
{
int ResId = Convert.ToInt32(appointment.VehicleIDs);
origAppointment.VehicleId = ResId;
origAppointment.VehicleIDs =
$"<VehicleIds>\r\n<VehicleId Type = \"System.Int32\" Value = \"{ResId}\" />\r\n</VehicleIds>";
}
else
{
origAppointment.VehicleIDs = appointment.VehicleIDs;
}
AppointmentContext.Entry(origAppointment);
if (origAppointment != null)
{
origAppointment.AllDay = appointment.AllDay;
origAppointment.StartTime = appointment.StartTime;
origAppointment.EndTime = appointment.EndTime;
origAppointment.Subject = appointment.Subject;
origAppointment.Description = appointment.Description;
origAppointment.Location = appointment.Location;
origAppointment.EventType = appointment.EventType;
origAppointment.RecurrenceInfo = appointment.RecurrenceInfo;
origAppointment.ReminderInfo = appointment.ReminderInfo;
origAppointment.Label = appointment.Label;
origAppointment.Status = appointment.Status;
AppointmentContext.MarketRouteSchedules.Attach(origAppointment);
var entry = AppointmentContext.Entry <MarketRouteSchedule>(origAppointment);
entry.Property(e => e.AllDay).IsModified = true;
entry.Property(e => e.VehicleId).IsModified = true;
entry.Property(e => e.VehicleIDs).IsModified = true;
entry.Property(e => e.StartTime).IsModified = true;
entry.Property(e => e.EndTime).IsModified = true;
entry.Property(e => e.Subject).IsModified = true;
entry.Property(e => e.Description).IsModified = true;
entry.Property(e => e.Location).IsModified = true;
entry.Property(e => e.EventType).IsModified = true;
entry.Property(e => e.RecurrenceInfo).IsModified = true;
entry.Property(e => e.ReminderInfo).IsModified = true;
entry.Property(e => e.Label).IsModified = true;
entry.Property(e => e.Status).IsModified = true;
}
}
AppointmentContext.SaveChanges();
}
void RemoveAppoinments()
{
Schedule[] schedules = SchedulerExtension.GetAppointmentsToRemove <Schedule>("scheduler", SchedulerHelper.DataObject.Appointments,
SchedulerHelper.DataObject.Resources, SchedulerHelper.AppointmentStorage, SchedulerHelper.ResourceStorage);
foreach (var schedule in schedules)
{
SchedulingDBDataProvider.DeleteCarScheduling(schedule);
}
}
void UpdateAppointments()
{
Schedule[] schedules = SchedulerExtension.GetAppointmentsToUpdate <Schedule>("scheduler", SchedulerHelper.DataObject.Appointments,
SchedulerHelper.DataObject.Resources, SchedulerHelper.AppointmentStorage, SchedulerHelper.ResourceStorage);
foreach (var schedule in schedules)
{
SchedulingDBDataProvider.UpdateSchedule(schedule);
}
}
XtraSchedulerReport CreateSchedulerReport()
{
XtraSchedulerReport report = new XtraSchedulerReport();
var printAdapter = SchedulerExtension.GetPrintAdapter(SchedulerDemoHelper.ReportTemplatesSchedulerSettings,
SchedulerDataHelper.DataObject.Appointments, SchedulerDataHelper.DataObject.Resources);
printAdapter.EnableSmartSync = ReportTemplateFileName.ToLower().Contains("trifold");
report.SchedulerAdapter = printAdapter.SchedulerAdapter;
report.LoadLayout(System.Web.HttpContext.Current.Server.MapPath("~/App_Data/SchedulerReportTemplates/" + ReportTemplateFileName));
return(report);
}
private static void InsertAppointments(SchedulerDataObject dataObject)
{
var currentTenant = caCurrent.CurrentTenant();
var appointmentServices = DependencyResolver.Current.GetService <IAppointmentsService>();
var newAppointments = SchedulerExtension.GetAppointmentsToInsert <Appointments>("Scheduler", dataObject.FetchAppointments, dataObject.Resources,
AppointmentStorage, ResourceStorage);
foreach (var appointment in newAppointments)
{
appointmentServices.CreateAppointment(appointment);
}
}
EditableSchedule CreateAppointmentWithReminders()
{
Appointment appointment = new Appointment(AppointmentType.Normal);
appointment.Start = DateTime.Now + TimeSpan.FromMinutes(5) + TimeSpan.FromSeconds(5);
appointment.Duration = TimeSpan.FromHours(2);
appointment.Subject = "Appointment with Reminder";
appointment.HasReminder = true;
appointment.Reminder.TimeBeforeStart = TimeSpan.FromMinutes(5);
appointment.ResourceId = Resource.Empty;
appointment.StatusId = (int)AppointmentStatusType.Busy;
appointment.LabelId = 1;
return(SchedulerExtension.ConvertAppointment <EditableSchedule>(appointment, SchedulerDemoHelper.DefaultAppointmentStorage));
}
static void InsertAppointment()
{
Appointment appointment = SchedulerExtension.GetAppointmentToInsert <Appointment>("Scheduler",
OutlookDataProvider.GetAppointments(),
OutlookDataProvider.GetResources(),
SchedulerHelper.Settings.Storage.Appointments,
SchedulerHelper.Settings.Storage.Resources
);
if (appointment != null)
{
OutlookDataProvider.InsertAppointment(appointment);
}
}
public ActionResult ICalendarImport()
{
UploadedFile[] files = UploadControlExtension.GetUploadedFiles("schedulerAptImporter");
if (files.Count() > 0)
{
try {
EditableSchedule[] schedules = SchedulerExtension.ImportFromICalendar <EditableSchedule>(SchedulerDemoHelper.ExportSchedulerSettings, files[0].FileContent);
CarsDataProvider.SetImportedCarSchedulings(schedules);
}
catch (Exception e) {
TempData["SchedulerErrorText"] = e.Message;
}
}
return(RedirectToAction("ICalendar"));
}
static void UpdateAppointment()
{
List <CustomAppointment> appointmnets = System.Web.HttpContext.Current.Session["AppointmentsList"] as List <CustomAppointment>;
List <CustomResource> resources = System.Web.HttpContext.Current.Session["ResourcesList"] as List <CustomResource>;
CustomAppointment[] insertedAppts = SchedulerExtension.GetAppointmentsToInsert <CustomAppointment>(SchedulerDataHelper.GetSchedulerSettings(), appointmnets, resources);
SchedulerDataHelper.InsertAppointments(insertedAppts);
CustomAppointment[] updatedAppts = SchedulerExtension.GetAppointmentsToUpdate <CustomAppointment>(SchedulerDataHelper.GetSchedulerSettings(), appointmnets, resources);
SchedulerDataHelper.UpdateAppointments(updatedAppts);
CustomAppointment[] removedAppts = SchedulerExtension.GetAppointmentsToRemove <CustomAppointment>(SchedulerDataHelper.GetSchedulerSettings(), appointmnets, resources);
SchedulerDataHelper.RemoveAppointments(removedAppts);
}
static void InsertAppointments(SchedulerDataObject dataObject)
{
var _marketRouteScheduleService = DependencyResolver.Current.GetService <MarketRouteScheduleService>();
var context = DependencyResolver.Current.GetService <IApplicationContext>();
var newAppointments =
SchedulerExtension
.GetAppointmentsToInsert <Ganedata.Core.Entities.Domain.MarketRouteSchedule>("RouteScheduler",
dataObject.FetchAppointments, dataObject.Resources,
AppointmentStorage, ResourceStorage);
foreach (var appointment in newAppointments)
{
context.MarketRouteSchedules.Add(appointment);
}
context.SaveChanges();
}
static void UpdateAppointment()
{
EFAppointment insertedAppt = SchedulerExtension.GetAppointmentToInsert <EFAppointment>(SchedulerSettingsHelper.CommonSchedulerSettings,
SchedulerDataHelper.GetAppointments(), SchedulerDataHelper.GetResources());
SchedulerDataHelper.InsertAppointment(insertedAppt);
EFAppointment[] updatedAppt = SchedulerExtension.GetAppointmentsToUpdate <EFAppointment>(SchedulerSettingsHelper.CommonSchedulerSettings,
SchedulerDataHelper.GetAppointments(), SchedulerDataHelper.GetResources());
foreach (var appt in updatedAppt)
{
SchedulerDataHelper.UpdateAppointment(appt);
}
EFAppointment[] removedAppt = SchedulerExtension.GetAppointmentsToRemove <EFAppointment>(SchedulerSettingsHelper.CommonSchedulerSettings,
SchedulerDataHelper.GetAppointments(), SchedulerDataHelper.GetResources());
foreach (var appt in removedAppt)
{
SchedulerDataHelper.RemoveAppointment(appt);
}
}
static void DeleteAppointments(SchedulerDataObject dataObject)
{
var context = DependencyResolver.Current.GetService <IApplicationContext>();
var delAppointments =
SchedulerExtension
.GetAppointmentsToRemove <Ganedata.Core.Entities.Domain.MarketRouteSchedule>("RouteScheduler",
dataObject.FetchAppointments, dataObject.Resources,
AppointmentStorage, ResourceStorage);
foreach (var appointment in delAppointments)
{
var delAppointment =
context.MarketRouteSchedules.FirstOrDefault(a => a.MarketRouteScheduleId == appointment.MarketRouteScheduleId);
if (delAppointment != null)
{
delAppointment.IsCanceled = true;
}
}
context.SaveChanges();
}
void UpdateAppointment()
{
ScheduleCalendar insertedAppt = SchedulerExtension.GetAppointmentToInsert <ScheduleCalendar>("scheduler", SchedulerDataHelper.GetAppointments(),
SchedulerDataHelper.GetResources(), SchedulerDataHelper.DefaultAppointmentStorage, SchedulerDataHelper.DefaultResourceStorage);
SchedulerDataHelper.InsertAppointment(insertedAppt);
ViewData["EditableSchedule"] = insertedAppt;
ScheduleCalendar[] updatedAppt = SchedulerExtension.GetAppointmentsToUpdate <ScheduleCalendar>("scheduler", SchedulerDataHelper.GetAppointments(),
SchedulerDataHelper.GetResources(), SchedulerDataHelper.DefaultAppointmentStorage, SchedulerDataHelper.DefaultResourceStorage);
foreach (var appt in updatedAppt)
{
SchedulerDataHelper.UpdateAppointment(appt);
}
ScheduleCalendar[] removedAppt = SchedulerExtension.GetAppointmentsToRemove <ScheduleCalendar>("scheduler", SchedulerDataHelper.GetAppointments(),
SchedulerDataHelper.GetResources(), SchedulerDataHelper.DefaultAppointmentStorage, SchedulerDataHelper.DefaultResourceStorage);
foreach (var appt in removedAppt)
{
SchedulerDataHelper.RemoveAppointment(appt);
}
}
static void UpdateAppointment()
{
DBAppointment[] insertedAppointments = SchedulerExtension.GetAppointmentsToInsert <DBAppointment>("scheduler", SchedulerDataHelper.GetAppointments(),
SchedulerDataHelper.GetResources(), SchedulerStorageProvider.DefaultAppointmentStorage, SchedulerStorageProvider.DefaultResourceStorage);
foreach (var appt in insertedAppointments)
{
AppointmentDataAccessor.InsertAppointment(appt);
}
DBAppointment[] updatedAppointments = SchedulerExtension.GetAppointmentsToUpdate <DBAppointment>("scheduler", SchedulerDataHelper.GetAppointments(),
SchedulerDataHelper.GetResources(), SchedulerStorageProvider.DefaultAppointmentStorage, SchedulerStorageProvider.DefaultResourceStorage);
foreach (var appt in updatedAppointments)
{
AppointmentDataAccessor.UpdateAppointment(appt);
}
DBAppointment[] removedAppointments = SchedulerExtension.GetAppointmentsToRemove <DBAppointment>("scheduler", SchedulerDataHelper.GetAppointments(),
SchedulerDataHelper.GetResources(), SchedulerStorageProvider.DefaultAppointmentStorage, SchedulerStorageProvider.DefaultResourceStorage);
foreach (var appt in removedAppointments)
{
AppointmentDataAccessor.RemoveAppointment(appt);
}
}
public static T[] GetAppointmentsToRemove <T>(SchedulerDataObject dataObject, MVCxAppointmentStorage appointmentStorage) where T : ScheduleBase
{
return(SchedulerExtension.GetAppointmentsToRemove <T>("scheduler", dataObject.Appointments, dataObject.Resources,
appointmentStorage, SchedulerDemoHelper.DefaultResourceStorage));
}
public ActionResult ICalendarExport()
{
return(SchedulerExtension.ExportToICalendar(SchedulerDemoHelper.ExportSchedulerSettings, CarsDataProvider.GetImportedCarSchedulings()));
}
