public ScheduleDto GetSchedule(ScheduleRequest request)
{
string url = rootUrl + "/conferences/" + request.conferenceSlug + "/schedule/" + request.userSlug;
var client = new WebClient { Encoding = System.Text.Encoding.UTF8 };
client.Headers[HttpRequestHeader.Accept] = "application/json";
var returnString = client.DownloadString(new Uri(url));
var schedule = JsonSerializer.DeserializeFromString<ScheduleDto>(returnString);
return schedule;
}
public static bool GetScheduleEventForTVProgramme(CommonEPG.TVProgramme tvp, ref ScheduleEvent matchingEvent, ref ScheduleRequest matchingRequest)
{
CommonEPG.TVService tvc = EPGManager.TVServiceWithIDOrNull(tvp.ServiceID);
if (tvc == null)
{
return(false);
}
return(GetScheduleEventAtExactTimeOnChannel(tvp.StartTimeDT(), tvc.Callsign, false, "", ref matchingEvent, ref matchingRequest));
}
public IActionResult GetShedules([FromQuery] ScheduleRequest request)
{
request.BranchId = BranchId;
return(Ok(_customerScheduleService.GetShedules(request)));
}
public void AddScheduleToValidationServerVerificationWorks(IValidatorRunner validatorRunner, IScheduleCallback scheduleCallbacker, IValidationScheduler validatorScheduler, IValidatorProvider validatorProvider, IList <IValidatorInstance> validatorInstancesToReturn, string unknownInstanceId, string includedAndNotScheduledValidatorIdInstanceId,
string includedAndScheduledValidatorIdInstanceId, string includedAndScheduledValidatorId, string includedAndNotScheduledValidatorId, string unknownProxyId, IList <IValidatorProxy> validatorProxiesToReturn, IValidationResultHandler[] notificationHandler, IPublishEndpoint publishEndpoint)
{
var includedProxy = Substitute.For <IValidatorProxy>();
var includedInstance = Substitute.For <IValidatorInstance>();
includedProxy.ValidatorId.ReturnsForAnyArgs(includedAndNotScheduledValidatorId);
includedInstance.ValidatorInstanceId.ReturnsForAnyArgs(includedAndNotScheduledValidatorIdInstanceId);
var includedAndScheduledProxy = Substitute.For <IValidatorProxy>();
var includedAndScheduledInstance = Substitute.For <IValidatorInstance>();
includedAndScheduledProxy.ValidatorId.ReturnsForAnyArgs(includedAndScheduledValidatorId);
includedAndScheduledInstance.ValidatorInstanceId.ReturnsForAnyArgs(includedAndScheduledValidatorIdInstanceId);
validatorProvider.GetValidatorProxy(includedProxy.ValidatorId).Returns(includedProxy);
validatorProvider.GetValidatorProxy(includedAndScheduledProxy.ValidatorId).Returns(includedAndScheduledProxy);
validatorProvider.GetValidatorInstance(includedAndScheduledValidatorId, includedAndScheduledValidatorIdInstanceId).Returns(includedAndScheduledInstance);
validatorProvider.GetValidatorInstance(includedAndNotScheduledValidatorId, includedAndNotScheduledValidatorIdInstanceId).Returns(includedInstance);
validatorScheduler.IsValidationScheduled(includedAndNotScheduledValidatorId, includedAndNotScheduledValidatorIdInstanceId).Returns(false);
validatorScheduler.IsValidationScheduled(includedAndScheduledValidatorId, includedAndScheduledValidatorIdInstanceId).Returns(true);
validatorProvider.When(x => x.GetValidatorProxy(Arg.Is <string>(d => d != includedAndNotScheduledValidatorId && d != includedAndScheduledValidatorId))).Do(g => { throw new Exception(); });
validatorProvider.When(x => x.GetValidatorInstance(Arg.Any <string>(), Arg.Is <string>(d => d != includedAndNotScheduledValidatorIdInstanceId && d != includedAndScheduledValidatorIdInstanceId))).Do(g => { throw new Exception(); });
var vs = new ValidationServer(validatorProvider, validatorRunner, validatorScheduler, scheduleCallbacker, publishEndpoint, notificationHandler);
ScheduleRequest validRequest = new ScheduleRequest(includedProxy.ValidatorId, includedInstance.ValidatorInstanceId, "* * * * *");
ScheduleRequest requestWithInValidInstance = new ScheduleRequest(includedProxy.ValidatorId, unknownInstanceId, "* * * * *");
ScheduleRequest requestWithInValidProxy = new ScheduleRequest(unknownProxyId, unknownInstanceId, "* * * * *");
ScheduleRequest alreadyScheduledRequest = new ScheduleRequest(includedAndScheduledValidatorId, includedAndScheduledValidatorIdInstanceId, "* * * * *");
//This do not throw - Pass Verification
vs.AddValidationsToSchedule(new List <ScheduleRequest>()
{
validRequest
});
//This throw cause proxy is not available
Assert.ThrowsAny <Exception>(() => vs.AddValidationsToSchedule(new List <ScheduleRequest>()
{
requestWithInValidInstance
}));
//This throws cause instance is not available
Assert.ThrowsAny <Exception>(() => vs.AddValidationsToSchedule(new List <ScheduleRequest>()
{
requestWithInValidInstance
}));
//This throws cause item is already scheduled is not available
Assert.ThrowsAny <Exception>(() => vs.AddValidationsToSchedule(new List <ScheduleRequest>()
{
alreadyScheduledRequest
}));
}
public void HangFireItemScheduledCronTabInvalid(string validatorId, string validatorInstanceId, string cronTabExpressionInvalid)
{
IScheduleRequest scheduleRequest = new ScheduleRequest(validatorId, validatorInstanceId, cronTabExpressionInvalid);
Assert.ThrowsAny <Exception>(() => this._hangFireScheduler.AddValidationToSchedule(scheduleRequest));
}
public IActionResult Post([FromBody] ScheduleRequest scheduleRequest)
{
appointmentManager.CreateAppointment(scheduleRequest);
return(Ok());
}
/// <summary>
/// Enqueues a task on the target taskprocessor object
/// </summary>
/// <param name="task">the task selected for execution</param>
protected void EnqueueTaskOnTarget(ScheduleRequest task)
{
task.Target.TaskScheduled(new TaskContainer {
Request = task, Task = task.Task
});
}
/// <summary>
/// Executes a task that was previously scheduled if appropriate
/// </summary>
/// <param name="task">the task that was requested for execution</param>
/// <param name="action">the action that is performed to the provided task</param>
public virtual bool RunScheduledTask(ScheduleRequest task, Action <ITask> action)
{
action(task.Task);
return(true);
}
public IEnumerable <BillModel> Filter(IEnumerable <BillModel> billModels, ScheduleRequest request)
{
return(scheduleFilters.Aggregate(billModels, (current, filter) => filter.Filter(current, request)));
}
public async Task <int> Schedule(ScheduleRequest request)
{
//Lấy toàn bộ những lớp học phần theo học kỳ & năm học
var lopHocPhans = _context.LopHocPhans.Where(
x => x.HK_HocKy.Equals(request.HocKy) &&
x.HK_NamHoc.Equals(request.NamHoc))
.ToList();
//Tạo biến random để random buổi & ngày học
Random random = new Random();
//Random ngày học và buổi học của lớp đầu tiên
int randomBuoiHoc = random.Next(1, 3);
lopHocPhans[0].BuoiHoc = RandomBuoiHoc(randomBuoiHoc);
int randomNgayHoc = random.Next(2, 8);
lopHocPhans[0].NgayHoc = RandomNgayHoc(randomNgayHoc);
//Tạo danh sách lớp học phần đã tạo lịch thành công
var scheduledLopHocPhan = new List <LopHocPhan>();
scheduledLopHocPhan.Add(lopHocPhans[0]);
for (int current = 1; current < lopHocPhans.Count(); current++)
{
//Kiểm tra giảng viên tại row hiện tại có tồn tại trong list đã sắp xếp chưa, và kiểm tra gv có bận buổi dạy đó chưa
//true là đã bận
bool checkGiangVien = true;
//Kiểm tra phòng học tại row hiện tại có tồn tại trong list đã sắp xếp chưa, và kiểm tra phòng đã có lớp khác sự dụng không
//true là đã bận
bool checkPhong = true;
//Điều kiện ngừng lặp
int loopCount = 1;
//Nếu giảng viên hoặc phòng học tại row hiện tại đã bận, random 1 buổi khác
//loopCount = lặp qua số lượng phòng được request * 21 buổi để tìm buổi trống
while ((checkGiangVien || checkPhong) && loopCount <= request.RoomCount * 21)
{
//Random ngày học và buổi học cho row hiện tại
int randomBuoi = random.Next(1, 4);
lopHocPhans[current].BuoiHoc = RandomBuoiHoc(randomBuoi);
int randomNgay = random.Next(2, 9);
lopHocPhans[current].NgayHoc = RandomNgayHoc(randomNgay);
//Kiểm tra giảng viên tại row hiện tại có tồn tại trong list đã sắp xếp chưa, và kiểm tra gv có bận buổi dạy đó chưa
checkGiangVien = scheduledLopHocPhan.Any(
x => x.ID_GiangVien == lopHocPhans[current].ID_GiangVien &&
x.BuoiHoc == lopHocPhans[current].BuoiHoc &&
x.NgayHoc == lopHocPhans[current].NgayHoc);
//Random phòng mới cho ngày học của row hiện tại
var listPhong = _context.Phongs.ToList();
var randomPhong = random.Next(request.RoomCount);
lopHocPhans[current].ID_Phong = listPhong[randomPhong].ID;
//Kiểm tra phòng học tại row hiện tại có tồn tại trong list đã sắp xếp chưa, và kiểm tra phòng đã có lớp khác sự dụng không
checkPhong = scheduledLopHocPhan.Any(
x => x.ID_Phong == lopHocPhans[current].ID_Phong &&
x.BuoiHoc == lopHocPhans[current].BuoiHoc &&
x.NgayHoc == lopHocPhans[current].NgayHoc);
loopCount++;
}
//Thêm lớp học phần vào list cần check
scheduledLopHocPhan.Add(lopHocPhans[current]);
}
return(await _context.SaveChangesAsync());
}
public Task <ScheduleResponse> GetScheduleAsync(ScheduleRequest request, CancellationToken cancellationToken)
{
return(CallAsync <ScheduleRequest, CancellationToken, ScheduleResponse>(x => x.GetScheduleAsync, request, cancellationToken));
}
public EventSyncResponse CourseSchedule(ScheduleRequest model)
{
public string getData(ScheduleRequest request)
{
return(getWorkShiftOfEmp(request));
}
public List <Data.Model.Schedule> Get([FromQuery] ScheduleRequest request)
{
return(_service.Get(request));
}
public static bool GetScheduleEventAtExactTimeOnChannel(DateTime exactTime, string callsign, bool matchTitleStart, string txtTitleStartsWith, ref ScheduleEvent matchingEvent, ref ScheduleRequest matchingRequest)
{
// We have a channel to search for, what's the service ID
string svcID = EPGManager.ServiceIDFromCallsign(callsign);
// So now bother to get the events
List <ScheduleEvent> theList = GetScheduleEventsAroundExactTime(exactTime, 3);
foreach (ScheduleEvent se in theList)
{
if (matchTitleStart)
{
string seTitle = (string)se.GetExtendedProperty("Title");
if (!seTitle.ToLowerInvariant().StartsWith(txtTitleStartsWith.ToLowerInvariant()))
{
continue; // ie Do not match
}
}
if ((string)se.GetExtendedProperty("ServiceID") == svcID)
{
matchingEvent = se;
// Match schedule request, if there is one
try
{
matchingRequest = se.GetScheduleRequest();
}
catch
{
matchingRequest = null;
}
return(true);
}
}
return(false); // no match
}
/// <summary>
/// Schedules a task for execution
/// </summary>
/// <param name="task">the task that needs to be executed</param>
/// <returns>a value indicating whether the task was scheduled</returns>
public virtual bool ScheduleTask(ScheduleRequest task)
{
EnqueueTaskOnTarget(task);
return(true);
}
public async Task Load()
{
var userModel = await _userService.GetById <Data.Model.Users>(APIService.UserID);
if (userModel != null)
{
var request = new ScheduleRequest()
{
userName = userModel.FirstName,
userLastName = userModel.LastName,
AdminSearch = false
};
var list = await _userSchedulesService.Get <List <Data.Model.Schedule> >(request);
userSchedulesList.Clear();
foreach (var x in list)
{
userSchedulesList.Add(x);
}
}
userActiveScheduleList.Clear();
foreach (var s in userSchedulesList)
{
if (s.ScheduleStatusID == 1)
{
userActiveScheduleList.Add(s);
}
}
if (userActiveScheduleList.Count() > 0)
{
ActiveSchedule = userActiveScheduleList.First();
}
if (ActiveSchedule != null)
{
ScheduleVM = await _scheduleService.GetById <Data.ViewModel.ScheduleVM>(ActiveSchedule.ScheduleID);
var listOffer = await _offerService.Get <List <Data.ViewModel.OffersVM> >(new OfferSearchRequest()
{
ScheduleID = ScheduleVM.ScheduleID
});
if (listOffer.Count() > 0)
{
OfferVM = listOffer.First();
}
if (ScheduleVM.offerCreated)
{
sendMessage = true;
}
if (OfferVM != null)
{
if (OfferVM.partsSelected)
{
sendMessage = false;
}
}
}
}
/// <summary>
/// Executes a task that was previously scheduled if appropriate
/// </summary>
/// <param name="task">the task that was requested for execution</param>
/// <param name="action">the action that is performed to the provided task</param>
public virtual async Task <bool> RunScheduledTaskAsync(ScheduleRequest task, Func <ITask, Task> action)
{
await action(task.Task);
return(true);
}
public string getData(ScheduleRequest request)
{
return(getDataHisAttendance(request));
}
/// <summary>
/// Integrates a task into the runtime environment.
/// </summary>
/// <param name="task">the Schedule - Request that needs to be re-integrated after deserialization</param>
protected void IntegrateTaskOnTarget(ScheduleRequest task)
{
task.Target.IntegrateTask(task.Task);
task.IntegrateRequest(this);
}
/// <summary>
/// Gets the games by the request specified
/// </summary>
/// <param name="request">The options to retrieve games by</param>
/// <returns>Games matching the request</returns>
public async Task <List <Date> > GetSchedule(ScheduleRequest request)
{
return(JsonConvert.DeserializeObject <ScheduleResponse>(
await DoRequest($"schedule?{request}")
).Dates);
}
public void HangFireItemEditNonExistingScheduleThrows(string validatorId, string validatorInstanceId)
{
IScheduleRequest scheduleRequest = new ScheduleRequest(validatorId, validatorInstanceId, CronTabExpressionRunHourly);
Assert.ThrowsAny <Exception>(() => this._hangFireScheduler.EditValidationSchedule(scheduleRequest));
}
/// <summary>
/// Create a meeting for selected time by user.
/// </summary>
/// <param name="meeting">Object containing details required for meeting creation.</param>
/// <param name="token">User Active Directory access token.</param>
/// <returns>Meeting response.</returns>
public async Task <CreateEventResponse> CreateMeetingAsync(CreateEvent meeting, string token)
{
DateTime.TryParse(meeting.Time, out DateTime localTime);
var startDateTime = localTime.AddMinutes(Constants.DurationGapFromNow.Minutes);
var endDateTime = startDateTime.AddMinutes(meeting.Duration);
ScheduleRequest scheduleRequest = new ScheduleRequest
{
StartDateTime = new DateTimeAndTimeZone()
{
DateTime = startDateTime, TimeZone = meeting.TimeZone
},
EndDateTime = new DateTimeAndTimeZone()
{
DateTime = endDateTime, TimeZone = meeting.TimeZone
},
Schedules = new List <string>(),
};
scheduleRequest.Schedules.Add(meeting.RoomEmail);
var roomScheduleResponse = await this.meetingProvider.GetRoomsScheduleAsync(scheduleRequest, token).ConfigureAwait(false);
if (roomScheduleResponse.ErrorResponse != null)
{
// Graph API returned error message.
return(new CreateEventResponse {
StatusCode = roomScheduleResponse.StatusCode, ErrorResponse = roomScheduleResponse.ErrorResponse
});
}
if (roomScheduleResponse.Schedules?.FirstOrDefault()?.ScheduleItems?.Count == 0)
{
CreateEventRequest request = new CreateEventRequest()
{
Attendees = new List <Attendee>(),
Body = new Body {
Content = Strings.MeetingBody, ContentType = "HTML"
},
End = new DateTimeAndTimeZone {
DateTime = endDateTime, TimeZone = meeting.TimeZone
},
Start = new DateTimeAndTimeZone {
DateTime = startDateTime, TimeZone = meeting.TimeZone
},
Subject = Strings.MeetingBody,
Location = new Location {
DisplayName = meeting.RoomName
},
};
request.Attendees.Add(new Attendee {
EmailAddress = new EmailAddress {
Address = meeting.RoomEmail, Name = meeting.RoomName
}, Type = "required"
});
return(await this.meetingProvider.CreateMeetingAsync(request, token).ConfigureAwait(false));
}
else
{
return(new CreateEventResponse
{
ErrorResponse = new App.BookAThing.Common.Models.Error.ErrorResponse
{
Error = new App.BookAThing.Common.Models.Error.Error
{
StatusCode = "ScheduleExist",
ErrorMessage = "Schedule for room exist",
},
},
});
}
}
public Schedule CreateSchedule(string installedAppId, ScheduleRequest scheduleRequest)
{
return(_schedulesApi.CreateSchedule(installedAppId, _accessToken, scheduleRequest));
}
public async Task SendRequest()
{
var requestsList = await _requestByClientService.Get <List <Data.ViewModel.RequestVM> >(null);
if (requestsList.Count() > 0)
{
foreach (var x in requestsList)
{
if (x.UserID == APIService.UserID)
{
await Application.Current.MainPage.DisplayAlert("Upozorenje", "Imate već jedan aktivan zahtjev za termin servisiranja u nekom od auto servisa. Da bi poslali zahtjev za servisranjem nekom od auto servisa, ne smijete imati trenutno aktivnih zahtjeva(zahtjev koji je na čekanju i nije obrađen).", "OK");
return;
}
}
}
var userModel = await _userService.GetById <Data.Model.Users>(APIService.UserID);
ScheduleRequest schReq = new ScheduleRequest()
{
userName = userModel.FirstName,
userLastName = userModel.LastName
};
var schedulesList = await _scheduleService.Get <List <Data.Model.Schedule> >(schReq);
if (schedulesList.Count() > 0)
{
foreach (var x in schedulesList)
{
if (x.ScheduleStatusID == 1)
{
await Application.Current.MainPage.DisplayAlert("Upozorenje", "Trenutno imate aktivan termin u auto servisu: " + x.CarServiceName + ". Trenutni termin mora biti završen(okončan) da bi mogli poslati novi zahtjev za servisiranjem u ovaj ili neki drugi auto servis!", "OK");
return;
}
}
}
var request = new RequestUpsert()
{
DateOfRequest = DateTime.Now,
UserID = APIService.UserID,
CarServiceID = modelCS.CarServiceID,
RequestStatusID = 1,
};
foreach (var x in SelectedServicesList)
{
request._selectedServicesList.Add(new Data.Model.Services()
{
ServiceID = x.ServiceID
});
}
var modelReq = await _requestService.Insert <Data.Model.Request>(request);
if (modelReq != null)
{
await Application.Current.MainPage.DisplayAlert("Obrada uspješna.", "Uspješno ste poslali zahtjev za termin servisiranja.", "OK");
return;
}
}
