Наследование: INotifyPropertyChanged
Пример #1
0
        public void FluentTest1()
        {
            //Verify output. Should see one or two 10-second ticks, one or two 1,6 ticks, and one or two 2,7 ticks.
            var s = new Schedule()
                .AtSeconds(0, 10, 20, 30, 40, 50)
                .WithLocalTime()
                .Execute<TenSecTask>();
            SchedulerRuntime.Start(s);

            Thread.Sleep(new TimeSpan(0, 0, 2));

            SchedulerRuntime.AddSchedule(new Schedule().WithName("OneSix").AtSeconds(1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56).Execute<OneSixTask>());

            Thread.Sleep(new TimeSpan(0, 0, 6));

            SchedulerRuntime.UpdateSchedule(new Schedule().WithName("OneSix").AtSeconds(2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57).Execute<TwoSevenTask>());

            Thread.Sleep(new TimeSpan(0, 0, 6));

            SchedulerRuntime.Stop();
            Console.WriteLine("Stopped");

            Assert.IsTrue(TenSecTask.Ticked);
            Assert.IsTrue(OneSixTask.Ticked);
            Assert.IsTrue(TwoSevenTask.Ticked);
        }
Пример #2
0
        public MinuteUnit(Schedule schedule, int duration)
        {
            this.Schedule = schedule;
            this.Duration = duration;

            this.Schedule.CalculateNextRun = x => x.AddMinutes(Duration);
        }
Пример #3
0
 ///<summary>Inserts one Schedule into the database.  Provides option to use the existing priKey.</summary>
 internal static long Insert(Schedule schedule,bool useExistingPK)
 {
     if(!useExistingPK && PrefC.RandomKeys) {
         schedule.ScheduleNum=ReplicationServers.GetKey("schedule","ScheduleNum");
     }
     string command="INSERT INTO schedule (";
     if(useExistingPK || PrefC.RandomKeys) {
         command+="ScheduleNum,";
     }
     command+="SchedDate,StartTime,StopTime,SchedType,ProvNum,BlockoutType,Note,Status,EmployeeNum) VALUES(";
     if(useExistingPK || PrefC.RandomKeys) {
         command+=POut.Long(schedule.ScheduleNum)+",";
     }
     command+=
              POut.Date  (schedule.SchedDate)+","
         +    POut.Time  (schedule.StartTime)+","
         +    POut.Time  (schedule.StopTime)+","
         +    POut.Int   ((int)schedule.SchedType)+","
         +    POut.Long  (schedule.ProvNum)+","
         +    POut.Long  (schedule.BlockoutType)+","
         +"'"+POut.String(schedule.Note)+"',"
         +    POut.Int   ((int)schedule.Status)+","
         +    POut.Long  (schedule.EmployeeNum)+")";
         //DateTStamp can only be set by MySQL
     if(useExistingPK || PrefC.RandomKeys) {
         Db.NonQ(command);
     }
     else {
         schedule.ScheduleNum=Db.NonQ(command,true);
     }
     return schedule.ScheduleNum;
 }
Пример #4
0
 ///<summary>Inserts one Schedule into the database.  Returns the new priKey.</summary>
 internal static long Insert(Schedule schedule)
 {
     if(DataConnection.DBtype==DatabaseType.Oracle) {
         schedule.ScheduleNum=DbHelper.GetNextOracleKey("schedule","ScheduleNum");
         int loopcount=0;
         while(loopcount<100){
             try {
                 return Insert(schedule,true);
             }
             catch(Oracle.DataAccess.Client.OracleException ex){
                 if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
                     schedule.ScheduleNum++;
                     loopcount++;
                 }
                 else{
                     throw ex;
                 }
             }
         }
         throw new ApplicationException("Insert failed.  Could not generate primary key.");
     }
     else {
         return Insert(schedule,false);
     }
 }
Пример #5
0
        public void load_schedule(string f)
        {
            videoList = new VideoFile[1024];

            for (int i = 0; i < 7; i++)
            {
                dailyList[i] = new DailyVideoFiles();
            }
            Schedule s = new Schedule();
            s = XMLReader.ReadSchedule(f);
            List<DailyVideoFiles> list = s.DailyVideoFilesList;

            list.CopyTo(dailyList, 0);

            foreach (DailyVideoFiles dailyFile in list)
            {
                //MessageBox.Show("how many days?" + dailyFile.VideoFileList.Count);
                foreach (VideoFile v in dailyFile.VideoFileList)
                {
                    int index = v.Index;
                    videoList[index] = v;
                }
            }

            get_diff(dailyList);

        }
        public void MarkConflictingAppointmentsUponCreation()
        {
            var schedule = new Schedule(Guid.NewGuid(), testDateTimeRange, testClinicId, new List<Appointment>() { testAppointment1, testAppointment2 });

            Assert.IsTrue(testAppointment1.IsPotentiallyConflicting);
            Assert.IsTrue(testAppointment2.IsPotentiallyConflicting);
        }
Пример #7
0
 public FrmSelectStaff(Staff staff,Schedule schedule,int status)
 {
     InitializeComponent();
     this.staff = staff;
     this.schedule = schedule;
     this.statusButton = status;
 }
Пример #8
0
 public void CreateConflictCompilation(Schedule schedule, ConflictCriteria criteria)
 {
     switch (criteria)
     {
         case ConflictCriteria.All:
             Conflicts = new ObservableCollection<Conflict>(ConflictSearchEngine.SearchAllConflicts(schedule));
             break;
         case ConflictCriteria.GreaterThanFourClassesPerDay:
             Conflicts = new ObservableCollection<Conflict>(ConflictSearchEngine.GreaterThanFourClassesPerDay(schedule));
             break;
         case ConflictCriteria.CardsWithBlankFields:
             Conflicts = new ObservableCollection<Conflict>(ConflictSearchEngine.CardsWithBlankFields(schedule));
             break;
         case ConflictCriteria.GroupsInDifferentClassrooms:
             Conflicts = new ObservableCollection<Conflict>(ConflictSearchEngine.GroupsInDifferentClassrooms(schedule));
             break;
         case ConflictCriteria.LecturersInDifferentClassrooms:
             Conflicts = new ObservableCollection<Conflict>(ConflictSearchEngine.LecturersInDifferentClassrooms(schedule));
             break;
         case ConflictCriteria.LecturersOnDifferentClasses:
             Conflicts = new ObservableCollection<Conflict>(ConflictSearchEngine.LecturersInDifferentClassrooms(schedule));
             break;
         case ConflictCriteria.NextClassesAtDifferentAddress:
             Conflicts = new ObservableCollection<Conflict>(ConflictSearchEngine.NextClassesAtDifferentAddress(schedule));
             break;
     }
 }
 internal YearOnDayOfYearUnit(Schedule schedule, int duration, int dayOfYear)
 {
     _duration = duration;
     _dayOfYear = dayOfYear;
     Schedule = schedule;
     At(0, 0);
 }
Пример #10
0
        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);
        }
        public void Copy_Schedule()
        {
            // Arange
            int scheduleId = 1;
            string scheduleName = "ScheduleName1";

            int pierId = 1;
            string pierName = "PierName1";
            Pier pier = new Pier { Id = pierId, Name = pierName };

            int routeId = 1;
            string routeCode = "RouteCode1";
            string routeName = "RouteName1";
            Route route = new Route { Id = routeId, Code = routeCode, Name = routeName };

            TimeSpan time = new TimeSpan(0, 10, 0);

            Schedule oldSchedule = new Schedule { Id = scheduleId, Name = scheduleName, Pier = pier, Route = route, Time = time };

            // Act
            Schedule newSchedule = oldSchedule.Copy();

            // Assert
            Assert.AreNotSame(newSchedule, oldSchedule); // Not the same object

            // Check properties
            Assert.AreEqual(newSchedule.Id, scheduleId);
            Assert.AreEqual(newSchedule.Name, scheduleName);
            Assert.AreEqual(newSchedule.Route, route);
            Assert.AreEqual(newSchedule.Pier, pier);
            Assert.AreEqual(newSchedule.Time, time);

        }
Пример #12
0
 public void VerifyParsingBadDatesToSchedule()
 {
     List<string> filenames = new List<string>();
     filenames.Add("Tests\\Data\\GoodXML_malformedDate.xml");
     var schedule = new Schedule();
     var _emptyEvents = new ObservableCollection<Event>();
     ObservableCollection<Event> Events = schedule.GetXMLEvents(true, filenames); //read from xap
     Assert.IsNotNull(Events);
     //events with malformed dates should be added to the schedule with a fake date
     Assert.AreNotEqual(_emptyEvents, Events);
     Assert.IsNotNull(Events, "event collection");
     var enumerator = Events.GetEnumerator();
     enumerator.MoveNext();
     var firstEvent = enumerator.Current;
     Assert.IsNotNull(firstEvent, "first event in collection");
     Assert.AreEqual("Panel", firstEvent.Kind);
     Assert.AreEqual("Datetime 08272011 110000", firstEvent.Name);
     Assert.IsNotNull(firstEvent.StartTime, "datetime");
     Assert.AreEqual(TestValues.FriendlyTime, firstEvent.friendlyStartTime);
     Assert.AreEqual(false, firstEvent.Star);
     enumerator.MoveNext();
     var secondEvent = enumerator.Current;
     Assert.IsNotNull(secondEvent, "first event in collection");
     Assert.AreEqual("Panel", secondEvent.Kind);
     Assert.IsNotNull(secondEvent.StartTime, "datetime");
     Assert.AreEqual(TestValues.FriendlyTime, secondEvent.friendlyStartTime);
     Assert.AreEqual("Datetime Friday 10 November", secondEvent.Name);
     Assert.AreEqual(false, secondEvent.Star);
     //check for little watson file in isolated storage?
 }
Пример #13
0
        public const string DescriptionHeaderName = "# CrossSync: "; // Don't modify this.

        #endregion Fields

        #region Methods

        public static bool CanSync(out CybozuException ex)
        {
            ex = null;

            Properties.Settings settings = Properties.Settings.Default;
            if (!IsConfigured(settings)) return false;

            App firstApp, secondApp;
            Schedule firstSchedule, secondSchedule;

            try
            {
                firstApp = new App(settings.FirstUrl);
                firstApp.Auth(settings.FirstUsername, settings.FirstPassword);
                firstSchedule = new Schedule(firstApp);

                secondApp = new App(settings.SecondUrl);
                secondApp.Auth(settings.SecondUsername, settings.SecondPassword);
                secondSchedule = new Schedule(secondApp);
            }
            catch (CybozuException e)
            {
                // fail to auth
                ex = e;
                return false;
            }
            catch (Exception)
            {
                return false;
            }

            return true;
        }
 private void DeleteEmptyScheduler(Schedule schedule)
 {
     if (schedule != null && schedule.ID != ID.Null.ToString())
      {
     CalendarActions.DeleteScheduler(schedule);
      }
 }
Пример #15
0
        public void Announce(Schedule schedule)
        {
            var timeboxes = _timeBoxRepository.GetTimeBoxesFrom(schedule.Campaign, schedule.Start, schedule.End);

            foreach (var timeBox in timeboxes)
            {
                foreach (var term in timeBox.TermSet)
                {
                    var hrDate = term.GetLowestTerm().SaftyGetProperty<DateTime, IAssignment>(o => o.SaftyGetHrDate());

                    if (!hrDate.IsInTheRange(schedule))
                        continue;

                    //backupTerm
                    var backup = new BackupTerm(term.Id, timeBox.Agent.Id, term.Start, term.End, term.Text, term.Background, term.Level)
                                     {
                                         HrDate = hrDate
                                     };
                    if (term.ParentTerm != null)
                        backup.ParentTermId = term.ParentTerm.Id;
                    term.SaftyInvoke<AssignmentBase>(o => backup.WorkingTotals = o.WorkingTotals);

                    _timeBoxRepository.SaveOrUpdate(backup);
                }
            }
        }
Пример #16
0
 public FNode(Schedule _data, float _key)
 {
     right = this;
     left = this;
     data = _data;
     key = _key;
 }
 internal MonthOnDayOfMonthUnit(Schedule schedule, int duration, int dayOfMonth)
 {
     _duration = duration;
     _dayOfMonth = dayOfMonth;
     Schedule = schedule;
     At(0, 0);
 }
Пример #18
0
        public String ValidateSchedule(Schedule.Schedule schedule, Registration.Registration vehicle)
        {
            String information = "";

            try
            {

                if (comboBoxCountry.SelectedItem.ToString() == Registration.Country.country_name.Ecuador.ToString())
                {
                    vehicle = new Registration.EcuadorRegistration(this.textBoxRegistration.Text);

                    schedule = new Schedule.EcuadorSchedule();

                    DateTime dt = new DateTime();

                    dt = Convert.ToDateTime(dateTimePicker.Text);

                    if (!(schedule as Schedule.EcuadorSchedule).EcuadorValidator(vehicle, dt))

                        information = "El vehículo con matrícula " + vehicle.Number + " no puede conducir en la ciudad de Quito entre las las 7:00 y las 9:30 en la mañana y entre las 16:00 y las 19:30 en la tarde y noche.";
                    else
                        information = "El vehículo con matrícula " + vehicle.Number + " puede conducir libremente en la ciudad de Quito en la fecha seleccionada.";
                }
                else
                    information = "Información solo disponible para " + Registration.Country.country_name.Ecuador.ToString();

            }
            catch (Exception exception)
            {
                information = exception.Message;
            }

            return information;
        }
Пример #19
0
 public void AssignSchedule(Schedule schedule=null)
 {
     if (schedule == null)
        Schedule = NewSchedule();
     else
        Schedule = schedule;
 }
		public void UpdateSnapshots(Schedule schedule)
		{
			_snapshots.Clear();
			pnLeftColumn.Controls.Clear();
			pnRightColumn.Controls.Clear();
			int columnIndex = 0;
			foreach (PrintProduct publication in schedule.PrintProducts)
			{
				if (publication.Inserts.Count > 0)
				{
					var snapshot = new PublicationSnapshotControl(publication);
					if (columnIndex == 0)
					{
						pnLeftColumn.Controls.Add(snapshot);
						snapshot.BringToFront();
						columnIndex++;
					}
					else
					{
						pnRightColumn.Controls.Add(snapshot);
						snapshot.BringToFront();
						columnIndex = 0;
					}
					_snapshots.Add(snapshot);
				}
			}
			UpdateColumns(schedule);
		}
Пример #21
0
    public DateTime Day(DayOfWeek dayOfWeek, Schedule schedule)
    {
        switch (schedule)
        {
            case Schedule.Second:
                FindDate(dayOfWeek, _indexes[schedule]);
                break;
            case Schedule.Third:
                FindDate(dayOfWeek, _indexes[schedule]);
                break;
            case Schedule.Fourth:
                FindDate(dayOfWeek, _indexes[schedule]);
                break;
            case Schedule.Last:
                FindDate(dayOfWeek, _indexes[schedule]);
                break;
            case Schedule.Teenth:
                FindDate(dayOfWeek, _indexes[schedule]);
                break;
            case Schedule.First:
                FindDate(dayOfWeek, _indexes[schedule]);
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(schedule), schedule, null);
        }

        return _date;
    }
Пример #22
0
 public void ClearAndReplace(NPC npc, Schedule newSchedule)
 {
     _schedulesToDo.Clear();
     current = null;
     Add(new DefaultSchedule(npc));
     Add(newSchedule);
 }
        private Schedule ConfigureSchedulerSeedData()
        {
            var scheduleRepository = Container.Resolve<IRepository<Schedule>>();
            var globalSchedule = scheduleRepository.CreateQuery().FirstOrDefault(x => x.Name == _globalScheduleName);
            if (globalSchedule == null)
            {
                globalSchedule = new Schedule
                {
                    GlobalDefault = true,
                    Name = _globalScheduleName,
                    StartOnWeekends = false,
                    StartCron = "* 8 * * 1-5", // 8 AM, Monday through Friday
                    StopCron = "* 18 * * 1-5", // 6 PM, Monday through Friday
                };
                scheduleRepository.Add(globalSchedule);
            }

            foreach (var schedule in GetAdditionalSchedules())
            {
                var scopedSchedule = schedule;
                var existingSchedule = scheduleRepository.CreateQuery().FirstOrDefault(x => x.Name == scopedSchedule.Name);
                if (existingSchedule == null)
                {
                    scheduleRepository.Add(scopedSchedule);
                }
            }

            return globalSchedule;
        }
 internal void Add(Schedule schedule)
 {
     lock (_lock)
     {
         _schedules.Add(schedule);
     }
 }
 internal bool Remove(Schedule schedule)
 {
     lock (_lock)
     {
         return _schedules.Remove(schedule);
     }
 }
        /// <summary>
        /// Shows the detail.
        /// </summary>
        /// <param name="itemKey">The item key.</param>
        /// <param name="itemKeyValue">The item key value.</param>
        /// <param name="parentCategoryId">The parent category id.</param>
        public void ShowDetail( string itemKey, int itemKeyValue, int? parentCategoryId )
        {
            pnlDetails.Visible = false;
            if ( itemKey != "ScheduleId" )
            {
                return;
            }

            var scheduleService = new ScheduleService( new RockContext() );
            Schedule schedule = null;

            if ( !itemKeyValue.Equals( 0 ) )
            {
                schedule = scheduleService.Get( itemKeyValue );
            }
            else
            {
                schedule = new Schedule { Id = 0, CategoryId = parentCategoryId };
            }

            if ( schedule == null )
            {
                return;
            }

            pnlDetails.Visible = true;
            hfScheduleId.Value = schedule.Id.ToString();

            // render UI based on Authorized and IsSystem
            bool readOnly = false;

            nbEditModeMessage.Text = string.Empty;
            if ( !IsUserAuthorized( Authorization.EDIT ) )
            {
                readOnly = true;
                nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed( Schedule.FriendlyTypeName );
            }

            if ( readOnly )
            {
                btnEdit.Visible = false;
                btnDelete.Visible = false;
                ShowReadonlyDetails( schedule );
            }
            else
            {
                btnEdit.Visible = true;
                string errorMessage = string.Empty;
                btnDelete.Visible = scheduleService.CanDelete( schedule, out errorMessage );
                if ( schedule.Id > 0 )
                {
                    ShowReadonlyDetails( schedule );
                }
                else
                {
                    ShowEditDetails( schedule );
                }
            }
        }
Пример #27
0
        public void SetUp()
        {
            defaultScheduler = new DefaultScheduler(bus);
            container.Register<IBus>(() => bus);
            container.Register<DefaultScheduler>(() => defaultScheduler);

            schedule = new Schedule(container);
        }
Пример #28
0
 private void BuildAllStatistic(Schedule schedule)
 {
     BuildGroupStatistics(schedule);
     BuildLecturerStatistics(schedule);
     BuildSubjectStatistics(schedule);
     BuildClassroomStatistics(schedule);
     BuildClassTimeStatistics(schedule);
 }
Пример #29
0
 protected override Schedule GetSchedule()
 {
     //Schedule schedule = new DefaultSchedule(this);
     //return (schedule);
     Schedule schedule = new Schedule(this, Schedule.priorityEnum.Low);
     schedule.Add(new TimeTask(120f, new AbstractAnimationState(this, currentIdlePose)));
     return (schedule);
 }
 public Schedule createScheduleFromAgentsTxt()
 {
     var agents = JsonConvert.DeserializeObject<List<Agent>>(Resources.AgentsJson);
     var start = new DateTime(2014, 7, 28);
     var schedule = new Schedule(agents, start, start + new TimeSpan(28, 0, 0, 0));
     schedule.FillUp();
     return schedule;
 }
Пример #31
0
 public CallableFixedRateBond(int settlementDays, double faceAmount, Schedule schedule, DoubleVector coupons, DayCounter accrualDayCounter, BusinessDayConvention paymentConvention, double redemption, Date issueDate, CallabilitySchedule putCallSchedule) : this(NQuantLibcPINVOKE.new_CallableFixedRateBond(settlementDays, faceAmount, Schedule.getCPtr(schedule), DoubleVector.getCPtr(coupons), DayCounter.getCPtr(accrualDayCounter), (int)paymentConvention, redemption, Date.getCPtr(issueDate), CallabilitySchedule.getCPtr(putCallSchedule)), true)
 {
     if (NQuantLibcPINVOKE.SWIGPendingException.Pending)
     {
         throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
     }
 }
        public frmAddNewApprenticeshipAssessmentReport(CurriculumCourseEnrollment CurrentlySelectedCurriculumCourseEnrollment)
        {
            this.CurrentlySelectedCurriculumCourseEnrollment = CurrentlySelectedCurriculumCourseEnrollment;
            AssessmentReportList = new List <AssessmentReport>();

            iCurrentPosition = 0;
            InitializeComponent();

            /*Loadup the Selected Assesment
             * *****************************/

            using (var Dbconnection = new MCDEntities())
            {
                CurrentlySelectedAssessment = (from a in Dbconnection.Assessments
                                               where a.CurriculumCourseEnrollmentID == this.CurrentlySelectedCurriculumCourseEnrollment.CurriculumCourseEnrollmentID
                                               select a)
                                              .Include(a => a.AssessmentModules)
                                              .Include(a => a.AssessmentModules.Select(b => b.CurriculumCourseModule))
                                              .Include(a => a.AssessmentModules.Select(b => b.CurriculumCourseModule.Module))
                                              .Include(a => a.AssessmentModules.Select(b => b.AssessmentModuleActivities))
                                              //.Include(a => a.AssessmentModules.Select(b => b.LookupPracticalAssessmentStatus.PracticalAssessmentStatus))
                                              .FirstOrDefault <Assessment>();
                if (CurrentlySelectedAssessment == null)
                {
                    CurrentlySelectedAssessment = new Assessment();
                    Schedule CurrentConfiguredSchedule = (from a in Dbconnection.Schedules
                                                          where a.CurriculumCourseEnrollmentID == this.CurrentlySelectedCurriculumCourseEnrollment.CurriculumCourseEnrollmentID
                                                          select a).FirstOrDefault <Schedule>();

                    /*Set the start and end date controls on the first page.
                     * ***************************************************/
                    CurrentlySelectedAssessment.AssessmentDateStarted        = CurrentConfiguredSchedule.ScheduleStartDate.Date;
                    CurrentlySelectedAssessment.AssessmentDateCompleted      = CurrentConfiguredSchedule.ScheduleCompletionDate.Date;
                    CurrentlySelectedAssessment.AssessmentDateSubmitted      = DateTime.Now;
                    CurrentlySelectedAssessment.CurriculumCourseEnrollmentID = this.CurrentlySelectedCurriculumCourseEnrollment.CurriculumCourseEnrollmentID;

                    foreach (CurriculumCourseModule CCM in (from a in Dbconnection.CurriculumCourseModules
                                                            where a.CurriculumCourseID == this.CurrentlySelectedCurriculumCourseEnrollment.CurriculumCourseID
                                                            select a)
                             .Include(a => a.Module)
                             .ToList <CurriculumCourseModule>())
                    {
                        CCM.ObjectState = Data.Models.Enum.EntityObjectState.Unchanged;
                        // CCM.CurriculumCours.Course
                        CurrentlySelectedAssessment.AssessmentModules.Add(new AssessmentModule()
                        {
                            CurriculumCourseModuleID      = CCM.CurriculumCourseModuleID,
                            PracticalAssessmentStatusID   = (int)Common.Enum.EnumPracticalAssessmentStatuses.Not_Yet_Competent,
                            TheoriticalAssessmentStatusID = (int)Common.Enum.EnumTheoriticalAssesmentStatuses.Not_Yet_Competent,
                            Notes                  = "",
                            AssessmentID           = 0,
                            CurriculumCourseModule = CCM
                        });
                    }

                    //foreach (AssessmentModule AM in CurrentlySelectedAssessment.AssessmentModules)
                    //{
                    //    Dbconnection.Entry(AM).Reference(a => a.LookupPracticalAssessmentStatus).Load();
                    //    Dbconnection.Entry(AM).Reference(a => a.LookupTheoriticalAssesmentStatus).Load();
                    //}

                    /***********************************************
                    * Load the Currently Loaded Course Name
                    * *********************************************/
                    lblSelectedCourseName.Text = (from a in Dbconnection.CurriculumCourses
                                                  where a.CurriculumCourseID == this.CurrentlySelectedCurriculumCourseEnrollment.CurriculumCourseID
                                                  select a).FirstOrDefault <CurriculumCourse>().Course.CourseName;
                }
            };

            /*END of Loading Assessment
            * ************************/
        }
Пример #33
0
        public void Run(int width, int height, CDFG graph, bool alreadyOptimized)
        {
            if (CanOptimizeCDFG(graph) && EnableOptimizations && !alreadyOptimized)
            {
                CDFG optimizedCDFG = new CDFG();
                optimizedCDFG.StartDFG = OptimizeCDFG <T>(width, height, graph, KeepRunning.Token, EnableGarbageCollection);
                optimizedCDFG.AddNode(null, optimizedCDFG.StartDFG);

                graph = optimizedCDFG;
            }

            DFG <Block>            runningGraph    = graph.StartDFG;
            Stack <IControlBlock>  controlStack    = new Stack <IControlBlock>();
            Stack <List <string> > scopedVariables = new Stack <List <string> >();

            Rectangle[] oldRectangles = null;
            bool        firstRun      = true;

            Dictionary <string, List <IDropletSource> > sumOutputtedDropelts = new Dictionary <string, List <IDropletSource> >();

            controlStack.Push(null);
            scopedVariables.Push(new List <string>());

            Schedule scheduler = new Schedule(width, height);

            scheduler.SHOULD_DO_GARBAGE_COLLECTION = EnableGarbageCollection;
            List <StaticDeclarationBlock> staticModuleDeclarations = runningGraph.Nodes.Where(node => node.value is StaticDeclarationBlock)
                                                                     .Select(node => node.value as StaticDeclarationBlock)
                                                                     .ToList();

            if (staticModuleDeclarations.Count > 0)
            {
                scheduler.PlaceStaticModules(staticModuleDeclarations);
                scopedVariables.Peek().AddRange(scheduler.NewVariablesCreatedInThisScope.Distinct());
            }

            while (runningGraph != null)
            {
                int time = scheduler.ListScheduling(runningGraph, Executor);
                scopedVariables.Peek().AddRange(scheduler.NewVariablesCreatedInThisScope.Distinct().Where(x => !x.Contains("#@#Index")));

                foreach (var item in scheduler.OutputtedDroplets)
                {
                    if (sumOutputtedDropelts.ContainsKey(item.Key))
                    {
                        sumOutputtedDropelts[item.Key].AddRange(item.Value);
                    }
                    else
                    {
                        sumOutputtedDropelts.Add(item.Key, item.Value);
                    }
                }

                List <Command>[] commandTimeline = CreateCommandTimeline(scheduler.ScheduledOperations, time);
                if (firstRun)
                {
                    bool[] usedElectrodes = GetusedElectrodes(width, height, commandTimeline, EnableSparseElectrodes);
                    StartExecutor(graph.StartDFG, scheduler.StaticModules.Select(pair => pair.Value).ToList(), usedElectrodes);
                    firstRun = false;
                }
                SendCommands(commandTimeline, ref oldRectangles, scheduler.rectanglesAtDifferentTimes);

                if (KeepRunning.IsCancellationRequested)
                {
                    return;
                }

                runningGraph.Nodes.ForEach(x => x.value.Reset());
                (runningGraph, _) = GetNextGraph(graph, runningGraph, Executor, scheduler.Variables, controlStack, scopedVariables, scheduler.FluidVariableLocations);
            }

            Executor.UpdateDropletData(sumOutputtedDropelts.Values.SelectMany(x => x.Select(y => y.GetFluidConcentrations())).ToList());
        }
Пример #34
0
 private void Schedule_MouseDown(object sender, MouseEventArgs e)
 {
     mySelectedScheduleNode = Schedule.GetNodeAt(e.X, e.Y);
 }
Пример #35
0
 public void Increment()
 {
     LastRunTime = NextRunTime;
     NextRunTime = Schedule.GetNextOccurrence(NextRunTime);
 }
        public Schedule InitializeScheduleForSection(Section section, ScheduleConfiguration scheduleConfiguration, IList <WeekDay> weekDays, AcademicSemester academicSemester)
        {
            var schedule = new Schedule(section, scheduleConfiguration, weekDays, academicSemester);

            foreach (var courseOffering in section.CourseOfferings)
            {
                var lecture = courseOffering.Course.Lecture;
                var tutor   = courseOffering.Course.Tutor;
                var lab     = courseOffering.Course.Lab;


                while (lecture > 0)
                {
                    var randDay = Helper.GetRandomInteger(scheduleConfiguration.NumberOfDaysPerWeek);

                    var lectureInstructor = GetInstructor(courseOffering, LECTURE_ID);

                    var lectureRoom = GetRoom(courseOffering, LECTURE_ID);

                    var scheduleEntry = CreateScheduleEntry(courseOffering.Course, lectureInstructor, lectureRoom, LECTURE_ID);

                    if (lecture >= GeneticAlgorithmConf.MAX_CONSECUTIVE_LECTURE)
                    {
                        scheduleEntry.Duration = GeneticAlgorithmConf.MAX_CONSECUTIVE_LECTURE;
                        lecture -= schedule.AddScheduleEntry(scheduleEntry, randDay);
                    }
                    else if (lecture > 0)
                    {
                        scheduleEntry.Duration = GeneticAlgorithmConf.MAX_CONSECUTIVE_LECTURE - 1;
                        lecture -= schedule.AddScheduleEntry(scheduleEntry, randDay);
                    }
                }

                while (tutor > 0)
                {
                    var randDay = Helper.GetRandomInteger(scheduleConfiguration.NumberOfDaysPerWeek);

                    var tutorInstructor = GetInstructor(courseOffering, TUTOR_ID);

                    var tutorRoom = GetRoom(courseOffering, TUTOR_ID);

                    var scheduleEntry = CreateScheduleEntry(courseOffering.Course, tutorInstructor, tutorRoom, TUTOR_ID, duration: 1);

                    tutor -= schedule.AddScheduleEntry(scheduleEntry, randDay);
                }

                while (lab > 0)
                {
                    var randDay = Helper.GetRandomInteger(scheduleConfiguration.NumberOfDaysPerWeek);

                    var labInstructor = GetInstructor(courseOffering, LAB_ID);

                    var labRoom = GetRoom(courseOffering, LAB_ID);

                    var scheduleEntry = CreateScheduleEntry(courseOffering.Course, labInstructor, labRoom, LAB_ID);

                    if (lab >= GeneticAlgorithmConf.MAX_CONSECUTIVE_LAB)
                    {
                        scheduleEntry.Duration = GeneticAlgorithmConf.MAX_CONSECUTIVE_LAB;
                        lab -= schedule.AddScheduleEntry(scheduleEntry, randDay);
                    }
                    else if (lab >= (GeneticAlgorithmConf.MAX_CONSECUTIVE_LAB - 1))
                    {
                        scheduleEntry.Duration = GeneticAlgorithmConf.MAX_CONSECUTIVE_LAB - 1;
                        lab -= schedule.AddScheduleEntry(scheduleEntry, randDay);
                    }
                }
            }
            return(schedule);
        }
Пример #37
0
 public async Task <Schedule> Create(Schedule entity)
 {
     return(await _scheduleNonQueryDataService.Create(entity));
 }
Пример #38
0
 public async Task <Schedule> Update(int id, Schedule entity)
 {
     return(await _scheduleNonQueryDataService.Update(id, entity));
 }
Пример #39
0
        static void Main(string[] args)
        {
            try
            {
                DateTime    timer      = DateTime.Now;
                Option.Type type       = Option.Type.Put;
                double      underlying = 36.0;
                double      spreadRate = 0.005;

                double dividendYield = 0.02;
                double riskFreeRate  = 0.06;
                double volatility    = 0.2;

                int    settlementDays  = 3;
                int    length          = 5;
                double redemption      = 100.0;
                double conversionRatio = redemption / underlying; // at the money

                // set up dates/schedules
                Calendar calendar = new TARGET();
                Date     today    = calendar.adjust(Date.Today);

                Settings.setEvaluationDate(today);
                Date settlementDate = calendar.advance(today, settlementDays, TimeUnit.Days);
                Date exerciseDate   = calendar.advance(settlementDate, length, TimeUnit.Years);
                Date issueDate      = calendar.advance(exerciseDate, -length, TimeUnit.Years);

                BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;

                Frequency frequency = Frequency.Annual;

                Schedule schedule = new Schedule(issueDate, exerciseDate,
                                                 new Period(frequency), calendar, convention, convention,
                                                 DateGeneration.Rule.Backward, false);

                DividendSchedule    dividends   = new DividendSchedule();
                CallabilitySchedule callability = new CallabilitySchedule();

                List <double> coupons      = new InitializedList <double>(1, 0.05);
                DayCounter    bondDayCount = new Thirty360();

                int[] callLength = { 2, 4 }; // Call dates, years 2,4.
                int[] putLength  = { 3 };    // Put dates year 3.

                double[] callPrices = { 101.5, 100.85 };
                double[] putPrices  = { 105.0 };

                // Load call schedules
                for (int i = 0; i < callLength.Length; i++)
                {
                    SoftCallability s = new SoftCallability(
                        new Callability.Price(callPrices[i], Callability.Price.Type.Clean), schedule.date(callLength[i]),
                        1.20);
                    callability.Add(s);
                }

                for (int j = 0; j < putLength.Length; j++)
                {
                    Callability s = new Callability(new Callability.Price(putPrices[j], Callability.Price.Type.Clean),
                                                    Callability.Type.Put, schedule.date(putLength[j]));
                    callability.Add(s);
                }

                // Assume dividends are paid every 6 months .
                for (Date d = today + new Period(6, TimeUnit.Months); d < exerciseDate; d += new Period(6, TimeUnit.Months))
                {
                    Dividend div = new FixedDividend(1.0, d);
                    dividends.Add(div);
                }

                DayCounter dayCounter = new Actual365Fixed();
                double     maturity   = dayCounter.yearFraction(settlementDate, exerciseDate);

                Console.WriteLine("option type = " + type);
                Console.WriteLine("Time to maturity = " + maturity);
                Console.WriteLine("Underlying price = " + underlying);
                Console.WriteLine("Risk-free interest rate = {0:0.0%}", riskFreeRate);
                Console.WriteLine("Dividend yield = {0:0.0%}%", dividendYield);
                Console.WriteLine("Volatility = {0:0.0%}%", volatility);
                Console.WriteLine("");


                // write column headings
                int[]  widths     = { 35, 14, 14 };
                int    totalWidth = widths[0] + widths[1] + widths[2];
                string rule       = new string('-', totalWidth);
                string dblrule    = new string('=', totalWidth);

                Console.WriteLine(dblrule);
                Console.WriteLine("Tsiveriotis-Fernandes method");
                Console.WriteLine(dblrule);
                Console.WriteLine("Tree Type                           European     American        ");
                Console.WriteLine(rule);


                Exercise exercise   = new EuropeanExercise(exerciseDate);
                Exercise amexercise = new AmericanExercise(settlementDate, exerciseDate);

                Handle <Quote> underlyingH = new Handle <Quote>(new SimpleQuote(underlying));
                Handle <YieldTermStructure> flatTermStructure =
                    new Handle <YieldTermStructure>(new FlatForward(settlementDate, riskFreeRate, dayCounter));
                Handle <YieldTermStructure> flatDividendTS =
                    new Handle <YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
                Handle <BlackVolTermStructure> flatVolTS =
                    new Handle <BlackVolTermStructure>(new BlackConstantVol(settlementDate, calendar, volatility,
                                                                            dayCounter));

                BlackScholesMertonProcess stochasticProcess =
                    new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS);

                int timeSteps = 801;

                Handle <Quote> creditSpread = new Handle <Quote>(new SimpleQuote(spreadRate));

                Quote rate = new SimpleQuote(riskFreeRate);

                Handle <YieldTermStructure> discountCurve =
                    new Handle <YieldTermStructure>(new FlatForward(today, new Handle <Quote>(rate), dayCounter));

                IPricingEngine engine = new BinomialConvertibleEngine <JarrowRudd>(stochasticProcess, timeSteps);

                ConvertibleFixedCouponBond europeanBond = new ConvertibleFixedCouponBond(exercise, conversionRatio,
                                                                                         dividends, callability, creditSpread, issueDate, settlementDays, coupons, bondDayCount, schedule,
                                                                                         redemption);

                europeanBond.setPricingEngine(engine);

                ConvertibleFixedCouponBond americanBond = new ConvertibleFixedCouponBond(amexercise, conversionRatio,
                                                                                         dividends, callability, creditSpread, issueDate, settlementDays, coupons, bondDayCount, schedule,
                                                                                         redemption);
                americanBond.setPricingEngine(engine);


                Console.WriteLine("Jarrow-Rudd                         {0:0.000000}   {1:0.000000}", europeanBond.NPV(), americanBond.NPV());

                americanBond.setPricingEngine(new BinomialConvertibleEngine <CoxRossRubinstein>(stochasticProcess, timeSteps));
                europeanBond.setPricingEngine(new BinomialConvertibleEngine <CoxRossRubinstein>(stochasticProcess, timeSteps));

                Console.WriteLine("CoxRossRubinstein                   {0:0.000000}   {1:0.000000}", europeanBond.NPV(), americanBond.NPV());

                americanBond.setPricingEngine(new BinomialConvertibleEngine <AdditiveEQPBinomialTree>(stochasticProcess, timeSteps));
                europeanBond.setPricingEngine(new BinomialConvertibleEngine <AdditiveEQPBinomialTree>(stochasticProcess, timeSteps));

                Console.WriteLine("AdditiveEQPBinomialTree             {0:0.000000}   {1:0.000000}", europeanBond.NPV(), americanBond.NPV());

                americanBond.setPricingEngine(new BinomialConvertibleEngine <Trigeorgis>(stochasticProcess, timeSteps));
                europeanBond.setPricingEngine(new BinomialConvertibleEngine <Trigeorgis>(stochasticProcess, timeSteps));

                Console.WriteLine("Trigeorgis                          {0:0.000000}   {1:0.000000}", europeanBond.NPV(), americanBond.NPV());

                americanBond.setPricingEngine(new BinomialConvertibleEngine <Tian>(stochasticProcess, timeSteps));
                europeanBond.setPricingEngine(new BinomialConvertibleEngine <Tian>(stochasticProcess, timeSteps));

                Console.WriteLine("Tian                                {0:0.000000}   {1:0.000000}", europeanBond.NPV(), americanBond.NPV());

                americanBond.setPricingEngine(new BinomialConvertibleEngine <LeisenReimer>(stochasticProcess, timeSteps));
                europeanBond.setPricingEngine(new BinomialConvertibleEngine <LeisenReimer>(stochasticProcess, timeSteps));

                Console.WriteLine("LeisenReimer                        {0:0.000000}   {1:0.000000}", europeanBond.NPV(), americanBond.NPV());

                americanBond.setPricingEngine(new BinomialConvertibleEngine <Joshi4>(stochasticProcess, timeSteps));
                europeanBond.setPricingEngine(new BinomialConvertibleEngine <Joshi4>(stochasticProcess, timeSteps));

                Console.WriteLine("Joshi4                              {0:0.000000}   {1:0.000000}", europeanBond.NPV(), americanBond.NPV());
                Console.WriteLine("===========================================================================");

                Console.WriteLine(" \nRun completed in {0}", DateTime.Now - timer);
                Console.WriteLine();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
            Console.Write("Press any key to continue ...");
            Console.ReadKey();
        }
Пример #40
0
        public void Create(Schedule schedule)
        {
            Specs.AggregateIsNew.ThrowDomainErrorIfNotStatisfied(this);

            Emit(new VoyageCreatedEvent(schedule));
        }
Пример #41
0
        public static DFG <Block> OptimizeCDFG <T>(int width, int height, CDFG graph, CancellationToken keepRunning, bool useGC)
        {
            DFG <Block>            runningGraph    = graph.StartDFG;
            Stack <IControlBlock>  controlStack    = new Stack <IControlBlock>();
            Stack <List <string> > scopedVariables = new Stack <List <string> >();

            controlStack.Push(null);
            scopedVariables.Push(new List <string>());

            DFG <Block> bigDFG = new DFG <Block>();
            Dictionary <string, string> renamer           = new Dictionary <string, string>();
            Dictionary <string, string> variablePostfixes = new Dictionary <string, string>();

            Schedule scheduler = new Schedule(width, height);

            scheduler.SHOULD_DO_GARBAGE_COLLECTION = useGC;
            List <StaticDeclarationBlock> staticModuleDeclarations = runningGraph.Nodes.Where(node => node.value is StaticDeclarationBlock)
                                                                     .Select(node => node.value as StaticDeclarationBlock)
                                                                     .ToList();

            if (staticModuleDeclarations.Count > 0)
            {
                scheduler.PlaceStaticModules(staticModuleDeclarations);
                scopedVariables.Peek().AddRange(scheduler.NewVariablesCreatedInThisScope.Distinct());
            }

            int nameID = 0;

            while (runningGraph != null)
            {
                int time = scheduler.ListScheduling <T>(runningGraph, null);
                scopedVariables.Peek().AddRange(scheduler.NewVariablesCreatedInThisScope.Distinct().Where(x => !x.Contains("#@#Index")));
                runningGraph.Nodes.ForEach(x => x.value.IsDone = false);

                Assay fisk = new Assay(runningGraph);
                foreach (Block toCopy in fisk)
                {
                    if (toCopy is FluidBlock fluidBlockToCopy)
                    {
                        if (!variablePostfixes.ContainsKey(toCopy.OutputVariable))
                        {
                            variablePostfixes.Add(toCopy.OutputVariable, $"##{nameID++}");
                        }

                        Block copy = fluidBlockToCopy.CopyBlock(bigDFG, renamer, variablePostfixes[toCopy.OutputVariable]);

                        bigDFG.AddNode(copy);
                    }

                    fisk.UpdateReadyOperations(toCopy);
                }

                runningGraph.Nodes.ForEach(x => x.value.Reset());

                var           dropPositionsCopy = scheduler.FluidVariableLocations.ToDictionary();
                List <string> variablesOutOfScope;
                (runningGraph, variablesOutOfScope) = GetNextGraph(graph, runningGraph, null, scheduler.Variables, controlStack, scopedVariables, scheduler.FluidVariableLocations);

                if (useGC)
                {
                    AddWasteBlocks(variablesOutOfScope, bigDFG, renamer, dropPositionsCopy, staticModuleDeclarations);
                }

                foreach (var item in variablesOutOfScope)
                {
                    renamer.Remove(item);
                    variablePostfixes.Remove(item);
                }

                if (keepRunning.IsCancellationRequested)
                {
                    return(null);
                }
            }

            if (useGC)
            {
                AddWasteBlocks(scopedVariables.Pop(), bigDFG, renamer, scheduler.FluidVariableLocations, staticModuleDeclarations);
            }

            bigDFG.FinishDFG();
            return(bigDFG);
        }
Пример #42
0
        public ActionResult Edit([Bind(Include = "id,GameDate,Leagueid,Cancelled,rowversion")] Schedule schedule)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    if (db.Schedules.Any(x => x.GameDate == schedule.GameDate && x.id != schedule.id))
                    {
                        ModelState.AddModelError(string.Empty, "Duplicate date is not allowed");
                    }
                    else
                    {
                        db.Entry(schedule).State = EntityState.Modified;
                        db.SaveChanges();
                        return(RedirectToAction("Index", new { id = schedule.Leagueid }));
                    }
                }
            }
            catch (DbUpdateConcurrencyException ex)
            {
                var entry         = ex.Entries.Single();
                var clientValues  = (Schedule)entry.Entity;
                var databaseEntry = entry.GetDatabaseValues();
                if (databaseEntry == null)
                {
                    ModelState.AddModelError(string.Empty,
                                             "Unable to save changes. The schedule record was deleted by another user.");
                }
                else
                {
                    var databaseValues = (Schedule)databaseEntry.ToObject();

                    if (databaseValues.WeekDate != clientValues.WeekDate)
                    {
                        ModelState.AddModelError("Game Date", "Current value: "
                                                 + databaseValues.GameDate.ToShortDateString());
                    }
                    if (databaseValues.Cancelled != clientValues.Cancelled)
                    {
                        ModelState.AddModelError("Cancelled", "Current value: "
                                                 + databaseValues.Cancelled);
                    }
                    if (databaseValues.Leagueid != clientValues.Leagueid)
                    {
                        ModelState.AddModelError("League", "Current value: "
                                                 + databaseValues.Leagueid);
                    }

                    ModelState.AddModelError(string.Empty, "The record you attempted to edit "
                                             + "was modified by another user after you got the original value. The "
                                             + "edit operation was canceled and the current values in the database "
                                             + "have been displayed. If you still want to edit this record, click "
                                             + "the Save button again. Otherwise click the Back to List hyperlink.");
                    schedule.rowversion = databaseValues.rowversion;
                }
            }
            catch (Exception dex)
            {
                while (dex.InnerException != null)
                {
                    dex = dex.InnerException;
                }
                //Log the error (uncomment dex variable name and add a line here to write a log.)
                ModelState.AddModelError("",
                                         $"Unable to save changes. {dex.Message}");
                ErrorSignal.FromCurrentContext().Raise(dex);
            }
            ViewBag.Schedule = db.Schedules.Where(x => x.Leagueid == schedule.Leagueid).OrderBy(x => x.GameDate);
            return(View(schedule));
        }
 public async Task EditSchedule(Schedule schedule)
 {
     await this.EditSchedule(SCHEDULE_NAMESPACE, schedule);
 }
Пример #44
0
 public int UpdateSchedule(Schedule model)
 {
     this._scheduleRepository.Update(model);
     return(this._scheduleRepository.SaveChanges());
 }
 public async Task AddSchedule(Schedule schedule)
 {
     await this.AddSchedule(SCHEDULE_NAMESPACE, schedule);
 }
Пример #46
0
 public int SaveSchedule(Schedule model)
 {
     this._scheduleRepository.Add(model);
     return(this._scheduleRepository.SaveChanges());
 }
Пример #47
0
        private Schedule CreateSchedule(DateTime date)
        {
            Schedule schedule = new Schedule();

            DateTime monday = date.AddDays(-(int)date.DayOfWeek);

            schedule.Start = monday;
            schedule.End   = monday.AddDays(6);

            int year;
            int month;
            int day;

            for (int i = 0; i < 6; i++)
            {
                monday = monday.AddDays(1);
                year   = monday.Year;
                month  = monday.Month;
                day    = monday.Day;

                List <Slot> slots = new List <Slot> {
                    new Slot(new DateTime(year, month, day).AddHours(8).AddMinutes(30), new DateTime(year, month, day).AddHours(9).AddMinutes(15), true),
                    new Slot(new DateTime(year, month, day).AddHours(9).AddMinutes(30), new DateTime(year, month, day).AddHours(10).AddMinutes(15), false),
                    new Slot(new DateTime(year, month, day).AddHours(10).AddMinutes(45), new DateTime(year, month, day).AddHours(11).AddMinutes(30), true),
                    new Slot(new DateTime(year, month, day).AddHours(11).AddMinutes(45), new DateTime(year, month, day).AddHours(12).AddMinutes(30), false),
                    new Slot(new DateTime(year, month, day).AddHours(13).AddMinutes(30), new DateTime(year, month, day).AddHours(14).AddMinutes(15), true),
                    new Slot(new DateTime(year, month, day).AddHours(14).AddMinutes(30), new DateTime(year, month, day).AddHours(15).AddMinutes(15), true),
                    new Slot(new DateTime(year, month, day).AddHours(15).AddMinutes(30), new DateTime(year, month, day).AddHours(16).AddMinutes(15), true),
                    new Slot(new DateTime(year, month, day).AddHours(16).AddMinutes(30), new DateTime(year, month, day).AddHours(17).AddMinutes(15), false),
                    new Slot(new DateTime(year, month, day).AddHours(19), new DateTime(year, month, day).AddHours(19).AddMinutes(45), false)
                };

                slots.ForEach(s => {
                    db.Slots.Add(s);
                });

                db.SaveChanges();

                switch (i)
                {
                case 0:
                    schedule.Monday = slots;
                    break;

                case 1:
                    schedule.Tuesday = slots;
                    break;

                case 2:
                    schedule.Wednesday = slots;
                    break;

                case 3:
                    schedule.Thursday = slots;
                    break;

                case 4:
                    schedule.Friday = slots;
                    break;

                case 5:
                    schedule.Saturday = slots;
                    break;
                }
            }

            db.Schedules.Add(schedule);
            db.SaveChanges();

            return(schedule);
        }
Пример #48
0
        private static Dictionary <Point, string[]> GenerateTimeTable(Schedule solution, Dictionary <Point, int[]> slotTable)
        {
            int numberOfRooms = solution.Configuration.NumberOfRooms;
            int daySize       = Constant.DAY_HOURS * numberOfRooms;

            int ci      = 0;
            var classes = solution.Classes;

            var timeTable = new Dictionary <Point, string[]>();

            foreach (var cc in classes.Keys)
            {
                // coordinate of time-space slot
                var reservation = classes[cc];
                int day         = reservation.Day + 1;
                int time        = reservation.Time + 1;
                int room        = reservation.Room;

                var key          = new Point(time, room);
                var roomDuration = slotTable.ContainsKey(key) ? slotTable[key] : null;
                if (roomDuration == null)
                {
                    roomDuration   = new int[ROOM_COLUMN_NUMBER];
                    slotTable[key] = roomDuration;
                }
                roomDuration[day] = cc.Duration;
                for (int m = 1; m < cc.Duration; ++m)
                {
                    var nextRow = new Point(time + m, room);
                    if (!slotTable.ContainsKey(nextRow))
                    {
                        slotTable.Add(nextRow, new int[ROOM_COLUMN_NUMBER]);
                    }
                    if (slotTable[nextRow][day] < 1)
                    {
                        slotTable[nextRow][day] = -1;
                    }
                }

                var roomSchedule = timeTable.ContainsKey(key) ? timeTable[key] : null;
                var sb           = new StringBuilder();
                if (roomSchedule == null)
                {
                    roomSchedule   = new string[ROOM_COLUMN_NUMBER];
                    timeTable[key] = roomSchedule;
                }
                sb.Append(cc.Course.Name).Append("<br />").Append(cc.Professor.Name).Append("<br />");
                sb.Append(string.Join("/", cc.Groups.Select(grp => grp.Name).ToArray()));
                sb.Append("<br />");
                if (cc.LabRequired)
                {
                    sb.Append("Lab<br />");
                }

                for (int i = 0; i < CRITERIAS.Length; ++i)
                {
                    sb.Append("<span style='color:");
                    if (solution.Criteria[ci + i])
                    {
                        sb.Append(COLOR1).Append("' title='");
                        sb.Append(string.Format(CRITERIAS_DESCR[i], (i == 1 || i == 2) ? "" : "no "));
                    }
                    else
                    {
                        sb.Append(COLOR2).Append("' title='");
                        sb.Append(string.Format(CRITERIAS_DESCR[i], (i == 1 || i == 2) ? "not " : ""));
                    }
                    sb.Append("'> ").Append(CRITERIAS[i]);
                    sb.Append(" </span>");
                }
                roomSchedule[day] = sb.ToString();
                ci += CRITERIAS.Length;
            }
            return(timeTable);
        }
Пример #49
0
        private void ReadEffectiveWeeklySchedule()
        {
            Schedule.BeginUpdate();
            Schedule.Nodes.Clear();

            byte[] InOutBuffer = null;

            try
            {
                if (comm.RawEncodedDecodedPropertyConfirmedRequest(adr, schedule_id, BacnetPropertyIds.PROP_WEEKLY_SCHEDULE, BacnetConfirmedServices.SERVICE_CONFIRMED_READ_PROPERTY, ref InOutBuffer))
                {
                    int  offset = 0;
                    byte tag_number;
                    uint len_value_type;

                    // Tag 3
                    offset += ASN1.decode_tag_number(InOutBuffer, offset, out tag_number);
                    if (tag_number != 3)
                    {
                        return;
                    }

                    for (int i = 1; i < 8; i++)
                    {
                        TreeNode tday = null;

                        tday = new TreeNode("[" + (i - 1).ToString() + "] : " + System.Globalization.CultureInfo.InvariantCulture.DateTimeFormat.DayNames[i % 7], 0, 0);

                        Schedule.Nodes.Add(tday);

                        // Tag 0
                        offset += ASN1.decode_tag_number(InOutBuffer, offset, out tag_number);
                        while (!ASN1.IS_CLOSING_TAG(InOutBuffer[offset]))
                        {
                            BacnetValue value;
                            String      s;

                            // Time
                            offset += ASN1.decode_tag_number_and_value(InOutBuffer, offset, out tag_number, out len_value_type);
                            offset += ASN1.bacapp_decode_data(InOutBuffer, offset, InOutBuffer.Length, (BacnetApplicationTags)tag_number, len_value_type, out value);
                            DateTime dt = (DateTime)value.Value;

                            // Value
                            offset += ASN1.decode_tag_number_and_value(InOutBuffer, offset, out tag_number, out len_value_type);
                            offset += ASN1.bacapp_decode_data(InOutBuffer, offset, InOutBuffer.Length, (BacnetApplicationTags)tag_number, len_value_type, out value);

                            if (value.Tag != BacnetApplicationTags.BACNET_APPLICATION_TAG_NULL)
                            {
                                s            = dt.ToString("T") + " = " + Property.SerializeValue(value, value.Tag); // Second value is the ... value (Bool, Int, Uint, Float, double or null)
                                ScheduleType = value.Tag;                                                            // all type must be the same for a valid schedule (maybe, not sure !), so remember it
                            }
                            else
                            {
                                s = dt.ToString("T") + " = null";
                            }

                            tday.Nodes.Add(new TreeNode(s, 1, 1));
                        }
                        offset++;
                    }
                    offset += ASN1.decode_tag_number(InOutBuffer, offset, out tag_number);
                    if (tag_number != 3)
                    {
                        Schedule.Nodes.Clear();
                    }
                }
            }
            catch { }
            finally
            {
                Schedule.EndUpdate();

                Schedule.Sort(); // Time entries are not necesserary sorted, so do it (that's also why days are assign to [0], .. [6])
                Schedule.ExpandAll();
                Schedule.LabelEdit = true;
            }
        }
Пример #50
0
        private void BindReminders()
        {
            Mediachase.IBN.Business.ToDo.ToDoSecurity sec = Mediachase.IBN.Business.ToDo.GetSecurity(ToDoID);
            bool IsMember = sec.IsManager || sec.IsResource || sec.IsCreator;

            if (IsMember && TargetStartDate > DateTime.UtcNow)
            {
                int  Lag      = -1;
                bool IsActive = false;

                using (IDataReader reader = Schedule.GetReminderSubscriptionPersonalForObject(DateTypes.Todo_StartDate, ToDoID))
                {
                    if (reader.Read())
                    {
                        Lag      = (int)reader["Lag"];
                        IsActive = (bool)reader["IsActive"];
                    }
                }

                if (IsActive)
                {
                    imgReminderStart.ToolTip = String.Format("{0}: {1}", LocRM2.GetString("Start"), CommonHelper.GetIntervalString(Lag));
                }
                else
                {
                    imgReminderStart.ToolTip = CommonHelper.GetIntervalString(-1);
                    if (imgReminderStart.ToolTip.StartsWith("["))
                    {
                        imgReminderStart.ToolTip = imgReminderStart.ToolTip.Substring(1);
                    }
                    if (imgReminderStart.ToolTip.EndsWith("]"))
                    {
                        imgReminderStart.ToolTip = imgReminderStart.ToolTip.Substring(0, imgReminderStart.ToolTip.Length - 1);
                    }
                    imgReminderStart.ImageUrl = "~/Layouts/Images/reminder2.gif";
                }
            }
            else
            {
                imgReminderStart.Visible = false;
            }

            if (IsMember && TargetFinishDate > DateTime.UtcNow)
            {
                int  Lag      = -1;
                bool IsActive = false;

                using (IDataReader reader = Schedule.GetReminderSubscriptionPersonalForObject(DateTypes.Todo_FinishDate, ToDoID))
                {
                    if (reader.Read())
                    {
                        Lag      = (int)reader["Lag"];
                        IsActive = (bool)reader["IsActive"];
                    }
                }

                if (IsActive)
                {
                    imgReminderFinish.ToolTip = String.Format("{0}: {1}", LocRM2.GetString("Finish"), CommonHelper.GetIntervalString(Lag));
                }
                else
                {
                    imgReminderFinish.ToolTip = CommonHelper.GetIntervalString(-1);
                    if (imgReminderFinish.ToolTip.StartsWith("["))
                    {
                        imgReminderFinish.ToolTip = imgReminderFinish.ToolTip.Substring(1);
                    }
                    if (imgReminderFinish.ToolTip.EndsWith("]"))
                    {
                        imgReminderFinish.ToolTip = imgReminderFinish.ToolTip.Substring(0, imgReminderFinish.ToolTip.Length - 1);
                    }
                    imgReminderFinish.ImageUrl = "~/Layouts/Images/reminder2.gif";
                }
            }
            else
            {
                imgReminderFinish.Visible = false;
            }
        }
Пример #51
0
        } // BuildDescription

        public void BuildDescription(bool pastTime, bool withBasicDescription, bool withFullDescription, bool withChannel, bool withSchedule, bool withDuration, TimeSpan?overrideTotalRecordTime, StringBuilder buffer)
        {
            if ((withBasicDescription) || (withFullDescription))
            {
                var taskFormat = withFullDescription ? Properties.Texts.BuildDescriptionTaskDescription : Properties.Texts.BuildDescriptionTaskName;
                buffer.AppendFormat(taskFormat, Description.Name, Description.Description);
                buffer.AppendLine();
            } // if

            if (withChannel)
            {
                buffer.AppendFormat(Properties.Texts.BuildDescriptionChannel,
                                    Channel.LogicalNumber, Channel.Name,
                                    Channel.ChannelUrl,
                                    Channel.ServiceName);
                buffer.AppendLine();
            } // if withChannel

            if (withSchedule)
            {
                buffer.AppendLine(Properties.Texts.BuildDescriptionScheduleHeader);
                Schedule.Verbalize(pastTime, buffer);
                buffer.AppendLine();
            } // if withSchedule

            if (withDuration)
            {
                buffer.AppendLine(Properties.Texts.BuildDescriptionDurationHeader);
                var startSafetyMargin = Schedule.SafetyMarginTimeSpan;
                var endSafetyMargin   = Duration.SafetyMarginTimeSpan;
                var recordDuration    = Duration.Length;
                var totalRecordTime   = startSafetyMargin + recordDuration + endSafetyMargin;
                if (overrideTotalRecordTime.HasValue)
                {
                    totalRecordTime = overrideTotalRecordTime.Value;
                }

                var formatDuration = pastTime ? Properties.Texts.BuildDescriptionDurationPast : Properties.Texts.BuildDescriptionDuration;
                buffer.AppendFormat(formatDuration,
                                    recordDuration, (int)endSafetyMargin.TotalMinutes,
                                    totalRecordTime);
                buffer.AppendLine();

                if (Schedule.Kind != RecordScheduleKind.RightNow)
                {
                    string format;
                    var    startDate = Schedule.StartDate - Schedule.SafetyMarginTimeSpan;
                    var    endDate   = startDate + totalRecordTime;
                    if (startDate.Day == endDate.Day)
                    {
                        format = pastTime ? Properties.Texts.BuildDescriptionDurationEndsSameDay : Properties.Texts.BuildDescriptionDurationEndsToday;
                    }
                    else
                    {
                        format = pastTime ? Properties.Texts.BuildDescriptionDurationEndsNextDay : Properties.Texts.BuildDescriptionDurationEndsTomorrow;
                    } // if-else
                    buffer.AppendFormat(format, endDate);
                }
                else
                {
                } // if-else
                buffer.AppendLine();
            }     // if withDuration

            // remove last CRLF
            if (buffer.Length > 2)
            {
                buffer.Remove(buffer.Length - 2, 2);
            } // if
        }     // BuildDescription
Пример #52
0
        public void TaskStarting_Canceled_Success()
        {
            bool TaskStartingExecuted = false;
            Scheduler <BlockingScheduledAction> scheduler = new Scheduler <BlockingScheduledAction>(TimeSpan.FromSeconds(0.1));

            scheduler.TaskStarting += (sender, e) =>
            {
                e.Cancel             = true;
                TaskStartingExecuted = true;
            };
            BlockingScheduledAction action1 = new BlockingScheduledAction();
            ScheduledTask <BlockingScheduledAction> task = new ScheduledTask <BlockingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now), action1, true, null, null);

            scheduler.Tasks.Add(task);
            scheduler.Start();

            SpinWait.SpinUntil(() => { return(TaskStartingExecuted); });
            scheduler.Stop();

            Assert.IsNull(task.LastEndTime);

            scheduler.Dispose();
        }