Exemple #1
0
        private Song GetSong()
        {
            HolidayManager           holidayManager = new HolidayManager();
            List <string>            toSearch;
            RandomItemsProductPicker randomItemsProductPicker = new RandomItemsProductPicker();
            List <Song> listOfSongs = new List <Song>();

            if (holidayManager.IsHoliday(DateTime.Now, out toSearch))
            {
                // search items based on the keywords if it's a holiday
                var listOfSearchedSongs = randomItemsProductPicker.PickItems(
                    ReadersFactory.GetProductsReader(),
                    ReadersFactory.GetStocksReader(),
                    Filters.GetFilterByKeyWords(toSearch, typeof(Song)), 1);
                listOfSongs = listOfSearchedSongs.ConvertAll(x => (Song)x);
                return(listOfSongs[0]);
            }
            else
            {
                var listOfRandomBooks = randomItemsProductPicker.PickItems(
                    ReadersFactory.GetProductsReader(),
                    ReadersFactory.GetStocksReader(),
                    Filters.GetFilterByType(typeof(Song)), 1);
                listOfSongs = listOfRandomBooks.ConvertAll(x => (Song)x);
                return(listOfSongs[0]);
            }
        }
Exemple #2
0
        private List <string> GetSourceFileLinks(string baseUrl)
        {
            holidayList = HolidayManager.SelectHoliday(5);
            List <string> linkList   = new List <string>();
            string        pageSource = WebClientUtil.GetPageSource(baseUrl, 1800000);
            HtmlDocument  htmlDoc    = new HtmlDocument();

            htmlDoc.LoadHtml(pageSource);
            var    tableList      = htmlDoc.DocumentNode.SelectNodes("//table[@class = 'styleShiryo']");
            var    nodeDailyList  = tableList[1].SelectNodes("tr/td");
            string dailyExcelLink = "http://www.tse.or.jp" + MiscUtil.GetCleanTextFromHtml(nodeDailyList[2].SelectSingleNode("a").Attributes["href"].Value);

            linkList.Add(dailyExcelLink);
            if (DateTime.Today == MiscUtil.GetNextWeeklyTradingDay(DateTime.Today, holidayList, 2) || specialCase.Equals("yes"))
            {
                var    nodeWeeklyList = tableList[2].SelectNodes("tr/td");
                string titleWeekly    = MiscUtil.GetCleanTextFromHtml(nodeWeeklyList[0].InnerText);
                if (IsLastWeekInfo(titleWeekly) || specialCase.Equals("yes"))
                {
                    string weeklyExcelLink = "http://www.tse.or.jp" + MiscUtil.GetCleanTextFromHtml(nodeWeeklyList[2].SelectSingleNode("a").Attributes["href"].Value);
                    linkList.Add(weeklyExcelLink);
                }
            }
            return(linkList);
        }
        public ExcutionResult Save(Holiday holiday, string userId)
        {
            ExcutionResult result = new ExcutionResult();

            try
            {
                var param = HolidayManager.GetById(holiday.Id);
                var now   = DateTime.Now;
                if (param == null)
                {
                    holiday.CreatedAt = now;
                    holiday.CreatedBy = userId;
                    result            = HolidayManager.Insert(holiday);
                }
                else
                {
                    holiday.UpdatedAt = now;
                    holiday.UpdatedBy = userId;
                    result            = HolidayManager.Update(holiday);
                }
            }
            catch (Exception e)
            {
                result.ErrorCode = 1;
                result.Message   = e.Message;
                _iLogger.LogError(e.Message, e);
            }
            return(result);
        }
Exemple #4
0
        private void UpdateHolidayToDb(List <HolidayInfo> holiday)
        {
            int    rows = HolidayManager.UpdateHoliday(holiday);
            string msg  = string.Format("Updated {0} holiday record(s) in database. OK!", rows);

            Logger.Log(msg);
        }
        private void menuSettingsHolidays_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            var manager = HolidayManager.Create();

            using (XF_Holidays form = new XF_Holidays(manager))
                form.ShowDialog();
        }
Exemple #6
0
        private void updateHoliday()
        {
            if (!string.IsNullOrEmpty(tbHolidayName.Text))
            {
                HolidayItem item = new HolidayItem();

                item._HOLIDAY_ID   = selectedHolidayId;
                item._HOLIDAY_NAME = tbHolidayName.Text;
                item._HOLIDAY_DATE = (DateTime)dpHolidayDate.SelectedDate;
                item._HOLIDAY_TYPE = cbHolidayType.SelectedValue.ToString();

                try
                {
                    HolidayManager hm = new HolidayManager();
                    hm.UpdateHoliday(item);
                    MessageBox.Show("Holiday successfully updated.");
                }
                catch (System.Exception)
                {
                    MessageBox.Show("Server not responding.");
                }

                HolidayCollection holidayList = new HolidayCollection();
                holidayList.RetreiveAllHolidays();

                Close();
            }
            else
            {
                MessageBox.Show("Please input holiday name.");
            }
        }
Exemple #7
0
        private void saveHoliday()
        {
            if (isHolidayValid())
            {
                HolidayItem item = new HolidayItem();

                item._HOLIDAY_NAME = tbHolidayName.Text;
                item._HOLIDAY_DATE = (DateTime)dpHolidayDate.SelectedDate;
                item._HOLIDAY_TYPE = cbHolidayType.SelectedValue.ToString();

                try
                {
                    HolidayManager hm = new HolidayManager();
                    hm.SaveHoliday(item);
                    MessageBox.Show("New Holiday added.");
                }
                catch (System.Exception)
                {
                    MessageBox.Show("Server not responding.");
                }

                HolidayCollection holidayList = new HolidayCollection();
                holidayList.RetreiveAllHolidays();

                Close();
            }
        }
Exemple #8
0
        protected static void OnHolidayStarted()
        {
            Common.DebugNotify("OnHolidayStarted");

            HolidayManager ths = HolidayManager.sInstance;

            if (ths == null)
            {
                return;
            }

            if (SeasonsManager.sInstance == null)
            {
                return;
            }

            ths.OnHolidayStarted();

            if (!Tempest.Settings.mAllowHolidayParties)
            {
                NpcSeasonalPartyManager.ClearData(true);
            }

            sHolidayAlarm.Dispose();
            sHolidayAlarm = null;
        }
Exemple #9
0
        private void DeleteHoliday()
        {
            if (holidayBindingSource == null)
            {
                return;
            }
            var dResult = MessageBox.Show(@"Delete current record?", @"Delete", MessageBoxButtons.YesNo,
                                          MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);

            if (dResult != DialogResult.Yes)
            {
                return;
            }
            if (HolidayManager.Delete(((Holiday)holidayBindingSource.Current).HolidayId))
            {
                MessageBox.Show(@"Record was deleted successfully.", @"Delete", MessageBoxButtons.OK,
                                MessageBoxIcon.Information);
                holidayBindingSource.RemoveCurrent();
            }
            else
            {
                MessageBox.Show(@"Error on delete operation.", @"Delete", MessageBoxButtons.OK,
                                MessageBoxIcon.Error);
                holidayDataGridView.Focus();
            }
        }
Exemple #10
0
        private void DeleteHoliday()
        {
            string sMessageBoxText = "Do you want to delete this holiday?";
            string sCaption        = "Are you Sure?";

            MessageBoxButton btnMessageBox = MessageBoxButton.YesNo;
            MessageBoxImage  icnMessageBox = MessageBoxImage.Warning;

            MessageBoxResult rsltMessageBox = System.Windows.MessageBox.Show(sMessageBoxText, sCaption, btnMessageBox, icnMessageBox);

            switch (rsltMessageBox)
            {
            case MessageBoxResult.Yes:
                HolidayManager    hm = new HolidayManager();
                HolidayCollection hc = new HolidayCollection();
                hm.DeleteHoliday(selectedHolidayId);
                hc.RetreiveAllHolidays();
                MessageBox.Show("Holiday successfully deleted.");
                Close();
                break;

            case MessageBoxResult.No:
                break;
            }
        }
Exemple #11
0
 public HolidaysForm(HolidayManager _holidayManager)
 {
     InitializeComponent();
     holidayManager = _holidayManager;
     localDates     = holidayManager.Holidays;
     calendarHolidays.SelectedDates.AddRange(localDates.ToArray());
     UpdateDatesOnLabel();
 }
 /// <summary>
 /// Getting list of holidays date from workbook path given in parameters
 /// </summary>
 private void GetHolidays()
 {
     try
     {
         HolidayManager.SelectHoliday(5);
     }
     catch (Exception ex)
     {
         Logger.Log("Cannot get holidays", Logger.LogType.Error);
         throw new Exception("Cannot get holidays: " + ex.Message);
     }
 }
Exemple #13
0
        private static void CalculateDateTimeOfHoliday(HolidayManager ths, ref Season season)
        {
            DateAndTime startTime = SimClock.Subtract(SimClock.CurrentTime(), TimeUnit.Hours, SimClock.CurrentTime().Hour);

            startTime = SimClock.Subtract(startTime, TimeUnit.Days, Tempest.GetCurrentSeasonDay() - 1);

            List <Pair <Season, uint> > days = new List <Pair <Season, uint> >();

            HolidaySettings settings = Tempest.Settings.GetHolidays(season);

            Common.StringBuilder result = new Common.StringBuilder("Season: " + season);

            result += Common.NewLine + "CurrentTime: " + SimClock.CurrentTime();
            result += Common.NewLine + "StartTime: " + startTime;
            result += Common.NewLine + "ExpectedEndTime: " + SeasonsManager.ExpectedEndTime;
            result += Common.NewLine + "GetCurrentSeasonDay: " + Tempest.GetCurrentSeasonDay();
            result += Common.NewLine + SimClock.ElapsedTime(TimeUnit.Days, startTime);

            foreach (HolidaySettings.Holiday day in settings.Days)
            {
                uint actualDay = day.GetActualDay(season);
                if (actualDay == 0)
                {
                    continue;
                }

                days.Add(new Pair <Season, uint>(day.mSeason, actualDay - 1));
            }

            days.Sort(SortByDay);

            foreach (Pair <Season, uint> day in days)
            {
                ths.mStartDateTimeOfHoliday = SimClock.Add(startTime, TimeUnit.Days, day.Second);

                result += Common.NewLine + "Days: " + day.Second + " Time: " + ths.mStartDateTimeOfHoliday;

                if (ths.mStartDateTimeOfHoliday.Ticks < SimClock.CurrentTicks)
                {
                    ths.mStartDateTimeOfHoliday = DateAndTime.Invalid;
                }
                else
                {
                    result += Common.NewLine + " Success";

                    season = day.First;
                    break;
                }
            }

            Common.DebugNotify(result);
        }
        public JapanOSETradeVolumeUpdatorConfig()
        {
            InitialBusinessDay();
            List <DateTime> holidays = HolidayManager.SelectHoliday(5);
            DateTime        date     = DateTime.Today;

            date = date.AddDays(businessDay[date.DayOfWeek.ToString()]);
            while (IsHoliday(holidays, date))
            {
                date.AddDays(-1);
            }
            Date = date.ToString("yyyyMMdd");
        }
        // import de.jollyday.configuration.ConfigurationProvider;
        // import java.net.MalformedURLException;
        // private CollectionValuedMap<String, JollyHoliday> holidays;
        public virtual void Init(string prefix, Properties props)
        {
            string xmlPath     = props.GetProperty(prefix + "xml", "edu/stanford/nlp/models/sutime/jollyday/Holidays_sutime.xml");
            string xmlPathType = props.GetProperty(prefix + "pathtype", "classpath");

            varPrefix = props.GetProperty(prefix + "prefix", varPrefix);
            logger.Info("Initializing JollyDayHoliday for SUTime from " + xmlPathType + ' ' + xmlPath + " as " + prefix);
            Properties managerProps = new Properties();

            managerProps.SetProperty("manager.impl", "edu.stanford.nlp.time.JollyDayHolidays$MyXMLManager");
            try
            {
                URL holidayXmlUrl;
                if (Sharpen.Runtime.EqualsIgnoreCase(xmlPathType, "classpath"))
                {
                    holidayXmlUrl = GetType().GetClassLoader().GetResource(xmlPath);
                }
                else
                {
                    if (Sharpen.Runtime.EqualsIgnoreCase(xmlPathType, "file"))
                    {
                        holidayXmlUrl = new URL("file:///" + xmlPath);
                    }
                    else
                    {
                        if (Sharpen.Runtime.EqualsIgnoreCase(xmlPathType, "url"))
                        {
                            holidayXmlUrl = new URL(xmlPath);
                        }
                        else
                        {
                            throw new ArgumentException("Unsupported " + prefix + "pathtype = " + xmlPathType);
                        }
                    }
                }
                UrlManagerParameter ump = new UrlManagerParameter(holidayXmlUrl, managerProps);
                holidayManager = HolidayManager.GetInstance(ump);
            }
            catch (MalformedURLException e)
            {
                throw new Exception(e);
            }
            if (!(holidayManager is JollyDayHolidays.MyXMLManager))
            {
                throw new AssertionError("Did not get back JollyDayHolidays$MyXMLManager");
            }
            Configuration config = ((JollyDayHolidays.MyXMLManager)holidayManager).GetConfiguration();

            holidays = GetAllHolidaysMap(config);
        }
        public bool QueryIsHoliday(HolidayManager hgr, DateTime t1)
        {
            string today = t1.ToString("yyyyMMdd");
            //string status = null;
            HOLIDAY holiday = hgr.Query("SELECT * FROM HOLIDAY WHERE TO_CHAR(DAY,'yyyyMMdd') = " + today + "").FirstOrDefault();

            if (holiday != null && (!"0".Equals(holiday.STATUS)))
            {
                return(true); // 非工作日
            }
            else
            {
                return(false); // 工作日
            }
        }
        public ExcutionResult GetById(string id)
        {
            ExcutionResult result = new ExcutionResult();

            try
            {
                var param = HolidayManager.GetById(id);
                result.Data = param;
            }
            catch (Exception e)
            {
                result.ErrorCode = 1;
                result.Message   = e.Message;
                _iLogger.LogError(e.Message, e);
            }
            return(result);
        }
        public int[] CalculateCompareDateValues(DateTime t1, DateTime t2, HolidayManager hgr, bool flag, int num, int itervalnums)
        {
            if (DateTime.Compare(t1, t2) > 0)
            {
                while (flag && itervalnums < 1000)
                {
                    if (DateTime.Compare(t1, t2) > 0)
                    {
                        if (QueryIsHoliday(hgr, t2))
                        {
                            num++;
                        }

                        itervalnums++;
                        t2 = t2.AddDays(1);
                    }
                    else
                    {
                        flag = false;
                    }
                }
            }
            else
            {
                while (flag && itervalnums < 1000)
                {
                    if (DateTime.Compare(t1, t2) < 0)
                    {
                        if (QueryIsHoliday(hgr, t1))
                        {
                            num++;
                        }

                        itervalnums++;
                        t1 = t1.AddDays(1);
                    }
                    else
                    {
                        flag = false;
                    }
                }
            }
            int[] days = new int[] { num, itervalnums, itervalnums - num };
            return(days);
        }
        public ExcutionResult GetAllByPaging(PagingItem pagingItem)
        {
            ExcutionResult result = new ExcutionResult();

            try
            {
                var param = HolidayManager.GetAllByPaging(pagingItem);
                result.Data     = param;
                result.MetaData = pagingItem;
            }
            catch (Exception e)
            {
                result.ErrorCode = 1;
                result.Message   = e.Message;
                _iLogger.LogError(e.Message, e);
            }
            return(result);
        }
Exemple #20
0
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            try
            {
                datePickerStart.Date = DateTime.Parse(Settings.getValueByKey("DATEPICKERSTART", DateTime.Now.ToString()));
                datePickerEnd.Date   = DateTime.Parse(Settings.getValueByKey("DATEPICKEREND", DateTime.Now.AddDays(180).ToString()));
            }
            catch { }

            Holidays = HolidayManager.GetHolidays();


            LoadListViewHolidays();
            LoadlistViewNobMudYrd();
            Load_listViewNobMudYrdCalendar();
            App.Current.IsIdleChanged += onIsIdleChanged;
        }
        /// <summary>
        /// 比较时间大小
        /// </summary>
        /// <returns></returns>
        public int[] CompareDate(DateTime t1, DateTime t2, HolidayManager hgr)
        {
            bool flag        = true;
            int  num         = 0;
            int  itervalnums = 0;

            int[] days = null;
            if (t1.ToString("yyyyMMdd").Equals(t2.ToString("yyyyMMdd")))
            {
                days = new int[] { num, itervalnums, itervalnums - num };
            }
            else
            {
                days = CalculateCompareDateValues(t1, t2, hgr, flag, num, itervalnums);
            }



            return(days);
        }
Exemple #22
0
        // This alarm is fired at 23.99 on the previous day
        protected static void OnNewDay()
        {
            HolidayManager ths = HolidayManager.sInstance;

            if (ths != null)
            {
                // Clean up in case the previous holiday alarm is munched
                ths.OnHolidayDone();
            }

            SetUpHolidayManager(false);

            if (SeasonsManager.Enabled)
            {
                if (Tempest.Settings.GetHolidays(SeasonsManager.CurrentSeason).mNoSchool)
                {
                    foreach (SimDescription sim in Household.AllSimsLivingInWorld())
                    {
                        if (sim.CareerManager == null)
                        {
                            continue;
                        }

                        School school = sim.CareerManager.School;
                        if (school == null)
                        {
                            continue;
                        }

                        if (!school.IsWorkDay)
                        {
                            continue;
                        }

                        school.TakePaidTimeOff(1);
                    }
                }
            }
        }
Exemple #23
0
        private void holidayDataGridView_RowLeave(object sender, DataGridViewCellEventArgs e)
        {
            if (holidayBindingSource == null)
            {
                return;
            }
            if (holidayDataGridView.Rows.Count <= 1)
            {
                return;
            }
            if (!holidayDataGridView.IsCurrentRowDirty)
            {
                return;
            }
            Validate();
            holidayBindingSource.EndEdit();
            var iResult = HolidayManager.Save((Holiday)holidayBindingSource.Current);

            if (iResult > 0)
            {
                LoadInitHoliday();
            }
        }
Exemple #24
0
 public UnitOfWork(ApplicationDbContext context)
 {
     this.context       = context;
     Claims             = new ClaimManager(context);
     Departments        = new DepartmentManager(context);
     DepartmentProjects = new DepartmentProjectsManager(context);
     Engineers          = new EngineerManager(context);
     //EngineerSubTasks = new EngineerSubTasksManager(context);
     SubTaskSessions   = new SubTaskSessionManager(context);
     Projects          = new ProjectManager(context);
     SubTasks          = new SubTaskManager(context);
     Tasks             = new TaskManager(context);
     Teams             = new TeamManager(context);
     TeamTasks         = new TeamTasksManager(context);
     Invoices          = new InvoicesManager(context);
     InoviceItems      = new InvoiceItemManager(context);
     Dependency        = new DependencyManager(context);
     Notification      = new NotificationManager(context);
     NotificationUsers = new NotificationUsersManager(context);
     Files             = new FilesManager(context);
     Comments          = new CommentManager(context);
     Holiday           = new HolidayManager(context);
 }
        public ExcutionResult Delete(string id, string userId)
        {
            ExcutionResult rowAffected = new ExcutionResult();

            try
            {
                var param = HolidayManager.GetById(id);
                if (param != null)
                {
                    var now = DateTime.Now;
                    param.UpdatedAt = now;
                    param.UpdatedBy = userId;
                    rowAffected     = HolidayManager.Delete(param);
                }
            }
            catch (Exception e)
            {
                rowAffected.ErrorCode = 1;
                rowAffected.Message   = e.Message;
                _iLogger.LogError(e.Message, e);
            }
            return(rowAffected);
        }
 public AddEntryDialog(HolidayManager manager, SystemClock clock)
 {
     _manager = manager;
     _clock   = clock;
     InitializeComponent();
 }
Exemple #27
0
        private static void CalculateDateTimeOfHoliday(HolidayManager ths, ref Season season)
        {
            DateAndTime startTime = SimClock.Subtract(SimClock.CurrentTime(), TimeUnit.Hours, SimClock.CurrentTime().Hour);
            startTime = SimClock.Subtract(startTime, TimeUnit.Days, Tempest.GetCurrentSeasonDay() - 1);

            List<Pair<Season, uint>> days = new List<Pair<Season, uint>>();

            HolidaySettings settings = Tempest.Settings.GetHolidays(season);

            Common.StringBuilder result = new Common.StringBuilder("Season: " + season);

            result += Common.NewLine + "CurrentTime: " + SimClock.CurrentTime();
            result += Common.NewLine + "StartTime: " + startTime;
            result += Common.NewLine + "ExpectedEndTime: " + SeasonsManager.ExpectedEndTime;
            result += Common.NewLine + "GetCurrentSeasonDay: " + Tempest.GetCurrentSeasonDay();
            result += Common.NewLine + SimClock.ElapsedTime(TimeUnit.Days, startTime);

            foreach (HolidaySettings.Holiday day in settings.Days)
            {                
                uint actualDay = day.GetActualDay(season);                
                if (actualDay == 0) continue;

                days.Add(new Pair<Season, uint>(day.mSeason, actualDay - 1));
            }

            days.Sort(SortByDay);

            foreach (Pair<Season, uint> day in days)
            {                
                ths.mStartDateTimeOfHoliday = SimClock.Add(startTime, TimeUnit.Days, day.Second);

                result += Common.NewLine + "Days: " + day.Second + " Time: " + ths.mStartDateTimeOfHoliday;

                if (ths.mStartDateTimeOfHoliday.Ticks < SimClock.CurrentTicks)
                {
                    ths.mStartDateTimeOfHoliday = DateAndTime.Invalid;
                }
                else
                {
                    result += Common.NewLine + " Success";

                    season = day.First;
                    break;
                }
            }

            Common.DebugNotify(result);
        }
Exemple #28
0
        public override void OnDelayedWorldLoadFinished()
        {
            Overwatch.Log("CleanupTimers");

            Dictionary <DateAndTime, Dictionary <MethodInfo, Dictionary <ReferenceWrapper, bool> > > lookup = new Dictionary <DateAndTime, Dictionary <MethodInfo, Dictionary <ReferenceWrapper, bool> > >();

            Dictionary <AlarmHandle, AlarmManager> remove = new Dictionary <AlarmHandle, AlarmManager>();

            Dictionary <AlarmManager, bool> managers = new Dictionary <AlarmManager, bool>();

            managers.Add(AlarmManager.Global, true);

            foreach (Lot lot in LotManager.AllLots)
            {
                if (lot.mSavedData.mAlarmManager == null)
                {
                    continue;
                }

                if (managers.ContainsKey(lot.AlarmManager))
                {
                    continue;
                }

                managers.Add(lot.AlarmManager, true);
            }

            Dictionary <ulong, SimDescription> sims = SimListing.GetResidents(true);

            foreach (AlarmManager manager in managers.Keys)
            {
                foreach (KeyValuePair <AlarmHandle, List <AlarmManager.Timer> > list in manager.mTimers)
                {
                    foreach (AlarmManager.Timer timer in list.Value)
                    {
                        bool removed = false;

                        SimDescription sim = timer.ObjectRef as SimDescription;
                        if (sim != null)
                        {
                            if (!sim.IsValidDescription)
                            {
                                remove[list.Key] = manager;

                                Overwatch.Log(" Invalid Sim " + sim.FullName);
                                removed = true;
                            }
                        }
                        else
                        {
                            GameObject gameObject = timer.ObjectRef as GameObject;
                            if (gameObject != null)
                            {
                                if (gameObject.HasBeenDestroyed)
                                {
                                    remove[list.Key] = manager;

                                    Overwatch.Log(" Destroyed Object " + gameObject.GetType());
                                    removed = true;
                                }
                            }
                        }

                        AlarmTimerCallback callback = timer.CallBack;

                        if (callback == null)
                        {
                            remove[list.Key] = manager;

                            Overwatch.Log(" Removed Empty Alarm");
                            removed = true;
                        }
                        else
                        {
                            Writing.RoyaltyAlarm royaltyAlarm = callback.Target as Writing.RoyaltyAlarm;
                            if (royaltyAlarm != null)
                            {
                                string reason = null;
                                if ((royaltyAlarm.mSkill == null) || (royaltyAlarm.mSkill.SkillOwner == null))
                                {
                                    reason = "No Skill";
                                }
                                else if (!royaltyAlarm.mSkill.SkillOwner.IsValidDescription)
                                {
                                    reason = "Bad Sim";
                                }
                                else if (royaltyAlarm.mSkill.SkillOwner.SkillManager == null)
                                {
                                    reason = "No Manager";
                                }
                                else
                                {
                                    Writing skill = royaltyAlarm.mSkill.SkillOwner.SkillManager.GetSkill <Writing>(SkillNames.Writing);
                                    if (skill != royaltyAlarm.mSkill)
                                    {
                                        reason = "Not Royalty Skill";
                                    }
                                    else if (skill.mRoyaltyAlarm != royaltyAlarm)
                                    {
                                        reason = "Not Royalty Alarm";
                                    }
                                }

                                if (reason != null)
                                {
                                    remove[list.Key] = manager;

                                    Overwatch.Log(" Invalid Royalty Alarm: " + reason);
                                    removed = true;
                                }
                            }
                            else
                            {
                                MethodInfo info = typeof(LunarCycleManager).GetMethod("PossiblySpawnZombie", BindingFlags.Static | BindingFlags.NonPublic);
                                if (callback.Method == info)
                                {
                                    if (LunarCycleManager.mZombieAlarm != timer.Handle)
                                    {
                                        remove[list.Key] = manager;

                                        Overwatch.Log(" Invalid Zombie Alarm");
                                        removed = true;
                                    }
                                }
                                else
                                {
                                    info = typeof(MeteorShower).GetMethod("RandomMeteorShowerCallback", BindingFlags.Static | BindingFlags.Public);
                                    if (callback.Method == info)
                                    {
                                        if (MeteorShower.RandomMeteorShowerAlarmHandler != timer.Handle)
                                        {
                                            remove[list.Key] = manager;

                                            Overwatch.Log(" Invalid Meteor Shower Alarm");
                                            removed = true;
                                        }
                                    }
                                }
                            }

                            if (!removed)
                            {
                                Dictionary <MethodInfo, Dictionary <ReferenceWrapper, bool> > methods;
                                if (!lookup.TryGetValue(timer.AlarmDateAndTime, out methods))
                                {
                                    methods = new Dictionary <MethodInfo, Dictionary <ReferenceWrapper, bool> >();
                                    lookup[timer.AlarmDateAndTime] = methods;
                                }

                                Dictionary <ReferenceWrapper, bool> objects;
                                if (!methods.TryGetValue(callback.Method, out objects))
                                {
                                    objects = new Dictionary <ReferenceWrapper, bool>();
                                    methods[callback.Method] = objects;
                                }

                                ReferenceWrapper reference = new ReferenceWrapper(callback.Target);

                                if (objects.ContainsKey(reference))
                                {
                                    remove[list.Key] = manager;

                                    Overwatch.Log(" Removed Duplicate Alarm: " + timer.AlarmDateAndTime + " " + callback.Method + " (" + callback.Target + ")");
                                }
                                else
                                {
                                    objects[reference] = true;
                                }
                            }
                        }
                    }
                }
            }

            foreach (KeyValuePair <AlarmHandle, AlarmManager> handle in remove)
            {
                handle.Value.RemoveAlarm(handle.Key);
            }

            // cleanup trick or treating fail
            HolidayManager instance = HolidayManager.Instance;

            if (instance != null && AlarmManager.Global != null)
            {
                if (!instance.IsFallHoliday && TrickOrTreatSituation.NPCTrickOrTreatAlarm != AlarmHandle.kInvalidHandle)
                {
                    Overwatch.Log("Cleaned up run away trick or treat alarm");
                    AlarmManager.Global.RemoveAlarm(TrickOrTreatSituation.NPCTrickOrTreatAlarm);
                    TrickOrTreatSituation.NPCTrickOrTreatAlarm = AlarmHandle.kInvalidHandle;
                }
            }
        }
Exemple #29
0
        /// <summary>
        /// Find next trading day as effective date.
        /// </summary>
        private void InitialzeEffectiveDate()
        {
            List <DateTime> holidayList = HolidayManager.SelectHoliday(MarketId);

            effectiveDate = MiscUtil.GetNextTradingDay(DateTime.Today, holidayList, 1).ToString("yyyy-MM-dd", new CultureInfo("en-US"));
        }
Exemple #30
0
 public MainForm()
 {
     InitializeComponent();
     holidayManager  = new HolidayManager();
     employeeManager = new EmployeeManager(ref holidayManager);
 }
 private void InstanceMembers()
 {
     _whManager = new DayWorkingHoursManager();
     _dayAgendasManager = new DayAgendasManager();
     _holidayManager = new HolidayManager();
     _bookingsManager = new BookingsManager();
 }
        public new void Show()
        {
            #region THEME SETUP
            Themes.Theme theme = ThemeManager.Themes.ContainsKey(AppConfig.Instance.currentTheme ?? "") ? ThemeManager.Themes[AppConfig.Instance.currentTheme] : ThemeManager.Themes["Metro/LightGreen"];
            ThemeManager.Apply(theme);
            #endregion

            ImportAssetsForm iaf = new ImportAssetsForm();
            iaf.ShowDialog();

            Width     *= AppConfig.Instance.scale;
            Height    *= AppConfig.Instance.scale;
            MinWidth  *= AppConfig.Instance.scale;
            MinHeight *= AppConfig.Instance.scale;
            #region OPEN_WITH
            string[] args = Environment.GetCommandLineArgs();
            App.Logger.Log($"Command Line Args: {string.Join(";", args)}");
            if (args?.Length >= 2)
            {
                for (int k = 1; k < args.Length; k++)
                {
                    try
                    {
                        CurrentProject.file = args[k];
                        if (CurrentProject.Load(new NPCProject()))
                        {
                            App.NotificationManager.Clear();
                            App.NotificationManager.Notify(LocalizationManager.Current.Notification["Project_Loaded"]);
                            AddToRecentList(CurrentProject.file);
                            break;
                        }
                        else
                        {
                            CurrentProject.file = "";
                        }
                    }
                    catch { }
                }
            }
            #endregion
            #region APPAREL SETUP
            faceImageIndex.Maximum  = faceAmount - 1;
            beardImageIndex.Maximum = beardAmount - 1;
            hairImageIndex.Maximum  = haircutAmount - 1;
            //(CharacterEditor as CharacterEditor).FaceImageIndex_Changed(null, new RoutedPropertyChangedEventArgs<double?>(0, 0));
            //(CharacterEditor as CharacterEditor).HairImageIndex_Changed(null, new RoutedPropertyChangedEventArgs<double?>(0, 0));
            //(CharacterEditor as CharacterEditor).BeardImageIndex_Changed(null, new RoutedPropertyChangedEventArgs<double?>(0, 0));
            #endregion
            RefreshRecentList();
            #region AFTER UPDATE
            try
            {
                string updaterPath = Path.Combine(AppConfig.Directory, "updater.exe");
                if (File.Exists(updaterPath))
                {
                    OpenPatchNotes();
                    File.Delete(updaterPath);
                    App.Logger.Log("Updater deleted.");
                }
            }
            catch { App.Logger.Log("Can't delete updater.", ELogLevel.WARNING); }
            #endregion
            #region AUTOSAVE INIT
            if (AppConfig.Instance.autosaveOption > 0)
            {
                AutosaveTimer = new DispatcherTimer();
                switch (AppConfig.Instance.autosaveOption)
                {
                case 1:
                    AutosaveTimer.Interval = new TimeSpan(0, 5, 0);
                    break;

                case 2:
                    AutosaveTimer.Interval = new TimeSpan(0, 10, 0);
                    break;

                case 3:
                    AutosaveTimer.Interval = new TimeSpan(0, 15, 0);
                    break;

                case 4:
                    AutosaveTimer.Interval = new TimeSpan(0, 30, 0);
                    break;

                case 5:
                    AutosaveTimer.Interval = new TimeSpan(1, 0, 0);
                    break;
                }
                AutosaveTimer.Tick += AutosaveTimer_Tick;
                AutosaveTimer.Start();
            }
            #endregion
            #region AppUpdate
            AppUpdateTimer = new DispatcherTimer
            {
                Interval = new TimeSpan(0, 0, 1)
            };
            AppUpdateTimer.Tick += AppUpdateTimer_Tick;
            AppUpdateTimer.Start();
            #endregion
            #region VERSION SPECIFIC CODE
#if !DEBUG
            debugOverlayText.Visibility = Visibility.Collapsed;
#endif
#if PREVIEW
            previewOverlayText.Visibility = Visibility.Visible;
#endif
            #endregion
            #region DISCORD
            DiscordManager = new DiscordRPC.DiscordManager(1000)
            {
                descriptive = AppConfig.Instance.enableDiscord
            };
            DiscordManager?.Initialize();
            MainWindowViewModel.TabControl_SelectionChanged(mainTabControl, null);
            #endregion
            #region ENABLE EXPERIMENTAL
            if (AppConfig.Instance.experimentalFeatures)
            {
            }
            #endregion
            #region CONTEXT MENUS

            #endregion
            HolidayManager.Check();
            if (App.Package.Guides.Count > 0)
            {
                foreach (KeyValuePair <string, string> guide in App.Package.Guides)
                {
                    guidesMenuItem.Items.Add(new MenuItem()
                    {
                        Header  = guide.Key,
                        Command = new BaseCommand(() =>
                        {
                            System.Diagnostics.Process.Start(guide.Value);
                        })
                    });
                }
            }
            else
            {
                guidesMenuItem.IsEnabled = false;
            }

            if (string.IsNullOrEmpty(App.Package.GetTemplatesURL))
            {
                getTemplatesMenuItem.IsEnabled = false;
            }
            else
            {
                getTemplatesMenuItem.Click += (sender, e) =>
                {
                    Process.Start(App.Package.GetTemplatesURL);
                };
            }

            if (App.Package.FeedbackLinks.Length > 0)
            {
                foreach (Data.AppPackage.FeedbackLink link in App.Package.FeedbackLinks)
                {
                    MenuItem newItem = new MenuItem()
                    {
                        Header  = link.Localize ? LocalizationManager.Current.Interface[link.Text] : link.Text,
                        Command = new BaseCommand(() =>
                        {
                            System.Diagnostics.Process.Start(link.URL);
                        })
                    };
                    if (!string.IsNullOrEmpty(link.Icon))
                    {
                        try
                        {
                            newItem.Icon = new Image()
                            {
                                Width  = 16,
                                Height = 16,
                                Source = new BitmapImage(new Uri(link.Icon))
                            };
                        }
                        catch (Exception ex)
                        {
                            App.Logger.LogException("Could not load feedback icon", ex: ex);
                        }
                    }
                    commMenuItem.Items.Add(newItem);
                }
            }
            else
            {
                commMenuItem.IsEnabled = false;
            }

            try
            {
                foreach (Data.AppPackage.Notification n in App.Package.Notifications)
                {
                    string text = n.Localize ? LocalizationManager.Current.Notification.Translate(n.Text) : n.Text;

                    List <Button> _buttons = new List <Button>();

                    foreach (Data.AppPackage.Notification.Button b in n.Buttons)
                    {
                        string bText = b.Localize ? LocalizationManager.Current.Notification.Translate(b.Text) : b.Text;

                        Button elem = new Button()
                        {
                            Content = new TextBlock()
                            {
                                Text = bText
                            }
                        };
                        elem.Click += (_, __) => b.GetButtonAction().Invoke();

                        _buttons.Add(elem);
                    }

                    App.NotificationManager.Notify(text, buttons: _buttons.ToArray());
                }
            }
            catch (Exception ex)
            {
                App.Logger.LogException("Could not display notification(s)", ex: ex);
            }

            if (App.Package.Patrons.Length > 0)
            {
                var pList = App.Package.Patrons.ToList();
                pList.Shuffle();
                string pjoined = string.Join(", ", pList.Take(5));

                App.NotificationManager.Notify(LocalizationManager.Current.Notification.Translate("StartUp_Patreon_Patrons", pjoined));
            }

            ConsoleLogger.StartWaitForInput();

            Loaded += (sender, e) =>
            {
                var scr = ScreenHelper.GetCurrentScreen(this);

                var sz = scr.Size;

                if (sz.Width < MinWidth || sz.Height < MinHeight)
                {
                    var res = MessageBox.Show(LocalizationManager.Current.Interface["Warning_Scale"], Title, MessageBoxButton.YesNo);

                    if (res == MessageBoxResult.Yes)
                    {
                        MinWidth  /= AppConfig.Instance.scale;
                        MinHeight /= AppConfig.Instance.scale;
                        Width     /= AppConfig.Instance.scale;
                        Height    /= AppConfig.Instance.scale;

                        this.Left = (sz.Width - Width) / 2 + sz.Left;
                        this.Top  = (sz.Height - Height) / 2 + sz.Top;

                        Application.Current.Resources["Scale"] = 1.0;

                        AppConfig.Instance.scale = 1.0;

                        AppConfig.Instance.Save();
                    }
                }

                if (GameAssetManager.HasImportedAssets)
                {
                    if (!File.Exists(Path.Combine(AppConfig.Instance.unturnedDir, "Extras", "Icons", "Bag_MRE_81.png")))
                    {
                        MessageBox.Show(LocalizationManager.Current.Notification["StartUp_IconsNotGenerated"], Title, MessageBoxButton.OK);
                    }
                }
            };

            base.Show();
        }