internal IFacadeUpdateResult <ScheduleEventData> SaveScheduleEvent(ScheduleEventDto dto) { ArgumentValidator.IsNotNull("dto", dto); FacadeUpdateResult <ScheduleEventData> result = new FacadeUpdateResult <ScheduleEventData>(); IScheduleEventService service = UnitOfWork.GetService <IScheduleEventService>(); ScheduleEvent instance = RetrieveOrNew <ScheduleEventData, ScheduleEvent, IScheduleEventService>(result.ValidationResult, dto.Id); if (result.IsSuccessful) { instance.Name = dto.Name; instance.ScheduledTime = dto.ScheduledTime; instance.ObjectId = dto.ObjectId; instance.ObjectTypeId = dto.ObjectTypeId; instance.ReccuringTypeId = dto.ReccuringTypeId; instance.StartDate = dto.StartDate; instance.EndDate = dto.EndDate; var saveQuery = service.Save(instance); result.AttachResult(instance.RetrieveData <ScheduleEventData>()); result.Merge(saveQuery); } return(result); }
public static ScheduleEvent CheckScheuleEvent(string text) { ScheduleEvent temp = ScheduleEvent.None; switch (text) { case INST_Schedule_None: temp = ScheduleEvent.None; break; case INST_Schedule_DiscountFoodStore: temp = ScheduleEvent.DiscountFoodStore; break; case INST_Schedule_ClothingFestival101: temp = ScheduleEvent.ClothingFestival101; break; case INST_Schedule_ClothingFestival202: temp = ScheduleEvent.ClothingFestival202; break; case INST_Schedule_ClothingFestival303: temp = ScheduleEvent.ClothingFestival303; break; case INST_Schedule_ClothingFestival404: temp = ScheduleEvent.ClothingFestival404; break; case INST_Schedule_Project: temp = ScheduleEvent.Project; break; case INST_Schedule_Class: temp = ScheduleEvent.Class; break; case INST_Schedule_MysticFestival1st: temp = ScheduleEvent.MysticFestival1st; break; case INST_Schedule_MysticFestival2nd: temp = ScheduleEvent.MysticFestival2nd; break; case INST_Schedule_MysticFestival3rd: temp = ScheduleEvent.MysticFestival3rd; break; case INST_Schedule_MysticFestival4th: temp = ScheduleEvent.MysticFestival4th; break; case INST_Schedule_Birthday: temp = ScheduleEvent.Birthday; break; } return(temp); }
/// <summary> /// Maps the event definition into the the schedule view model. /// </summary> /// <param name="eventDefinition"></param> /// <returns></returns> public ScheduleViewModel Map(EventDefinition eventDefinition) { var times = GetTimes(eventDefinition); List <ScheduleSession> scheduleSessions = eventDefinition .Sessions.Select(s => new ScheduleSession { SessionId = s.SessionId, Title = s.Title, StartTime = DateTime.SpecifyKind(s.StartTime, DateTimeKind.Utc), Duration = s.Duration, RoomNumber = s.RoomNumber, Speaker = s.Speaker }).ToList(); var scheduleEvent = new ScheduleEvent { EventDefinitionId = eventDefinition.EventDefinitionId, Rooms = eventDefinition.RoomNumber, Sessions = scheduleSessions }; var viewModel = new ScheduleViewModel { EventDefinition = scheduleEvent, Times = times }; return(viewModel); }
/// <summary> /// Construct a passive data structure to hold chart information /// </summary> /// <param name="row"></param> /// <param name="dateTime"></param> /// <param name="task"></param> public ChartInfo(int row, DateTime dateTime, ScheduleEvent task) : this() { Row = row; DateTime = dateTime; Task = task; }
public async Task <IActionResult> OnPostScheduleAsync() { AddScheduleEvent ASSE = new AddScheduleEvent(); ScheduleEvent SE = new ScheduleEvent(); SE.Ended = false; SE.GameID = 1; SE.MinutesToAddOnTrigger = int.Parse(Request.Form["MinutesToAddOnTrigger"]); SE.NextTrigger = DateTime.Parse(Request.Form["NextTrigger"].ToString()); SE.Notes = Request.Form["Notes"]; SE.NumberOfTimesToTrigger = int.Parse(Request.Form["NumberOfTimesToTrigger"]); SE.NumberOfTimesTriggered = 0; SE.ScheduelID = int.Parse(Request.Form["ScheduleID"]); ASSE.SE = SE; ASSE.ChangeEvents = Request.Form["IDList"]; HttpResponseMessage PostResponse = await DS.PostAsync(ASSE, "bot/AddScheduleEvent"); string content = await PostResponse.Content.ReadAsStringAsync(); SimpleResponse SR = JsonConvert.DeserializeObject <SimpleResponse>(content); string response = await DS.GetAsync("bot/GetInfoForScheduleEventAdd"); ASEP = JsonConvert.DeserializeObject <AddSchedulEventPrep>(response); return(Page()); }
private void ScheduleLoad(int uID) { try { DBA db = DBA.Instance; db.connect(); var con = db.getConnection(); con.Open(); string query = "SELECT * FROM schedule WHERE user_id = " + uID + "ORDER BY startH ASC"; using (SqlCommand cmd = new SqlCommand(query, con)) { using (SqlDataReader r = cmd.ExecuteReader()) { while (r.Read()) { int cID = r.GetInt32(2); string day = r.GetString(4); string title = r.GetString(3) + " " + r.GetString(8); string start = r.GetInt32(5).ToString() + ":00"; string end = r.GetInt32(6).ToString() + ":00"; ScheduleEvent block = new ScheduleEvent(r.GetInt32(1), r.GetInt32(2), r.GetString(3), r.GetString(4), r.GetInt32(5), r.GetInt32(6), r.GetInt32(7), r.GetString(8)); putInSchedule(block.Day, block.Class_name, block.Course_name, block.Start, block.End); } } } } catch (SqlException ex) { MessageBox.Show(ex.Message, "SQL Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public Form1() { InitializeComponent(); schedulerControl1.Init(projectManager); projectManager.Start = DateTime.Now.AddDays(-3); var task = new ScheduleEvent(1) { Name = "Hello", Slack = TimeSpan.FromDays(0.5) }; projectManager.Add(task); projectManager.SetStart(task, DateTime.Now.AddDays(3)); projectManager.SetEnd(task, DateTime.Now.AddDays(5)); var task2 = new ScheduleEvent(0) { Name = "Hello" }; projectManager.Add(task2); projectManager.SetStart(task2, DateTime.Now.AddDays(3)); projectManager.SetEnd(task2, DateTime.Now.AddDays(5)); var task3 = new ScheduleEvent(0) { Name = "Hello" }; projectManager.Add(task3); projectManager.SetStart(task3, DateTime.Now.AddDays(6)); projectManager.SetEnd(task3, DateTime.Now.AddDays(7)); }
public static void CopyValidEvents(Schedule schedule, ScheduleEventCollection eventList, string postfix) { if (eventList.Count == 0) return; ScheduleEventCollection newEventsList = new ScheduleEventCollection(); foreach (ScheduleEvent srcEvent in eventList) { StringBuilder sb = new StringBuilder(); sb.Append(DescriptionHeaderName); sb.AppendLine(Resources.CrossSyncDescription); if (!string.IsNullOrEmpty(srcEvent.Description)) { sb.AppendLine(); sb.Append(srcEvent.Description); } ScheduleEvent newEvent = new ScheduleEvent(); newEvent.EventType = srcEvent.IsBanner ? ScheduleEventType.Banner : ScheduleEventType.Normal; newEvent.PublicType = srcEvent.IsPublic ? SchedulePublicType.Public : SchedulePublicType.Private; newEvent.Start = srcEvent.Start; newEvent.End = srcEvent.End; newEvent.AllDay = srcEvent.AllDay; newEvent.StartOnly = srcEvent.StartOnly; newEvent.Plan = srcEvent.Plan; newEvent.Detail = srcEvent.Detail + postfix; newEvent.Description = sb.ToString(); newEvent.UserIds.Add(schedule.App.UserId); newEventsList.Add(newEvent); } if (newEventsList.Count == 0) return; schedule.AddEvents(newEventsList); }
/// <summary> /// Asynchronously Create ScheduleEvents. /// </summary> /// <remarks> /// Add a single schedule event. /// </remarks> /// <param name="scheduleEvent"> /// The <see cref="ScheduleEvent"/> object to be created. /// </param> /// <returns> /// The <see cref="ScheduleEvent"/> object that was created, along with /// an output instance of the <see cref="ResultsMeta"/> class containing additional data. /// </returns> public async Task <(ScheduleEvent, ResultsMeta)> CreateScheduleEventAsync( ScheduleEvent scheduleEvent) { (IList <ScheduleEvent> scheduleEvents, ResultsMeta resultsMeta) = await CreateScheduleEventsAsync(new[] { scheduleEvent }, default).ConfigureAwait(false); return(scheduleEvents.FirstOrDefault(), resultsMeta); }
protected void SaveClicked(object o, EventArgs e) { if (!SecurityContextManager.Current.CurrentURL.Contains("New")) { var se = new ScheduleEventServices().GetByID(((ScheduleEvent)SecurityContextManager.Current.CurrentItem.ItemReference).ID); se.Description = tbDescription.Text; se.EventTypeID = Convert.ToInt16(ddlEventType.SelectedValue); se.IsActive = cbIsActive.Checked; se.Name = tbName.Text; se.StaffID = Convert.ToInt16(ddlStaff.SelectedValue); new ScheduleEventServices().Save(se); Response.Redirect("/Schedules/" + se.ID.ToString()); } else { var se = new ScheduleEvent(); se.Description = tbDescription.Text; se.EventTypeID = Convert.ToInt16(ddlEventType.SelectedValue); se.IsActive = cbIsActive.Checked; se.Name = tbName.Text; se.StaffID = Convert.ToInt16(ddlStaff.SelectedValue); new ScheduleEventServices().Save(se); } LoadEvent(); }
public static void UnsetNotModified(ScheduleEventCollection srcEventList, ScheduleEventCollection origEventList, ScheduleEventCollection destEventList, string postfix) { for (int i = srcEventList.Count - 1; i >= 0; i--) { ScheduleEvent srcEvent = srcEventList[i]; bool fromDest = false; ScheduleEvent destEvent = FindPairdEvent(srcEvent, origEventList, string.Empty); if (destEvent == null) { destEvent = FindPairdEvent(srcEvent, destEventList, postfix); fromDest = true; } if (destEvent == null) { continue; } srcEventList.Remove(srcEvent); if (fromDest) { destEventList.Remove(destEvent); } else { origEventList.Remove(destEvent); } } }
public void AdvanceTime(TimeSpan delta) { _timeNow += delta.Ticks; while (_heap.Count > 0 && _heap.Peek().EndTime <= _timeNow) { ScheduleEvent scheduleEvent = _heap.ExtractMin(); _lookup.Remove(scheduleEvent.Id); if (!scheduleEvent.Cancelled) { scheduleEvent.Callback(scheduleEvent.Id, scheduleEvent.State); if (!scheduleEvent.Cancelled) { scheduleEvent.Cancelled = !scheduleEvent.Repeat; if (scheduleEvent.Repeat) { _repeat.Add(scheduleEvent); } } } if (scheduleEvent.Cancelled) { _pool.Release(scheduleEvent); } } _repeat.ForEach(delegate(ScheduleEvent s) { s.StartTime = _timeNow; _heap.Add(s); _lookup.Add(s.Id, s); }); _repeat.Clear(); }
public static void Initialize(ScheduleDataContext context) { context.Database.EnsureCreated(); // Look for any students. if (context.ScheduleEvents.Any()) { return; // DB has been seeded } var appointments = new ScheduleEvent[] { new ScheduleEvent { Id = 1, Subject = "Meeting", StartTime = new DateTime(2018, 3, 27, 10, 00, 00), EndTime = new DateTime(2018, 3, 27, 11, 00, 00), StartTimezone = "", EndTimezone = "", IsAllDay = false, Description = "", Location = "", RecurrenceID = "10", RecurrenceRule = "FREQ=DAILY;INTERVAL=1;COUNT=5" }, new ScheduleEvent { Id = 2, Subject = "Client Demo", StartTime = new DateTime(2018, 3, 28, 10, 00, 00), EndTime = new DateTime(2018, 3, 28, 11, 00, 00), StartTimezone = "", EndTimezone = "", IsAllDay = false, Description = "", Location = "" }, }; foreach (ScheduleEvent app in appointments) { context.ScheduleEvents.Add(app); } context.SaveChanges(); }
/// <summary> /// 播放指定定时器 /// </summary> /// <param name="scheduleEvent">Schedule event.</param> public void Play(ScheduleEvent scheduleEvent) { if (scheduleEvent != null) { scheduleEvent.Play(); } }
/// <summary> /// 暂停指定定时器 /// </summary> /// <param name="scheduleEvent">Schedule event.</param> public void Pause(ScheduleEvent scheduleEvent) { if (scheduleEvent != null) { scheduleEvent.Pause(); } }
public JsonResult Delete(ScheduleEvent value) { //if (value.ApprovedActivity != true) { var activity = new ScheduleEvent { SheduleID = value.SheduleID }; db.ScheduleEvents.Attach(activity); db.ScheduleEvents.Remove(activity); //db.SaveChanges(); } try { db.SaveChanges(); } catch (DbEntityValidationException e) { foreach (var eve in e.EntityValidationErrors) { Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:", eve.Entry.Entity.GetType().Name, eve.Entry.State); foreach (var ve in eve.ValidationErrors) { Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage); } } throw; } IEnumerable data = new mascisEntities().ScheduleEvents; return(Json(data, JsonRequestBehavior.AllowGet)); }
/// <summary> /// 停止某个事件 /// </summary> /// <param name="scheduleEvent">Schedule event.</param> public void UnSchedule(ScheduleEvent scheduleEvent) { if (scheduleEvent != null) { scheduleEvent.Stop(); m_willRemove.Add(scheduleEvent); } }
public void Create(ScheduleEvent entity) { using (MQuinceDbContext _context = new MQuinceDbContext(_dbContext)) { _context.ScheduleEvents.Add(EventMapper.MapScheduleEventEntityToScheduleEventPersistence(entity)); _context.SaveChanges(); } }
public Game(ScheduleEvent e) { League = e.LeagueCode; Round = e.Round; GameDate = e.GameDate; HomeTeam = e.HomeTeam; AwayTeam = e.AwayTeam; }
/// <summary> /// Update ScheduleEvents. /// </summary> /// <remarks> /// Edit a single schedule event. /// </remarks> /// <param name="scheduleEvent"> /// The <see cref="ScheduleEvent"/> object to be updated. /// </param> /// <returns> /// The <see cref="ScheduleEvent"/> object that was updated, along with /// an output instance of the <see cref="ResultsMeta"/> class containing additional data. /// </returns> public (ScheduleEvent, ResultsMeta) UpdateScheduleEvent( ScheduleEvent scheduleEvent) { (IList <ScheduleEvent> scheduleEvents, ResultsMeta resultsMeta) = UpdateScheduleEvents(new[] { scheduleEvent }); return(scheduleEvents.FirstOrDefault(), resultsMeta); }
public ActionResult DeleteConfirmed(int id) { ScheduleEvent scheduleEvent = db.ScheduleEvents.Find(id); db.ScheduleEvents.Remove(scheduleEvent); db.SaveChanges(); return(RedirectToAction("Index")); }
/// <summary> /// The Following method is used to display all the usercontrol tabs /// in a list form using switch case that changes when the user click on a different /// usercontrol button. /// written by author : Abdelrahman Ahmed /// ref: https://docs.microsoft.com/en-us/dotnet/api/system.windows.controls.selectionchangedeventargs?view=netframework-4.7.2 /// using selection event changer with children to add new tab and clear the previous one. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void MenuSelector_SelectionChanged(object sender, SelectionChangedEventArgs e) { UserControl tab = null; EventCenter.Children.Clear(); switch (((ListViewItem)((ListView)sender).SelectedItem).Name) { case "Dashboard": tab = new DashboardEvent(); EventCenter.Children.Add(tab); break; case "Storage": tab = new StorageEvent(); EventCenter.Children.Add(tab); break; case "Crops": tab = new CropsEvent(); EventCenter.Children.Add(tab); break; case "Delivery": tab = new DeliveryEvent(); EventCenter.Children.Add(tab); break; case "Timetable": tab = new TimetableEvent(); EventCenter.Children.Add(tab); break; case "Employees": tab = new EmployeeEvent(); EventCenter.Children.Add(tab); break; case "Schedule": tab = new ScheduleEvent(); EventCenter.Children.Add(tab); break; case "Sales": tab = new SalesEvent(); EventCenter.Children.Add(tab); break; case "Users": tab = new UserEvent(); EventCenter.Children.Add(tab); break; default: break; } }
private Color GetColorBySchedule(ScheduleEvent scheduleEvent) { Color color = Color.white; switch (scheduleEvent) { case ScheduleEvent.Project: color = _classActicityColor; break; case ScheduleEvent.Class: color = _classActicityColor; break; case ScheduleEvent.Birthday: color = _birthDayColor; break; case ScheduleEvent.ClothingFestival101: color = _clothingColor; break; case ScheduleEvent.ClothingFestival202: color = _clothingColor; break; case ScheduleEvent.ClothingFestival303: color = _clothingColor; break; case ScheduleEvent.ClothingFestival404: color = _clothingColor; break; case ScheduleEvent.DiscountFoodStore: color = _foodColor; break; case ScheduleEvent.MysticFestival1st: color = _mysticColor; break; case ScheduleEvent.MysticFestival2nd: color = _mysticColor; break; case ScheduleEvent.MysticFestival3rd: color = _mysticColor; break; case ScheduleEvent.MysticFestival4th: color = _mysticColor; break; } return(color); }
private void DrawScheduleEvent(Graphics graphics, TaskPaintEventArgs e, ScheduleEvent task, RectangleF taskRect) { var fill = taskRect; fill.Width = (int)(fill.Width * 1); graphics.FillRectangle(e.Format.BackFill, taskRect); graphics.FillRectangle(e.Format.ForeFill, fill); graphics.DrawRectangle(e.Format.Border, taskRect); }
public async Task <IActionResult> DeleteScheduleEvent([FromBody] ScheduleEventView view) { ScheduleEventModule invMod = new ScheduleEventModule(); ScheduleEvent scheduleEvent = await invMod.ScheduleEvent.Query().MapToEntity(view); invMod.ScheduleEvent.DeleteScheduleEvent(scheduleEvent).Apply(); return(Ok(view)); }
/// <summary> /// Asynchronously Update ScheduleEvents, with support for cancellation. /// </summary> /// <remarks> /// Edit a single schedule event. /// </remarks> /// <param name="scheduleEvent"> /// The <see cref="ScheduleEvent"/> object to be updated. /// </param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns> /// The <see cref="ScheduleEvent"/> object that was updated, along with /// an output instance of the <see cref="ResultsMeta"/> class containing additional data. /// </returns> public async Task <(ScheduleEvent, ResultsMeta)> UpdateScheduleEventAsync( ScheduleEvent scheduleEvent, CancellationToken cancellationToken) { (IList <ScheduleEvent> scheduleEvents, ResultsMeta resultsMeta) = await UpdateScheduleEventsAsync(new[] { scheduleEvent }, cancellationToken).ConfigureAwait(false); return(scheduleEvents.FirstOrDefault(), resultsMeta); }
public async Task <IHttpActionResult> NewEventAsync(string id, ScheduleEvent @event) { @event.id = -1; Event updated = await _eventWriter.CreateAsync(Map(@event)); await Publish(_eventPublisher.OnCreatedAsync, updated); return(Ok(Map(updated))); }
public static Recording CreateFromScheduleEvent(ScheduleEvent scheduleEvent) { return(new Recording( scheduleEvent.Id, (string)scheduleEvent.GetExtendedProperty(CHANNEL_ID), (string)scheduleEvent.GetExtendedProperty(TITLE), scheduleEvent.StartTime.ToLocalTime(), scheduleEvent.EndTime.ToLocalTime() )); }
public ActionResult Edit([Bind(Include = "Id,Subject,Description,StartTime,EndTime,AllDay,Recurrence,RecurrenceRule,VenueCode,ParticipationInvitee,ParticipationAttendee,ExpectedOutput,Objective,ActivityClassificationId,OrganId,DirectorateId,SectorId,SourceOfFundingId,FundingTypeId,PublicHoliday,CostEstimates,MeetingType,Approved_By,Date_Approved,Added_By,Date_Added,City,ActivityImplemented,ActivityImplementedComment,ApprovedActivity,IsBlockAppointment,BlockForAll,ActivityForwarded,Organizer")] ScheduleEvent scheduleEvent) { if (ModelState.IsValid) { db.Entry(scheduleEvent).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(scheduleEvent)); }
public Store(Store_Template store_Template) { _storeContoller = StoreContoller.Instance; _currentItemSet = new List <StoreItemSet>(); _definition = store_Template; _isEvent = false; _scheduleEvent = ScheduleEvent.None; _currentStoreItemSetId = _definition.DefaultStoreItemId; }
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 static ScheduleEvent FindPairdEvent(ScheduleEvent srcEvent, ScheduleEventCollection eventList, string postfix) { string detail = srcEvent.Detail + postfix; foreach (ScheduleEvent scheduleEvent in eventList) { // compare event type if ((srcEvent.IsBanner && !scheduleEvent.IsBanner) || (!srcEvent.IsBanner && scheduleEvent.IsBanner)) continue; // compare start date and time if (!srcEvent.Start.Equals(scheduleEvent.Start)) continue; // compare start only flag if (srcEvent.StartOnly) { if (!scheduleEvent.StartOnly) continue; } else { if (scheduleEvent.StartOnly) continue; // compare end date and time if (!srcEvent.End.Equals(scheduleEvent.End)) continue; } // compare plan if (srcEvent.Plan != scheduleEvent.Plan) continue; // compare detail if (detail == scheduleEvent.Detail) return scheduleEvent; } return null; }
private bool GetEvent(out ScheduleEvent _event) { _event = ScheduleEvent.eTerminate; lock (m_EventsLock) { int nCount = m_Events.Count; if (nCount == 0) return false; _event = m_Events.Dequeue(); if (nCount == 1) m_hNotifyEvent.Reset(); } return true; }
private void AppendEvent(ScheduleEvent _event) { lock (m_EventsLock) { m_Events.Enqueue(_event); m_hNotifyEvent.Set(); } }
/// <summary> /// Compares the schedule events for a reverse sort /// </summary> /// <param name="x">The first event.</param> /// <param name="y">The second event.</param> /// <returns></returns> private static int CompareScheduleEvents(ScheduleEvent x, ScheduleEvent y) { if (x.StartTime > y.StartTime) return -1; if (x.StartTime < y.StartTime) return 1; return 0; }