public void Run_WhenCanceled_ExpectExits() { // Arrange var mockBuffer = new Mock <IBuffer>(); var mockStopwatchFactory = new Mock <IStopwatchFactory>(); var mockDelayCalculator = new Mock <IDelayCalculator>(); var scheduleSettings = new ScheduleSettings { ThrottleTime = TimeSpan.FromMilliseconds(10) }; var pumpProcessor = new PumpProcessor( this.LoggerFactory, mockBuffer.Object, mockStopwatchFactory.Object, mockDelayCalculator.Object, scheduleSettings); var cancellationTokenSource = new CancellationTokenSource(); cancellationTokenSource.Cancel(); // Act var stopwatch = Stopwatch.StartNew(); pumpProcessor.Run(cancellationTokenSource.Token); stopwatch.Stop(); // Assert this.WriteTimeElapsed(stopwatch); mockBuffer.Verify(r => r.ProcessBufferAsync(It.IsAny <CancellationToken>()), Times.Never()); }
public bool TestExclusions(DateTime dateTime, string asset) { //arrange var dateService = new Mock <IDateService>(); dateService.Setup(s => s.Now()).Returns(dateTime); var settings = new ScheduleSettings( dayOffStartDay: DayOfWeek.Friday, dayOffStartTime: new TimeSpan(21, 0, 0), dayOffEndDay: DayOfWeek.Sunday, dayOffEndTime: new TimeSpan(21, 0, 0), assetPairsWithoutDayOff: new[] { AssetWithoutDayOff, "BTCCHF" }.ToHashSet(), pendingOrdersCutOff: new TimeSpan(1, 0, 0)); var dayOffSettingsService = new Mock <IDayOffSettingsService>(); dayOffSettingsService.Setup(s => s.GetScheduleSettings()).Returns(settings); dayOffSettingsService.Setup(s => s.GetExclusions(AssetWithDayOff)) .Returns(ImmutableArray.Create( new DayOffExclusion(Guid.NewGuid(), "smth", new DateTime(2017, 6, 24, 01, 00, 00), new DateTime(2017, 6, 24, 04, 00, 00), true))); dayOffSettingsService.Setup(s => s.GetExclusions(AssetWithoutDayOff)) .Returns(ImmutableArray.Create( new DayOffExclusion(Guid.NewGuid(), "smth", new DateTime(2017, 6, 24, 03, 00, 00), new DateTime(2017, 6, 24, 04, 00, 00), false))); var dayOffService = new AssetPairDayOffService(dateService.Object, dayOffSettingsService.Object); //act return(dayOffService.ArePendingOrdersDisabled(asset)); }
public StateMachineSchedule(string name, Expression <Func <TInstance, Guid?> > tokenIdExpression, ScheduleSettings <TInstance, TMessage> settings) { _name = name; _settings = settings; _tokenIdProperty = new ReadWriteProperty <TInstance, Guid?>(tokenIdExpression.GetPropertyInfo()); }
public static IReadOnlyList <ScheduleSettings> GetMarketHoursScheduleSettings( this MarketSchedule marketSchedule, string marketId, string marketName, string assetRegex) { var result = new List <ScheduleSettings>(); var daySessionsCount = marketSchedule.Open.Length; for (int i = 0; i < daySessionsCount; i++) { var isLastTradingSession = i == daySessionsCount - 1; var sessionClose = marketSchedule.Close[i]; var nextSessionOpen = isLastTradingSession ? marketSchedule.Open[0] : marketSchedule.Open[i + 1]; var ss = ScheduleSettings.Create( $"{marketId}_none_working_hours_open{sessionClose}_close{nextSessionOpen}", marketId, marketName, new ScheduleConstraint { Time = sessionClose }, new ScheduleConstraint { Time = nextSessionOpen }, assetRegex); result.Add(ss); } return(result); }
public void Remove(ScheduleSettings entity) { var item = Items.First(i => i.Schedule == entity); Items.Remove(item); entity.Notify(); }
public void Resolve_Schedules_IsExpected(string mockResult) { var mock = new Mock <IResolver <DateTime, string> >(); mock.Setup(m => m.Resolve(It.IsAny <DateTime>())) .Returns(mockResult) .Verifiable(); var schedules = new ScheduleSettings { { "Default", new TimeRangeSettings() }, { "Explicit", new TimeRangeSettings() } }; var sut = new ScheduleResolver(mock.Object, schedules); var actual = sut.Resolve(DateTime.Today); mock.Verify(); if (mockResult == null) { actual.Name.Should().NotBeNull().And.NotBe(mockResult); } else { actual.Name.Should().Be(mockResult); } }
public TvTamerService(IDatabaseUpdater databaseUpdater, IEpisodeProcessor episodeProcessor, IEpisodeDownloader episodeDownloader, ScheduleSettings scheduleSettings) { _databaseUpdater = databaseUpdater; _episodeProcessor = episodeProcessor; _episodeDownloader = episodeDownloader; _scheduleSettings = scheduleSettings; }
public SettingPage() { InitializeComponent(); PageTitle = string.Format("{0} - {1}", AppResources.ApplicationTitle, AppResources.Settings); scheduleSettings = MutexedIsoStorageFile.Read <ScheduleSettings>("ScheduleSettings", Constants.MUTEX_DATA); //초기 락스크린 컬러 피커값 저장 loadOrgColorPickerValue(); }
private void AddSettings(List <IScheduleSettings> data, string marketId, ScheduleConstraint start, ScheduleConstraint end, int rank = 0, bool enabled = false) { var settings = new ScheduleSettings(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), rank, "*", new HashSet <string>(0), marketId, enabled, TimeSpan.Zero, start, end); data.Add(settings); }
/// <summary> /// Declares a schedule placeholder that is stored with the state machine instance /// </summary> /// <typeparam name="TMessage">The scheduled message type</typeparam> /// <param name="propertyExpression">The schedule property on the state machine</param> /// <param name="tokenIdExpression">The property where the tokenId is stored</param> /// <param name="settings">The request settings (which can be read from configuration, etc.)</param> protected void Schedule <TMessage>(Expression <Func <Schedule <TInstance, TMessage> > > propertyExpression, Expression <Func <TInstance, Guid?> > tokenIdExpression, ScheduleSettings <TInstance, TMessage> settings) where TMessage : class { var property = propertyExpression.GetPropertyInfo(); var name = property.Name; var schedule = new StateMachineSchedule <TInstance, TMessage>(name, tokenIdExpression, settings); property.SetValue(this, schedule); Event(propertyExpression, x => x.Received); if (settings.Received == null) { Event(propertyExpression, x => x.AnyReceived); } else { Event(propertyExpression, x => x.AnyReceived, x => { settings.Received(x); }); } DuringAny( When(schedule.AnyReceived) .ThenAsync(async context => { Guid?tokenId = schedule.GetTokenId(context.Instance); ConsumeContext consumeContext; if (context.TryGetPayload(out consumeContext)) { Guid?messageTokenId = consumeContext.GetSchedulingTokenId(); if (messageTokenId.HasValue) { if (!tokenId.HasValue || (messageTokenId.Value != tokenId.Value)) { if (_log.IsDebugEnabled) { _log.DebugFormat("SAGA: {0} Scheduled message not current: {1}", context.Instance.CorrelationId, messageTokenId.Value); } return; } } } BehaviorContext <TInstance, TMessage> eventContext = context.GetProxy(schedule.Received, context.Data); await((StateMachine <TInstance>) this).RaiseEvent(eventContext).ConfigureAwait(false); schedule.SetTokenId(context.Instance, default(Guid?)); })); }
private TemplateNodeUpdateJob CreateJob(ScheduleSettingsRow row, TemplateNodeInfo node) { var scheduleSettings = new ScheduleSettings { ActiveWeekDays = row.ActiveWeekDays .Split(',') .Select( s => { DayOfWeek result; if (Enum.TryParse(s, out result)) { return(result as DayOfWeek?); } return(null); }) .Where(d => d != null) .Select(d => d.Value).ToList(), Enabled = row.Enabled, Id = row.TemplateNodesScheduleUserId, Name = row.TemplateNodesScheduleUserName, IsSendMessage = row.IsSendMessage, EndDate = row.EndDate.GetValueOrDefault(), OccursOnceDateTime = row.OccursOnceDateTime, OccursOnceDateTimeEnabled = row.OccursOnceDateTimeEnabled, StartDate = row.StartDate, DayOfMonth = new DayOfMonthSettings { DayNumber = (int)row.DayNumber }, ReccurPeriod = new TimeUnitBasedPeriod( (ReccurPeriodTimeUnit)row.TimeUnit, (int)row.TimeUnitCount), DailyFrequency = new DailyFrequency { EndingAt = row.EndingAt.FromTicks(), OccursOnceTime = row.OccursOnceTime.FromTicks(), PeriodTimeUnit = row.PeriodTimeUnit.HasValue ? (DailyFrequency.TimeUnit?)row.PeriodTimeUnit.Value : null, PeriodTimeUnitCount = (int?)row.PeriodTimeUnitCount, StartingAt = row.StartingAt.FromTicks(), OccursOnce = row.OccursOnce }, HasEndDate = row.EndDate.HasValue }; return(new TemplateNodeUpdateJob { LastRan = row.LastRan, Settings = scheduleSettings, NodeInfo = node, SettingsId = row.Identity }); }
public StartupManager( ILogFactory logFactory, BuildReportJob job, ScheduleSettings scheduleSettings) { _log = logFactory.CreateLog(this); _job = job; _scheduleSettings = scheduleSettings; }
public StartupManager( ILogFactory logFactory, ScheduleSettings scheduleSettings, TransactionsSnapshotRepository transactionsSnapshotRepository) { _scheduleSettings = scheduleSettings; _transactionsSnapshotRepository = transactionsSnapshotRepository; _log = logFactory.CreateLog(this); }
/// <summary> /// Из выбранных дней недели /// </summary> /// <param name="s"></param> /// <param name="r"></param> /// <returns></returns> private bool FromDaysOfWeek(ScheduleSettings s, CreateRuleSettingsRequest r) { return((s.IsMonday && r.Date.DayOfWeek == DayOfWeek.Monday) || (s.IsTuesday && r.Date.DayOfWeek == DayOfWeek.Tuesday) || (s.IsWednesday && r.Date.DayOfWeek == DayOfWeek.Wednesday) || (s.IsThursday && r.Date.DayOfWeek == DayOfWeek.Thursday) || (s.IsFriday && r.Date.DayOfWeek == DayOfWeek.Friday) || (s.IsSaturday && r.Date.DayOfWeek == DayOfWeek.Saturday) || (s.IsSunday && r.Date.DayOfWeek == DayOfWeek.Sunday)); }
// // GET: /Scheduler/ public ActionResult Index() { var schedule = RavenSession.Load <ScheduleSettings>("scheduleSettings/1"); var data = new List <EmailReminderData>(); int delayHours = 4; if (schedule == null) { schedule = new ScheduleSettings { Id = "scheduleSettings/1" }; RavenSession.Store(schedule); ViewBag.Message = "This is the first run!"; ViewBag.Error = "First run, creating session"; return(View()); } if ((DateTime.Now - schedule.LastRun).TotalHours > delayHours) { try { var logic = new ReminderHelper(RavenSession, Server.MapPath("/Views/Templates/")); var reminders = logic.GetAllRemindersDueBefore(DateTime.Now); var msgs = logic.ComposeMessages(reminders); ViewBag.Messages = msgs; var emails = logic.SendEmails(msgs); ViewBag.SentMessages = emails; logic.UpdateMsgCount(reminders); } catch (Exception ex) { ViewBag.Error = ex.Message; } ViewBag.Message = "Last run: " + schedule.LastRun; if (data.Count > 0) { string emailText = GetEmailText(data); RavenSession.Store(new TempTextEmail { Text = emailText }); } schedule.LastNumberOfNotifications = data.Count; schedule.LastRun = DateTime.Now; RavenSession.SaveChanges(); } else { ViewBag.Error = "Scheduler will not run before" + (delayHours - (DateTime.Now - schedule.LastRun).TotalHours).ToString() + " hours"; } return(View(data)); }
public void Run_WhenDataProcessed_ExpectBatchSubmittedEvent() { // Arrange var mockBuffer = new Mock <IBuffer>(); var mockStopwatchFactory = new Mock <IStopwatchFactory>(); var mockStopwatch = new Mock <IStopwatch>(); var mockDelayCalculator = new Mock <IDelayCalculator>(); mockStopwatchFactory.Setup(r => r.StartNew()).Returns(mockStopwatch.Object); mockDelayCalculator.Setup(r => r.GetNextDelay(It.IsAny <TimeSpan>(), It.IsAny <TimeSpan>())) .Returns(TimeSpan.FromMilliseconds(100)); mockBuffer.Setup(r => r.ProcessBufferAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(new BufferProcessResponse { Processed = 10, Remaining = 10 }); var scheduleSettings = new ScheduleSettings { ThrottleTime = TimeSpan.FromMilliseconds(10) }; var pumpProcessor = new PumpProcessor( this.LoggerFactory, mockBuffer.Object, mockStopwatchFactory.Object, mockDelayCalculator.Object, scheduleSettings); // Act var stopwatch = Stopwatch.StartNew(); pumpProcessor.Run(CancellationToken.None); stopwatch.Stop(); // Assert this.WriteTimeElapsed(stopwatch); var manualResetEventSlim = new ManualResetEventSlim(false); pumpProcessor.BatchSubmitted += (sender, i) => manualResetEventSlim.Set(); var wasTriggered = manualResetEventSlim.Wait(TimeSpan.FromMilliseconds(100)); Assert.That(wasTriggered, Is.True); mockBuffer.Verify(r => r.ProcessBufferAsync(It.IsAny <CancellationToken>()), Times.AtLeastOnce()); }
/// <summary> /// Initializes a new instance of the <see cref="PumpProcessor" /> class. /// </summary> /// <param name="loggerFactory">The logger factory.</param> /// <param name="buffer">The buffer.</param> /// <param name="stopwatchFactory">The stopwatch factory.</param> /// <param name="delayCalculator">The delay calculator.</param> /// <param name="scheduleSettings">The schedule settings.</param> public PumpProcessor( [NotNull] ILoggerFactory loggerFactory, [NotNull] IBuffer buffer, [NotNull] IStopwatchFactory stopwatchFactory, [NotNull] IDelayCalculator delayCalculator, [NotNull] ScheduleSettings scheduleSettings) { this.buffer = buffer; this.stopwatchFactory = stopwatchFactory; this.delayCalculator = delayCalculator; this.scheduleSettings = scheduleSettings; this.logger = loggerFactory.CreateLogger <PumpProcessor>(); }
public static IReadOnlyList <ScheduleSettings> GetScheduleSettings(this IEnumerable <WorkingDay> days, string marketId, string marketName, string assetRegex) { return(days .Where(d => d.CanHaveScheduleConstraint()) .Select(d => ScheduleSettings.Create( d.GetScheduleId(marketId), marketId, marketName, d.GetStartScheduleConstraint(), d.GetEndScheduleConstraint(), assetRegex)) .ToList()); }
void _Init(ScheduleSettings scheduleSettings) { Asr.IsTrue(_instance == this); _dispose = React.Scope(out var scope); Sch.Scope = scope; _completed = false; Sch.Logic = StartSch(scheduleSettings.Logic, scope); (_update, Sch.Update) = scope.PubSub(); (_lateUpdate, Sch.LateUpdate) = scope.PubSub(); (_fixedUpdate, Sch.Physics) = scope.PubSub(); (_updateTime, Sch.UpdateTime) = scope.PubSub <float>(); (_fixedUpdateTime, Sch.PhysicsTime) = scope.PubSub <float>(); (SchPub.PublishError, Sch.OnError) = Sch.Scope.PubSub <Exception>(); }
/// <summary> /// Creates this instance. /// </summary> /// <param name="queueConfiguration">The queue configuration.</param> /// <param name="loggerFactory">The logger factory.</param> /// <returns> /// The <see cref="IQueue" /> /// </returns> public static IQueue Create( QueueConfiguration queueConfiguration, ILoggerFactory loggerFactory = null) { var logger = loggerFactory ?? new LoggerFactory(); var queueEndpoint = new QueueEndpoint { ConnectionString = queueConfiguration.QueueConnectionString, QueueName = queueConfiguration.QueueName }; var serializerSettings = new SerializerSettings { SerializerType = queueConfiguration.SerializerType }; var batchSettings = new BatchSettings { MaxQueueMessagesPerSchedule = queueConfiguration.MaxQueueMessagesPerSchedule, MaxMessagesPerQueueMessage = queueConfiguration.MaxMessagesPerQueueMessage }; var scheduleSettings = new ScheduleSettings { ThrottleTime = queueConfiguration.ThrottleTime }; var queueWrapper = new QueueWrapper(queueEndpoint); var messageSerializer = new MessageSerializer(serializerSettings); var queueMessageSerializer = new QueueMessageSerializer(batchSettings, messageSerializer); var buffer = new Buffer(logger, queueWrapper, queueMessageSerializer); var stopwatchFactory = new StopwatchFactory(); var delayCalculator = new DelayCalculator(); var pumpProcessor = new PumpProcessor( logger, buffer, stopwatchFactory, delayCalculator, scheduleSettings); var queuePump = new QueuePump(buffer, pumpProcessor); return(new Queue(queuePump)); }
private static ScheduleSettingsContract Convert([CanBeNull] ScheduleSettings shedule) { if (shedule == null) { return(null); } return(new ScheduleSettingsContract { AssetPairsWithoutDayOff = shedule.AssetPairsWithoutDayOff, DayOffEndDay = shedule.DayOffEndDay, DayOffEndTime = shedule.DayOffEndTime, DayOffStartDay = shedule.DayOffStartDay, DayOffStartTime = shedule.DayOffStartTime, PendingOrdersCutOff = shedule.PendingOrdersCutOff, }); }
private ScheduleSettings CreateSchedules() { var schedules = new ScheduleSettings { { "Empty", new TimeRangeSettings { Start = "00:00", Finish = "00:00" } }, { "Invalid", new TimeRangeSettings { Start = "00:01", Finish = "00:00" } }, { "Valid", new TimeRangeSettings { Start = "00:00", Finish = "00:01" } } }; return(schedules); }
public static ScheduleSettings GetSingleSessionScheduleSettings(string marketId, string marketName, string assetRegex, TimeSpan open, TimeSpan close) { return(ScheduleSettings.Create( $"{marketId}_working_hours_open{open}_close{close}", marketId, marketName, new ScheduleConstraint { Time = close }, new ScheduleConstraint { Time = open }, assetRegex)); }
private static void CloneScheduleSettings(TypiconVersion version, ScheduleSettings scheduleSettings) { if (scheduleSettings != null) { version.ScheduleSettings = new ScheduleSettings() { IsMonday = scheduleSettings.IsMonday, IsTuesday = scheduleSettings.IsTuesday, IsWednesday = scheduleSettings.IsWednesday, IsThursday = scheduleSettings.IsThursday, IsFriday = scheduleSettings.IsFriday, IsSaturday = scheduleSettings.IsSaturday, IsSunday = scheduleSettings.IsSunday }; version.ScheduleSettings.IncludedDates.AddRange(scheduleSettings.IncludedDates); version.ScheduleSettings.ExcludedDates.AddRange(scheduleSettings.ExcludedDates); } }
public static List <ScheduleSettings> MapWeekends(string marketId, string marketName, List <DayOfWeek> weekends, string assetPairRegex) { var result = new List <ScheduleSettings>(); foreach (var weekend in weekends) { var start = new ScheduleConstraint { DayOfWeek = weekend }; var end = new ScheduleConstraint { DayOfWeek = weekend == DayOfWeek.Saturday ? DayOfWeek.Sunday : weekend + 1 }; var id = $"{marketId}_{weekend.ToString()}"; result.Add(ScheduleSettings.Create(id, marketId, marketName, start, end, assetPairRegex)); } return(result); }
public async Task Run_WhenRun_ExpectBufferProcessed() { // Arrange var mockBuffer = new Mock <IBuffer>(); var mockStopwatchFactory = new Mock <IStopwatchFactory>(); var mockStopwatch = new Mock <IStopwatch>(); var mockDelayCalculator = new Mock <IDelayCalculator>(); mockStopwatchFactory.Setup(r => r.StartNew()).Returns(mockStopwatch.Object); mockBuffer.Setup(r => r.ProcessBufferAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(new BufferProcessResponse()); mockDelayCalculator.Setup(r => r.GetNextDelay(It.IsAny <TimeSpan>(), It.IsAny <TimeSpan>())) .Returns(TimeSpan.FromMilliseconds(100)); var scheduleSettings = new ScheduleSettings { ThrottleTime = TimeSpan.FromMilliseconds(10) }; var pumpProcessor = new PumpProcessor( this.LoggerFactory, mockBuffer.Object, mockStopwatchFactory.Object, mockDelayCalculator.Object, scheduleSettings); // Act var stopwatch = Stopwatch.StartNew(); Assert.DoesNotThrow(() => pumpProcessor.Run(CancellationToken.None)); stopwatch.Stop(); // Assert this.WriteTimeElapsed(stopwatch); await Task.Delay(200).ConfigureAwait(false); mockBuffer.Verify(r => r.ProcessBufferAsync(It.IsAny <CancellationToken>()), Times.AtLeastOnce()); }
public async Task RefreshNotifications(ulong serverId, ScheduleSettings settings) { var now = DateTime.UtcNow.Add(settings.TimezoneOffset); var context = _notifications.GetOrAdd(serverId, x => new NotificationContext(serverId, OnNotify)); using (await context.Lock.ClaimAsync()) { var next = settings.Events.SkipWhile(x => x.Date < now).FirstOrDefault(x => x.Notify && x.HasTime); if (context.UtcDueTime.HasValue && (next == null || context.UtcDueTime <= next.Date.Subtract(settings.TimezoneOffset))) { return; } if (next == null || (next.Date - now).TotalMilliseconds >= int.MaxValue) { context.Disable(); return; } context.Replan(next.Date - now, next.Date.Subtract(settings.TimezoneOffset)); } }
public bool TestDayOff(DateTime dateTime, string asset) { //arrange var dateService = new Mock <IDateService>(); dateService.Setup(s => s.Now()).Returns(dateTime); var settings = new ScheduleSettings( dayOffStartDay: DayOfWeek.Friday, dayOffStartTime: new TimeSpan(21, 0, 0), dayOffEndDay: DayOfWeek.Sunday, dayOffEndTime: new TimeSpan(21, 0, 0), assetPairsWithoutDayOff: new[] { AssetWithoutDayOff, "BTCCHF" }.ToHashSet(), pendingOrdersCutOff: TimeSpan.Zero); var dayOffSettingsService = new Mock <IDayOffSettingsService>(); dayOffSettingsService.Setup(s => s.GetScheduleSettings()).Returns(settings); dayOffSettingsService.Setup(s => s.GetExclusions(It.IsNotNull <string>())).Returns(ImmutableArray <DayOffExclusion> .Empty); var dayOffService = new AssetPairDayOffService(dateService.Object, dayOffSettingsService.Object); //act return(dayOffService.IsDayOff(asset)); }
private List<ScheduleSettings> LoadFromConfig() { List<ScheduleSettings> settings = new List<ScheduleSettings>(); try { // Get the application configuration file. System.Configuration.Configuration config = System.Configuration.ConfigurationManager.OpenExeConfiguration( ConfigurationUserLevel.None) as System.Configuration.Configuration; // Read and display the custom section. ScheduleConfigurationSection scheduleSection = System.Configuration.ConfigurationManager.GetSection("scheduling") as ScheduleConfigurationSection; if (scheduleSection == null) { throw new Exception("Failed to load scheduling config."); } else { for (int i = 0; i < scheduleSection.ScheduleProviders.Count; i++) { var prxy = scheduleSection.ScheduleProviders[i]; if (!string.IsNullOrEmpty(prxy.Name)) { var setting = new ScheduleSettings(GetScheduleSettings(prxy)); settings.Add(setting); } } } } catch (ConfigurationErrorsException err) { throw err; } return settings; }
public static List <ScheduleSettings> MapHolidays(string marketId, string marketName, IEnumerable <DateTime> holidays, string assetPairRegex) { var result = new List <ScheduleSettings>(); foreach (var holiday in holidays) { var start = new ScheduleConstraint { Date = holiday.Date }; var end = new ScheduleConstraint { Date = holiday.Date.AddDays(1) }; var id = $"{marketId}_holiday_{holiday.Date}"; result.Add(ScheduleSettings.Create(id, marketId, marketName, start, end, assetPairRegex)); } return(result); }
public static void CreateDefaultValues() { ScheduleSettings scheduleSetting = MutexedIsoStorageFile.Read <ScheduleSettings>("ScheduleSettings", Constants.MUTEX_DATA); //락스크린의 템플릿 SetDefaultSetting(Constants.LOCKSCREEN_BACKGROUND_TEMPLATE, new LockscreenTemplateItem() { LockscreenItemInfos = new LockscreenItemInfo[] { new LockscreenItemInfo { LockscreenItem = LiveItems.Weather, Column = 0, Row = 0, ColSpan = 1, RowSpan = 3 }, new LockscreenItemInfo { LockscreenItem = LiveItems.Calendar, Column = 1, Row = 0, ColSpan = 1, RowSpan = 3 } } }); //락스크린의 뒷배경 분할 SetDefaultSetting(Constants.LOCKSCREEN_BACKGROUND_USE_SEPARATION, false); //락스크린의 배경 색상 SetDefaultSetting(Constants.LOCKSCREEN_BACKGROUND_COLOR, new ColorItem() { Text = AppResources.ColorChrome, Color = ColorItem.ConvertColor(0xFF1F1F1F) }); //락스크린의 배경 투명도 SetDefaultSetting(Constants.LOCKSCREEN_BACKGROUND_OPACITY, Constants.LOCKSCREEN_BACKGROUND_DEFAULT_OPACITY); //락스크린의 글자 굵기 SetDefaultSetting(Constants.LOCKSCREEN_FONT_WEIGHT, FontWeights.Bold.ToString()); //락스크린의 업데이트 주기 if (scheduleSetting.LockscreenUpdateInterval == 0) { scheduleSetting.LockscreenUpdateInterval = 180; MutexedIsoStorageFile.Write <ScheduleSettings>(scheduleSetting, "ScheduleSettings", Constants.MUTEX_DATA); } //라이브타일 랜덤색상 사용여부 SetDefaultSetting(Constants.LIVETILE_RANDOM_BACKGROUND_COLOR, true); ColorItem accentColorItem = new ColorItem() { Color = (Color)Application.Current.Resources["PhoneAccentColor"] }; if (string.IsNullOrEmpty(accentColorItem.Text)) { accentColorItem.Text = AppResources.AccentColor; } //메인 라이브타일의 배경색상 SetDefaultSetting(Constants.LIVETILE_CALENDAR_BACKGROUND_COLOR, accentColorItem); //보조 라이브타일의 템플릿... SetDefaultSetting(Constants.LIVETILE_WEATHER_BACKGROUND_COLOR, accentColorItem); //배터리 라이브타일의 템플릿... SetDefaultSetting(Constants.LIVETILE_BATTERY_BACKGROUND_COLOR, accentColorItem); //날씨 타일 폰트 크기 SetDefaultSetting(Constants.LIVETILE_WEATHER_FONT_SIZE, new PickerItem() { Key = 1.1, Name = string.Format(AppResources.Percent, 1.1 * 100) }); //날씨 및 달력의 글자 굵기 SetDefaultSetting(Constants.LIVETILE_FONT_WEIGHT, FontWeights.SemiBold.ToString()); //배터리 완충 상태 표시 SetDefaultSetting(Constants.LIVETILE_BATTERY_FULL_INDICATION, new PickerItem() { Key = 100, Name = AppResources.BatteryFull }); //라이브타일의 업데이트 주기 if (scheduleSetting.LivetileUpdateInterval == 0) { scheduleSetting.LivetileUpdateInterval = 60; MutexedIsoStorageFile.Write <ScheduleSettings>(scheduleSetting, "ScheduleSettings", Constants.MUTEX_DATA); } //보호색 사용여부 SetDefaultSetting(Constants.CHAMELEON_USE_PROTECTIVE_COLOR, true); //보호이미지 사용여부 SetDefaultSetting(Constants.CHAMELEON_USE_PROTECTIVE_IMAGE, false); SetDefaultSetting(Constants.CHAMELEON_SKIN_BACKGROUND_COLOR, new ColorItem() { Color = ColorItem.GetColorByName("Green") }); //날씨 위치 서비스 if (!SettingHelper.ContainsKey(Constants.WEATHER_USE_LOCATION_SERVICES)) { SettingHelper.Set(Constants.WEATHER_USE_LOCATION_SERVICES, true, false); } //날씨 표시 단위 if (!SettingHelper.ContainsKey(Constants.WEATHER_UNIT_TYPE)) { if (System.Globalization.CultureInfo.CurrentUICulture.Name == "en-US") { SettingHelper.Set(Constants.WEATHER_UNIT_TYPE, DisplayUnit.Fahrenheit, false); } else { SettingHelper.Set(Constants.WEATHER_UNIT_TYPE, DisplayUnit.Celsius, false); } } //날씨 기본 아이콘 설정 if (!SettingHelper.ContainsKey(Constants.WEATHER_ICON_TYPE)) { SettingHelper.Set(Constants.WEATHER_ICON_TYPE, WeatherIconType.Simple01, false); } //달력의 첫요일 SetDefaultSetting(Constants.CALENDAR_FIRST_DAY_OF_WEEK, DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek); //달력 약속 표시 SetDefaultSetting(Constants.CALENDAR_SHOW_APPOINTMENT, true); //시작 페이지 설정 SetDefaultSetting(Constants.COMMON_FIRST_PAGE_ITEM, 0); //기본 빙마켓 설정 SetDefaultSetting(Constants.BING_LANGUAGE_MARKET, System.Globalization.CultureInfo.CurrentUICulture.Name); SetDefaultSetting(Constants.BING_SEARCH_ASPECT, "Tall"); SetDefaultSetting(Constants.BING_SEARCH_OPTIONS, "None"); SetDefaultSetting(Constants.BING_SEARCH_SIZE, "Large"); SetDefaultSetting(Constants.BING_SEARCH_SIZE_WIDTH, "" + (int)ResolutionHelper.CurrentResolution.Width); SetDefaultSetting(Constants.BING_SEARCH_SIZE_HEIGHT, "" + (int)ResolutionHelper.CurrentResolution.Height); SetDefaultSetting(Constants.BING_SEARCH_COLOR, "Color"); SetDefaultSetting(Constants.BING_SEARCH_STYLE, "Photo"); SetDefaultSetting(Constants.BING_SEARCH_FACE, "Other"); SetDefaultSetting(Constants.BING_SEARCH_COUNT, "40"); SetDefaultSetting(Constants.BING_SEARCH_ADULT, "Strict"); //손전등 - 토글버튼 사용 설정 SetDefaultSetting(Constants.FLASHLIGHT_USE_TOGGLE_SWITCH, true); SettingHelper.Save(); }