///// <summary>
///// Create a new, ephermal metric to watch
///// </summary>
///// <param name="pipeline"></param>
///// <param name="jsAggregator"></param>
///// <param name="name"></param>
///// <param name="connection"></param>
///// <param name="connectionId"></param>
//public JavascriptMetricConnection(EventPipeline pipeline, string jsAggregator, string name, IConnection connection, string connectionId, string javascriptId) {
// _connection = connection;
// _javascriptId = javascriptId;
// _connectionId = connectionId;
// var jsMetric = new JavascriptMetric(name, jsAggregator);
// jsMetric.Updated(connectionId, Updated);
// pipeline.AddProcessor(jsMetric);
// SendUpdates();
//}
/// <summary>
/// Bind to an existing metric given by "name"
/// </summary>
/// <param name="pipeline"></param>
/// <param name="name"></param>
/// <param name="connection"></param>
/// <param name="connectionId"></param>
public JavascriptMetricConnection(EventPipeline pipeline, string name, IConnection connection, string connectionId, string javascriptId, string keyFilter, TimePeriod period)
{
_connection = connection;
_connectionId = connectionId;
_javascriptId = javascriptId;
_timePeriod = period;
_keyFilter = PeriodMetric.BaseKey(name, _timePeriod, keyFilter);
if (string.IsNullOrEmpty(_keyFilter)) {
_keyFilter = "*";
}
// Try to find the metric, and add a watcher
var processor = pipeline.GetProcessor(name);
if (processor == null) {
throw new Exception(string.Format("Unable to find metric with name {0}", name));
}
var jsMetric = processor as JavascriptMetric;
if (jsMetric == null) {
throw new Exception(string.Format("Found metric with name {0}, but its not a JavascriptMetric", name));
}
jsMetric.Updated(_connectionId, Updated);
SendUpdates();
}
public void Create(IList<BondAnalysisLine> lines_, BondField field_, TimePeriod period_)
{
setupStuff();
BoxSetSeries series = (BoxSetSeries)ultraChart1.CompositeChart.Series[0];
series.BoxSets.Clear();
m_lineData_dt.Rows.Clear();
foreach (var bondstats in lines_)
{
var fieldValues = bondstats.GetHistoricValuesForField(field_, period_);
if (fieldValues == null || fieldValues.Length==0)
continue;
var last = fieldValues.Data.Last();
QuickSort.Sort(fieldValues.Data);
series.BoxSets.Add(new BoxSet()
{
Label = bondstats.Bond,
Min = fieldValues.Data[0],
Max = fieldValues.Data.Last(),
Q1 = fieldValues.Data[(int) fieldValues.Length/4],
Q2 = fieldValues.Data.Average(),
Q3 = fieldValues.Data[(int) fieldValues.Length/4*3]
});
m_lineData_dt.LoadDataRow(new object[] {bondstats.Bond, last},true);
}
}
public void ProcessRequest(HttpContext context)
{
try
{
context.Server.ScriptTimeout = PageTimeout;
WebUtil.TryEnableCompression(context);
context.Response.ContentType = "text/plain";
var requestParams = context.Request.Params;
var appKey = requestParams.Get("Application") ?? "";
var period = new TimePeriod(requestParams);
var sessions = DataReader.GetSessions(appKey, period);
foreach (var session in sessions)
{
context.Response.Write(session.Serialize());
context.Response.Write(Environment.NewLine);
}
}
catch (Exception exc)
{
WebLogger.Report(exc);
context.Response.Write(exc.ToString());
}
}
/// <summary>
/// </summary>
/// <param name="name">Name of the maintenance.</param>
/// <param name="groupids">IDs of the host groups that will undergo maintenance.</param>
/// <param name="hostids">IDs of the hosts that will undergo maintenance.</param>
/// <param name="timeperiods">Maintenance time periods.</param>
public Create(string name, int[] groupids, int[] hostids, TimePeriod[] timeperiods)
: base(name)
{
this.groupids = groupids;
this.hostids = hostids;
this.timeperiods = timeperiods;
}
public List<TimePeriod> generateCalendar1()
{
List<TimePeriod> list = new List<TimePeriod>();
TimePeriod tp1 = new TimePeriod();
tp1.Start = new DateTime(2015, 12, 12, 9, 30, 0);
tp1.End = new DateTime(2015, 12, 12, 11, 30, 0);
list.Add(tp1);
TimePeriod tp2 = new TimePeriod();
tp2.Start = new DateTime(2015, 12, 12, 12, 30, 0);
tp2.End = new DateTime(2015, 12, 12, 13, 30, 0);
list.Add(tp2);
TimePeriod tp3 = new TimePeriod();
tp3.Start = new DateTime(2015, 12, 12, 15, 00, 0);
tp3.End = new DateTime(2015, 12, 12, 18, 30, 0);
list.Add(tp3);
TimePeriod tp4 = new TimePeriod();
tp4.Start = new DateTime(2015, 12, 12, 21, 20, 0);
tp4.End = new DateTime(2015, 12, 12, 22, 00, 0);
list.Add(tp4);
return list;
}
/// <summary>
/// Get the data from the specified time period, if available. If no data are available, NULL is returned.
/// </summary>
/// <param name="timePeriod"></param>
/// <returns></returns>
public SoundSpeedField this[TimePeriod timePeriod]
{
get
{
return SoundSpeedFields.Find(t => t.TimePeriod == timePeriod);
}
}
//present past constructor
public Portrait(string saveString, TimePeriod period)
{
this.sheet = sheetMan.getSheet("portrait");
wasMoved = false;
if (period == TimePeriod.Present)
{
parseString(saveString, "EndPresentPortrait");
wasMoved = true;
inTime = TimePeriod.Present;
sendTime = TimePeriod.Past;
}
else if (period == TimePeriod.Past)
{
parseString(saveString, "EndPastPortrait");
wasMoved = true;
inTime = TimePeriod.Past;
sendTime = TimePeriod.Past;
}
else if (period == TimePeriod.FarPast)
{
parseString(saveString, "EndOldPortrait");
sendTime = TimePeriod.FarPast;
sheet = sheetMan.getSheet("oldportrait");
}
}
private string PretendToGetDataFromHttp(TimePeriod time)
{
Thread.Sleep(5000);
//In the real implementation, use the TimePeriod in the http call
var asStrings = data.Select(committer => new[] { committer.Name, committer.Commits.ToString(), committer.ImageUri.ToString() });
return Csv.ToCsv(asStrings);
}
public Portrait(string saveString, string str)
{
this.sheet = sheetMan.getSheet("portrait");
sendTime = TimePeriod.Past;
wasMoved = false;
parseString(saveString, str);
}
public static void addEvent(CalendarService service, string email, string summary, string[] participants, TimePeriod timePeriod)
{
Event myEvent = new Event
{
Summary = summary,
//Location = "Somewhere",
Start = new EventDateTime()
{
DateTime = timePeriod.Start.Value,
TimeZone = "Europe/London"
},
End = new EventDateTime()
{
DateTime = timePeriod.End.Value,
TimeZone = "Europe/London"
},
/*Recurrence = new String[] {
"RRULE:FREQ=WEEKLY;BYDAY=MO"
},*/
//Attendees = getAttendees(participants)
};
//or Insert(myEvent, "primary")
Event recurringEvent = service.Events.Insert(myEvent, email).Execute();
}
public static string FindTemperatureFile(TimePeriod monthIndex, string gdemDirectory)
{
var files = Directory.GetFiles(gdemDirectory, GDEMTemperatureFileName(monthIndex), SearchOption.AllDirectories);
if (files.Length > 0) return files[0];
files = Directory.GetFiles(gdemDirectory, NUWCTemperatureFileName(monthIndex), SearchOption.AllDirectories);
if (files.Length > 0) return files[0];
throw new FileNotFoundException(string.Format("Could not find requested temperature file, tried {0} and {1}", GDEMTemperatureFileName(monthIndex), NUWCTemperatureFileName(monthIndex)));
}
private TimePeriodModel mapTimePeriodToTimePeriodModel(TimePeriod timePeriod)
{
TimePeriodModel tpm = new TimePeriodModel();
tpm.TimePeriodId = timePeriod.timeperiodid;
tpm.Type = timePeriod.type;
return tpm;
}
protected GameController()
{
updatableObjs = new List<Updatable>();
drawableObjs = new List<Drawable>();
collideableObjs = new List<Collideable>();
levels = new Dictionary<string, Level>();
state = GameState.Game;
timePeriod = TimePeriod.Present;
}
public IncomeExpenseGraph(List<IGraphable> list, TimePeriod group, DateTime start, DateTime finish)
{
List = list;
Group = group;
Start = start;
Finish = finish;
InitialiseChart();
}
public Level(int Width, int Height, int playerX, int playerY, Color wallpaperColor, TimePeriod startTime)
{
this.Width = Width;
this.Height = Height;
this.playerX = playerX;
this.playerY = playerY;
this.startTime = startTime;
this.wallpaperColor = wallpaperColor;
savedObjs = new List<Saveable>();
}
public Level()
{
Width = 640;
Height = 360;
playerX = 38;
playerY = 58;
savedObjs = new List<Saveable>();
startTime = TimePeriod.Present;
wallpaperColor = Color.White;
}
static void Main()
{
TimePeriod t = new TimePeriod();
// Assigning the Hours property causes the 'set' accessor to be called.
t.Hours = 24;
// Evaluating the Hours property causes the 'get' accessor to be called.
System.Console.WriteLine("Time in hours: " + t.Hours);
}
public void SetValues(ITimeSeries series_, TimePeriod initialPeriod_ = TimePeriod.None)
{
if (series_ == null) return;
m_allValues = new[] {series_};
lblTitle.Text = series_.Name;
if (initialPeriod_ != TimePeriod.None)
periodButtons1.SetPeriod(initialPeriod_,true);
else
apply();
}
private string GetDataFromHttp(TimePeriod time)
{
var login = new Login();
var url = login.Url +
ServiceConstants.MOBILE_SERVICES_RELATIVE_PATH +
ServiceConstants.TOP_COMMITTERS_SERVICE_URL +
"?days=" + (int)time +
"&apiKey=" + login.Key;
return http.DownloadString(url);
}
public static List<Record> GetRecordsFromSession(Session session, TimePeriod period, bool filterRecords = true)
{
var res = new List<Record>();
using (var mutex = Utils.TryLockFile(session.FileName))
using (var stream = new FileStream(session.FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
var encoding = DetectEncoding(stream);
if (filterRecords)
{
while (true)
{
var startPos = stream.Position;
var line = ReadLine(stream, encoding);
if (line == null)
break;
var record = ParseLine(line);
if (!IsServiceMessage(record.Name))
{
stream.Position = startPos;
break;
}
record.SessionId = session.Id;
res.Add(record);
}
SkipOutdatedRecords(stream, encoding, period.StartTime);
}
using (var reader = new StreamReader(stream, encoding, true))
{
while (true)
{
var line = reader.ReadLine();
if (line == null)
break;
var record = ParseLine(line);
if (filterRecords && record.Time > period.EndTime)
break;
if (filterRecords && record.Time < period.StartTime)
continue;
record.SessionId = session.Id;
res.Add(record);
}
}
}
return res;
}
public PeriodMetric(string name, string jsAggregator, string filter, TimePeriod period)
{
_name = name;
_filter = filter;
_period = period;
var javascriptErrorMessageContext = string.Format("{0} ({1})", _name, "Metric Aggregator");
_context = new JavascriptContext(jsAggregator, javascriptErrorMessageContext);
Initialize();
}
public void LoadTopCommiters(TimePeriod time, Action<IEnumerable<Committer>> callback)
{
switch (time)
{
case TimePeriod.PastDay:
callback(PastDayData);
break;
default:
callback(DefaultData);
break;
}
}
/* Handle whatever logic this object needs to do when changing eras. */
public override void HandleChangeEra(TimePeriod eraChangingTo)
{
base.HandleChangeEra(eraChangingTo);
/* Switch eras I'm in if player takes me through a portal. */
if (this.transform.parent) {
currentEraExistingIn = eraChangingTo;
}
/* If player is going to the future... */
if (eraChangingTo == TimePeriod.FUTURE) {
/* And I'm in the past... */
if (currentEraExistingIn == TimePeriod.PAST) {
//Debug.Log("1");
/* Deactivate Power. */
activePlatform.SetActive(false);
//activePlatform.GetComponent<BouncyPlatform>().enabled = false;
inactivePlatform.SetActive(true);
}
/* And I'm in the future... */
else {
//Debug.Log("2");
/* Currently Deactivated */
activePlatform.SetActive(true);
//activePlatform.GetComponent<BouncyPlatform>().enabled = false;
inactivePlatform.SetActive(false);
}
}
/* Else if player is going to the past.. */
else {
/* And I'm in the past... */
if (currentEraExistingIn == TimePeriod.PAST) {
//Debug.Log("3");
/* Activate Power */
activePlatform.SetActive(true);
//activePlatform.GetComponent<BouncyPlatform>().enabled = true;
inactivePlatform.SetActive(false);
}
/* And I'm in the future... */
else {
//Debug.Log("4");
/* Currently Deactivated */
activePlatform.SetActive(false);
//activePlatform.GetComponent<BouncyPlatform>().enabled = false;
inactivePlatform.SetActive(false);
}
}
}
public static Statistics GetStatistics(IList<PlayTime> playTimes, IList<Program> programs, TimePeriod timePeriod)
{
var helper = new DateTimeHelper();
List<PlayTime> times;
switch (timePeriod)
{
case TimePeriod.Day:
times = playTimes.Where(x => helper.IsToday(x.Timestamp)).ToList();
break;
case TimePeriod.Week:
times = playTimes.Where(x => helper.IsCurrentWeek(x.Timestamp)).ToList();
break;
case TimePeriod.Month:
times = playTimes.Where(x => helper.IsCurrentMonth(x.Timestamp)).ToList();
break;
case TimePeriod.Year:
times = playTimes.Where(x => helper.IsCurrentYear(x.Timestamp)).ToList();
break;
case TimePeriod.Ever:
times = playTimes.ToList();
break;
default:
throw new ArgumentOutOfRangeException(nameof(timePeriod), timePeriod, null);
}
var statistic = new Statistics
{
TimePeriod = timePeriod,
TimePlayed = TimeSpan.FromMilliseconds(times.Select(x => x.Duration.TotalMilliseconds).Sum())
};
var games = new List<GameStatistic>();
foreach (var gameId in times.Select(x => x.Program).Distinct())
{
var game = programs.FirstOrDefault(x => x.Guid == gameId);
if (game == null)
continue;
games.Add(new GameStatistic
{
Name = game.Name,
Icon = game.Icon,
Guid = game.Guid,
ChartColor = GetColor(game),
TimePlayed =
TimeSpan.FromMilliseconds(
times.Where(x => x.Program == game.Guid).Select(x => x.Duration.TotalMilliseconds).Sum())
});
}
statistic.Games = games.OrderByDescending(x => x.TimePlayed).ToList();
return statistic;
}
public static void ParseQuery(string period, string arg, out TimePeriod pd, out DateTime start, out DateTime end)
{
pd = TimePeriod.Auto;;
if (period == "last") {
int num = int.Parse (arg.Substring (0, arg.Length - 1));
if (arg.EndsWith ("d")) {
end = DateTime.Now;
start = end.AddDays (-num);
}
else if (arg.EndsWith ("w")) {
end = DateTime.Now;
start = end.AddDays (-num*7);
}
else if (arg.EndsWith ("m")) {
end = DateTime.Now;
start = end.AddMonths (-num);
}
else if (arg.EndsWith ("y")) {
end = DateTime.Now;
start = end.AddYears (-num);
}
else
throw new Exception ("Invalid period specified");
}
else if (period == "period") {
string[] range = arg.Split ('.');
start = DateTime.Parse (range[0]);
end = DateTime.Parse (range[1]);
}
else if (period == "month") {
string[] m = arg.Split ('-');
start = new DateTime (int.Parse (m[1]), int.Parse (m[0]), 1);
end = start.AddMonths (1);
}
else if (period == "year") {
start = new DateTime (int.Parse (arg), 1, 1);
end = start.AddYears (1);
}
else
throw new Exception ("Invalid period specified");
if (pd == TimePeriod.Auto) {
int nd = (int)(end - start).TotalDays;
if (nd <= 60)
pd = TimePeriod.Day;
else if (nd <= 30*6)
pd = TimePeriod.Week;
else
pd = TimePeriod.Month;
}
}
public static List<Record> GetRecordsFromPath(string dataPath, TimePeriod period)
{
var res = new List<Record>();
var sessions = GetSessionsFromPath(dataPath, period);
foreach (var session in sessions)
{
var tmp = GetRecordsFromSession(session, period);
res.AddRange(tmp);
}
return res;
}
public BudgetItem(int id, Budget b, Tag t, string name, double amount, TimePeriod p,
int timePeriodCount, DateTime scheduledDate, bool recur, int dayCount)
{
ID = id;
Budget = b;
Tag = t;
Name = name;
Amount = amount;
TimePeriod = p;
TimePeriodCount = timePeriodCount;
ScheduledDate = scheduledDate;
Recur = recur;
DayCount = dayCount;
}
public TimePeriodValue(TimePeriod period, Number value)
{
base.\u002Ector();
TimePeriodValue timePeriodValue = this;
if (period == null)
{
string str = "Null 'period' argument.";
Throwable.__\u003CsuppressFillInStackTrace\u003E();
throw new IllegalArgumentException(str);
}
else
{
this.period = period;
this.value = value;
}
}
public static void ToneEx(this GpioApi gpio, int frequency, int duration)
{
gpio.DigitalWrite(PinState.Low);
var waitTimeMicroS = (1000.0*1000.0/frequency);
var sw = Stopwatch.StartNew();
using (var tp = new TimePeriod((int)waitTimeMicroS))
{
while (sw.ElapsedMilliseconds < duration)
{
gpio.DigitalWrite(PinState.High);
TimePeriod.Sleep((int)(waitTimeMicroS/1000.0));
gpio.DigitalWrite(PinState.Low);
TimePeriod.Sleep((int)(waitTimeMicroS/1000.0));
}
}
sw.Stop();
}
public Task(string description, TimePeriod duration)
{
base.\u002Ector();
Task task = this;
if (description == null)
{
string str = "Null 'description' argument.";
Throwable.__\u003CsuppressFillInStackTrace\u003E();
throw new IllegalArgumentException(str);
}
else
{
this.description = description;
this.duration = duration;
this.percentComplete = (Double) null;
this.subtasks = (List) new ArrayList();
}
}
public TimePeriodDateTimeCheck(TimePeriod timePeriod)
{
this._timePeriod = timePeriod;
}
public void Constructor_Invalid_Hours_Minutes(long a, byte b)
{
TimePeriod t = new TimePeriod(a, b);
}
public DownloadStats GetProjectDownloadStats(int projectId, TimePeriod period, DateTime startDate, DateTime endDate)
{
return(GetDownloadStats(period, startDate, endDate, ", Release E", "R.ReleaseId = E.Id AND E.ProjectId={0}", projectId));
}
public void ToString_Valid_Format(long a, string expected)
{
TimePeriod t = new TimePeriod(a, TimeUnit.Second);
Assert.AreEqual(expected, t.ToString());
}
public void TimePeriod_Substract_ArgumentException(long a, long b)
{
TimePeriod t1 = new TimePeriod(a);
TimePeriod t2 = new TimePeriod(b);
TimePeriod result = t1 - t2;
}
/***************************************************************************
* Parses the class time periods out of the "Day/Time" table column.
*
* We know which days are selected because their li tag will have the
* "meet hidden-xs" class.
*
* Note: Would break this class into smaller, testable, pieces
* in a production situation and more defensive coding against
* html anomolies.
****************************************************************************/
private List <TimePeriod> ParseTimePeriods(HtmlNode node)
{
List <TimePeriod> result = new List <TimePeriod>();
string startTime = string.Empty;
string endTime = string.Empty;
bool isTBD = false;
bool isUnknown = false;
string time = string.Empty;
if (node.InnerHtml.ToUpper() == "TBD")
{
time = node.InnerHtml.ToUpper();
isTBD = true;
}
else
{
time = node.InnerHtml.Substring(node.InnerHtml.IndexOf("</ul>") + 5).Trim(); // In this format 8:30 AM - 9:20 AM or possibly TBD
}
TimeSpan tStart = new TimeSpan();
TimeSpan tEnd = new TimeSpan();
string notes = time;
double?totalMinutes = null;
if (time.Contains("-") && time != "-")
{
startTime = time.Substring(0, time.IndexOf("-")).Trim();
endTime = time.Substring(time.IndexOf("-") + 1).Trim();
DateTime dateTime = DateTime.ParseExact(startTime,
"h:mm tt", CultureInfo.InvariantCulture);
tStart = dateTime.TimeOfDay;
if (endTime.Contains("<"))
{
endTime = endTime.Substring(0, endTime.IndexOf("<")).Trim();
}
dateTime = DateTime.ParseExact(endTime, "h:mm tt", CultureInfo.InvariantCulture);
tEnd = dateTime.TimeOfDay;
totalMinutes = tEnd.Subtract(tStart).TotalMinutes;
}
else
{
isTBD = (time.ToUpper() == "TBD");
isUnknown = (time.ToUpper() != "TBD");
}
var days = from day in node.Descendants("li")
where day.Attributes["class"].Value == "meet hidden-xs"
select day;
if (days.Count() > 0)
{
foreach (var day in days)
{
string dayName = day.Descendants("abbr").ElementAt(0).Attributes["title"].Value.Replace(" - meet", ""); // Returns the day name in readable format
DayOfWeek dow = ((DayOfWeek)Enum.Parse(typeof(DayOfWeek), dayName, true));
TimePeriod timePeriod = new TimePeriod()
{
Day = dow,
EndTime = tEnd,
IsTBD = isTBD,
IsUnknown = isUnknown,
Notes = notes,
StartTime = tStart,
TotalMinutes = totalMinutes
};
result.Add(timePeriod);
}
}
else
{
TimePeriod timePeriod = new TimePeriod()
{
Day = null,
EndTime = null,
IsTBD = isTBD,
IsUnknown = isUnknown,
Notes = notes,
StartTime = null
};
result.Add(timePeriod);
}
return(result);
}
public void Constructor_Valid_Seconds_TimeUnit(long a, TimeUnit timeUnit, long expected)
{
TimePeriod t = new TimePeriod(a, timeUnit);
Assert.AreEqual(expected, t.Seconds);
}
public DownloadStats GetTotalDownloadStats(TimePeriod period, DateTime startDate, DateTime endDate)
{
return(GetDownloadStats(period, startDate, endDate, "", "1=1", null));
}
public bool RuleCheckTimePeriod(TimePeriod timePeriod, object[] timePeriods)
{
//Check timePeriod 时间是否重复, 连续
return(true);
}
/// <summary>
/// ** nunit
/// </summary>
/// <param name="timePeriod"></param>
public void DeleteTimePeriod(TimePeriod timePeriod)
{
this._helper.DeleteDomainObject(timePeriod, new ICheck[] { new TimePeriodDeleteCheck(new TimePeriod[] { timePeriod }, this.DataProvider) });
}
public Guid CreateCompetition(string name, TimePeriod timePeriod) => _competitionRepository.Create(name, timePeriod);
public override IEnumerable <Instructor> GetInstructors(TimePeriod timePeriod, Course course)
{
return(base.GetInstructors(timePeriod, course)
.Where(instructor => instructor.CourseInstructors.Any(ci => ci.CourceId == course.Id)));
}
private Domain.TS.TS GetNewTS(string runningCard, string partItemCode, string partRunningCard, string userCode)
{
SystemSettingFacade systemSettingFacade = new SystemSettingFacade(this.DataProvider);
ShiftModelFacade shiftModelFacade = new ShiftModelFacade(this.DataProvider);
ModelFacade modelFacade = new ModelFacade(this.DataProvider);
TSFacade tsFacade = new TSFacade(this.DataProvider);
DataCollectFacade dataCollectFacade = new DataCollectFacade(this.DataProvider);
string sourceRCard = dataCollectFacade.GetSourceCard(runningCard.Trim().ToUpper(), string.Empty);
DBDateTime dbDateTime = FormatHelper.GetNowDBDateTime(this.DataProvider);
SimulationReport lastSimulation = dataCollectFacade.GetLastSimulationReport(sourceRCard);
if (lastSimulation == null)
{
return(null);
}
Domain.TS.TS newTS = tsFacade.CreateNewTS();
newTS.TSId = Guid.NewGuid().ToString();
newTS.RunningCard = partRunningCard;
newTS.RunningCardSequence = dataCollectFacade.GetMaxRCardSequenceFromTS(partRunningCard) + 100;
newTS.TranslateCard = partRunningCard;
newTS.TranslateCardSequence = newTS.RunningCardSequence;
newTS.SourceCard = partRunningCard;
newTS.SourceCardSequence = newTS.RunningCardSequence;
newTS.CardType = CardType.CardType_Part;
newTS.ReplacedRunningCard = " ";
newTS.ItemCode = partItemCode;
Model model = (Model)modelFacade.GetModelByItemCode(partItemCode);
if (model == null)
{
Parameter parameter = (Parameter)systemSettingFacade.GetParameter("PING", "DEFAULT_MODEL_CODE");
if (parameter != null)
{
newTS.ModelCode = parameter.ParameterAlias.Trim().ToUpper();
}
}
else
{
newTS.ModelCode = model.ModelCode;
}
newTS.MOCode = lastSimulation.MOCode;
newTS.FromRouteCode = lastSimulation.RouteCode;
newTS.FromOPCode = lastSimulation.OPCode;
newTS.FromResourceCode = lastSimulation.ResourceCode;
newTS.FromSegmentCode = lastSimulation.SegmentCode;
newTS.FromStepSequenceCode = lastSimulation.StepSequenceCode;
newTS.FromShiftTypeCode = lastSimulation.ShiftTypeCode;
newTS.MOSeq = lastSimulation.MOSeq;
TimePeriod tp = (TimePeriod)shiftModelFacade.GetTimePeriod(newTS.FromShiftTypeCode, dbDateTime.DBTime);
if (tp != null)
{
newTS.FromTimePeriodCode = tp.TimePeriodCode;
newTS.FromShiftCode = tp.ShiftCode;
newTS.FromShiftDay = shiftModelFacade.GetShiftDay(tp, dbDateTime.DateTime);
}
newTS.FromUser = userCode;
newTS.FromDate = dbDateTime.DBDate;
newTS.FormTime = dbDateTime.DBTime;
newTS.MaintainUser = userCode;
newTS.MaintainDate = dbDateTime.DBDate;
newTS.MaintainTime = dbDateTime.DBTime;
newTS.TSTimes = tsFacade.GetMaxTSTimes(partRunningCard) + 1;
newTS.FromInputType = TSSource.TSSource_TS;
newTS.TSStatus = TSStatus.TSStatus_New;
newTS.TransactionStatus = TransactionStatus.TransactionStatus_NO;
return(newTS);
}
public TimePeriodDateTimeCheck(TimePeriod timePeriod, IDomainDataProvider domainDataProvider)
{
this._domainDataProvider = domainDataProvider;
this._timePeriod = timePeriod;
}
public void Constructor_Valid_Miliseconds(long a, long expected)
{
TimePeriod t = new TimePeriod(a);
Assert.AreEqual(expected, t.Miliseconds);
}
/// <summary>
/// 1.sequence must greater than exsited ones
/// 2.start datetime must greater than the last timeperiod which sequence
/// equals to the this sequence - 1
/// 3.this datetime must connected to the end date time of last one.
/// eg.last one is 11:59:59,the start of the this one must be 12:00:00
/// </summary>
/// <returns></returns>
bool BenQGuru.eMES.Web.Helper.ICheck.Check()
{
DBDateTime currentDateTime = FormatHelper.GetNowDBDateTime(this.DataProvider);
#region TimePeriod本身的时间检查
TimePeriod currTimePeriod = new TimePeriod();
currTimePeriod.TimePeriodSequence = this._timePeriod.TimePeriodSequence;
currTimePeriod.TimePeriodBeginTime = this._timePeriod.TimePeriodBeginTime;
currTimePeriod.TimePeriodEndTime = this._timePeriod.TimePeriodEndTime;
currTimePeriod.IsOverDate = this._timePeriod.IsOverDate;
this.adjustTimePeriodTime(currTimePeriod);
// 起始时间应小于结束时间
if (currTimePeriod.TimePeriodBeginTime >= currTimePeriod.TimePeriodEndTime)
{
ExceptionManager.Raise(this.GetType(), "$Error_TimePeriod_BeginTime_Greater_Than_EndTime");
return(false);
}
#endregion
#region 取出同一Shift下的所有TimePeriod，并按Sequence排序
object obj = new ShiftModelFacade(this.DataProvider).GetShift(this._timePeriod.ShiftCode);
if (obj == null)
{
ExceptionManager.Raise(this.GetType(), "$Error_TimePeriod_Shift_Not_Exist");
return(false);
}
int shiftBeginTime = ((Shift)obj).ShiftBeginTime;
int shiftEndTime = ((Shift)obj).ShiftEndTime;
if (((Shift)obj).IsOverDate == FormatHelper.TRUE_STRING)
{
if (shiftEndTime < shiftBeginTime)
{
shiftEndTime = shiftEndTime + 240000;
}
else
{
shiftBeginTime = shiftBeginTime + 240000;
shiftEndTime = shiftEndTime + 240000;
}
}
//从数据库中取出同一Shift下,当前TimePeriod之前的所有TimePeriod
object[] prevTimePeriods = this.DataProvider.CustomQuery(
typeof(TimePeriod),
new SQLCondition(string.Format("select {0} from tbltp where shiftcode= '{1}' and tpseq <= {2} and tpcode <> '{3}' order by tpseq",
DomainObjectUtility.GetDomainObjectFieldsString(typeof(TimePeriod)),
this._timePeriod.ShiftCode,
this._timePeriod.TimePeriodSequence,
this._timePeriod.TimePeriodCode)));
//从数据库中取出同一Shift下,当前TimePeriod之后的所有TimePeriod
object[] nextTimePeriods = this.DataProvider.CustomQuery(
typeof(TimePeriod),
new SQLCondition(string.Format("select {0} from tbltp where shiftcode= '{1}' and tpseq >= {2} and tpcode <> '{3}' order by tpseq",
DomainObjectUtility.GetDomainObjectFieldsString(typeof(TimePeriod)),
this._timePeriod.ShiftCode,
this._timePeriod.TimePeriodSequence,
this._timePeriod.TimePeriodCode)));
#endregion
#region 将跨日期后的TimePeriod的时间加24小时
if (prevTimePeriods != null)
{
foreach (TimePeriod timePeriod in prevTimePeriods)
{
this.adjustTimePeriodTime(timePeriod);
}
}
if (nextTimePeriods != null)
{
foreach (TimePeriod timePeriod in nextTimePeriods)
{
this.adjustTimePeriodTime(timePeriod);
}
}
#endregion
#region 时间交叉判断
// 当前TimePeriod是第一个
if (prevTimePeriods == null || prevTimePeriods.Length == 0)
{
// TimePeriod起始时间不能小于Shift的起始时间
if (currTimePeriod.TimePeriodBeginTime != shiftBeginTime)
{
ExceptionManager.Raise(this.GetType(), "$Error_First_TimePeriod_Should_Be_Shift_BeginTime");
return(false);
}
}
else
{
//DateTime temp = FormatHelper.ToDateTime(currentDateTime.DBDate, ((TimePeriod)prevTimePeriods[prevTimePeriods.Length - 1]).TimePeriodEndTime);
//int tempEndTime = FormatHelper.TOTimeInt(temp.AddSeconds(1));
int tempEndTime = FormatHelper.TimeAddSeconds(((TimePeriod)prevTimePeriods[prevTimePeriods.Length - 1]).TimePeriodEndTime, 1);
// TimePeriod的起始时间必须与上一个TimePeriod的结束时间连续
if (tempEndTime != currTimePeriod.TimePeriodBeginTime)
{
ExceptionManager.Raise(this.GetType(), "$Error_TimePeriod_Time_Should_Be_Continuous");
return(false);
}
}
if (nextTimePeriods == null || nextTimePeriods.Length == 0)
{
// TimePeriod的结束时间不能大于Shift的结束时间
if (currTimePeriod.TimePeriodEndTime > shiftEndTime)
{
ExceptionManager.Raise(this.GetType(), "$Error_TimePeriod_EndTime_Greater_Than_Shift_EndTime");
return(false);
}
}
else
{
//DateTime temp = FormatHelper.ToDateTime(currentDateTime.DBDate, currTimePeriod.TimePeriodEndTime);
//int tempEndTime = FormatHelper.TOTimeInt(temp.AddSeconds(1));
int tempEndTime = FormatHelper.TimeAddSeconds(currTimePeriod.TimePeriodEndTime, 1);
// TimePeriod的结束时间必须与下一个TimePeriod的起始时间连续
if (tempEndTime != ((TimePeriod)nextTimePeriods[0]).TimePeriodBeginTime)
{
ExceptionManager.Raise(this.GetType(), "$Error_TimePeriod_Time_Should_Be_Continuous");
return(false);
}
}
#endregion
return(true);
}
public void Constructor_Valid_Hours_Minutes_Seconds(long a, byte b, byte c, long expected)
{
TimePeriod t = new TimePeriod(a, b, c);
Assert.AreEqual(expected, t.Seconds);
}
public async Task <List <Reposit> > GetRepos(string language, TimePeriod since) =>
new JsonDeserializer().Deserialize <List <Reposit> >
(await new DownloadManager().DownloadNewsFeedDataAsync
(ApiManager.Instance.TrendingReposEndpoint(language, since)));
public void Constructor_Negative_Seconds_ArgumentOutOfRangeException(long a)
{
TimePeriod t = new TimePeriod(a);
}
public async Task <Repository <Candle> > GetCandleRepositoryAsync(string exchangeName, Instrument instrument, TimePeriod period)
{
var repo = new Repository <Candle>(_logger);
var tableName = ExchangeUtils.GetCandleDataKey(exchangeName, instrument, period);
if (_availableTables.All(x => x != tableName))
{
throw new IndexOutOfRangeException();
}
await repo.CreateTable(GetConnectionString(), ExchangeUtils.GetCandleDataKey(exchangeName, instrument, period));
return(repo);
}
public void Constructor_Invalid_String_ArgumentException(string a)
{
TimePeriod t = new TimePeriod(a);
}
public void InitTimePeriod()
{
_timePeriod = new TimePeriod(new TimeSpan(12, 0, 0));
}
public void Constructor_Invalid_Hours_Minutes_Seconds(long a, byte b, byte c)
{
TimePeriod t = new TimePeriod(a, b, c);
}
public void Visit(TimePeriod period)
{
Console.WriteLine("Visit period {0}", period);
}
public TimerScheduleSpec Compute(
MatchedEventConvertor convertor,
MatchedEventMap beginState,
ExprEvaluatorContext exprEvaluatorContext,
TimeZoneInfo timeZone,
TimeAbacus timeAbacus)
{
DateTimeEx optionalDate = null;
long? optionalRemainder = null;
if (_dateNode != null)
{
Object param = PatternExpressionUtil.Evaluate(
NAME_OBSERVER, beginState, _dateNode, convertor, exprEvaluatorContext);
if (param is string)
{
optionalDate = TimerScheduleISO8601Parser.ParseDate((string) param);
}
else if (param.IsLong() || param.IsInt())
{
long msec = param.AsLong();
optionalDate = DateTimeEx.GetInstance(timeZone);
timeAbacus.CalendarSet(msec, optionalDate);
//optionalDate = new DateTimeEx(msec.AsDateTimeOffset(timeZone), timeZone);
optionalRemainder = timeAbacus.CalendarSet(msec, optionalDate);
}
else if (param is DateTimeOffset || param is DateTime)
{
optionalDate = new DateTimeEx(param.AsDateTimeOffset(timeZone), timeZone);
}
else if (param is DateTimeEx)
{
optionalDate = (DateTimeEx) param;
}
else if (param == null)
{
throw new EPException(
"Null date-time value returned from " +
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(_dateNode));
}
else
{
throw new EPException("Unrecognized date-time value " + param.GetType());
}
}
TimePeriod optionalTimePeriod = null;
if (_periodNode != null)
{
object param = PatternExpressionUtil.EvaluateTimePeriod(
NAME_OBSERVER, beginState, _periodNode, convertor, exprEvaluatorContext);
optionalTimePeriod = (TimePeriod) param;
}
long? optionalRepeatCount = null;
if (_repetitionsNode != null)
{
object param = PatternExpressionUtil.Evaluate(
NAME_OBSERVER, beginState, _repetitionsNode, convertor, exprEvaluatorContext);
if (param != null)
{
optionalRepeatCount = param.AsLong();
}
}
if (optionalDate == null && optionalTimePeriod == null)
{
throw new EPException("Required date or time period are both null for " + NAME_OBSERVER);
}
return new TimerScheduleSpec(optionalDate, optionalRemainder, optionalRepeatCount, optionalTimePeriod);
}
public void ExtendingTimePeriod_WhenExtendingWithNegativeTime_ThenExceptionIsThrown()
{
var timePeriod = new TimePeriod(TimeSpan.FromHours(14), TimeSpan.FromHours(15));
Should.Throw <ArgumentException>(() => timePeriod.ExtendWith(TimeSpan.FromHours(-3)));
}
public static void ApiDemo(ILiquidCrystal lc)
{
ApiDemoDisplay(lc, 0, 0, " -- Api Demo --");
// Display text
ApiDemoDisplay(lc, 0, 0, "Display text on line 0 and 1");
ApiDemoDisplay(lc, 0, 0, DateTime.Now.ToString("d"), waitTime: 0);
ApiDemoDisplay(lc, 0, 1, DateTime.Now.ToString("T"), clear: false);
if (lc.NumLines > 2)
{
ApiDemoDisplay(lc, 0, 2, DateTime.Now.ToString("dddd"), clear: false);
}
if (lc.NumLines > 3)
{
ApiDemoDisplay(lc, 0, 3, CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(DateTime.Now.Month), clear: false);
}
// Turn display on / off
ApiDemoDisplay(lc, 0, 0, "About to turn the display off", waitTime: 2000);
lc.NoDisplay();
TimePeriod.Sleep(1000);
lc.Display();
ApiDemoDisplay(lc, 0, 0, "Display turned on");
// Flash Screen
ApiDemoDisplay(lc, 0, 0, "About to flash the screen ...", waitTime: 2000);
ApiDemoDisplay(lc, 0, 0, "Flashing the screen ...", waitTime: 0);
lc.Flash(10);
TimePeriod.Sleep(1000);
// Cursor Blink Demo
ApiDemoDisplay(lc, 0, 0, "Cursor blink mode on");
lc.Blink();
TimePeriod.Sleep(1000 * 4);
ApiDemoDisplay(lc, 0, 0, "Cursor blink mode off");
lc.NoBlink();
// Cursor Demo
ApiDemoDisplay(lc, 0, 0, "Display Cursor");
lc.Cursor();
TimePeriod.Sleep(1000);
for (var i = 0; i < 15; i++)
{
lc.SetCursor(i, 0); TimePeriod.Sleep(300);
}
for (var i = 15; i >= 0; i--)
{
lc.SetCursor(i, 0); TimePeriod.Sleep(300);
}
TimePeriod.Sleep(1000 * 1);
lc.NoCursor();
ApiDemoDisplay(lc, 0, 0, "Cursor off");
// Autoscroll demo
ApiDemoDisplay(lc, 0, 0, "Autoscroll Demo", waitTime: 2000);
NusbioRocks(lc);
// Progress Bar Demo
ApiDemoDisplay(lc, 0, 0, "Progress Bar Demo");
ProgressBarDemo(lc);
ApiDemoDisplay(lc, 0, 0, "-- Demo Done --");
}
public static async Task <OrderHistoryResponse> QueryOrderHistoryAsync(CurrencyType type, TimePeriod period)
{
var param = new Dictionary <string, object>()
{
{ "currency_pair", type.ToCurrencyPair() },
{ "time", period.ToPeriodString() }
};
var response = await KorbitCall.GetAsync <OrderHistoryResponse>("v1/transactions", param);
return(response);
}
/// <inheritdoc />
public Task <StationDisease> GetLast(string stationId, DataGroup dataGroup, int numberOfEvents, TimePeriod timePeriod, IEnumerable <string> diseasesFilter = null)
{
var time = $"{numberOfEvents}{timePeriod.GetDescription()}";
var requestUri = $"/data/{stationId}/{dataGroup.GetDescription()}/last/{time}";
var body = new
{
diseases = diseasesFilter
};
return(PostAsync <StationDisease>(requestUri, body));
}
public DownloadStats GetReleaseDownloadStats(int releaseId, TimePeriod period, DateTime startDate, DateTime endDate)
{
return(GetDownloadStats(period, startDate, endDate, "", "R.ReleaseId={0}", releaseId));
}
