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();
}
