public async Task <ActionResult <Timescale> > PostTimescale(Timescale timescale)
{
_context.Timescales.Add(timescale);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetTimescale), new { id = timescale.Id }, timescale));
}
public static Expression <Func <GamePlayer, bool> > GetTimescaleWhereClause(Timescale timescale)
{
Expression <Func <GamePlayer, bool> > timescaleClause;
var dayOfWeek = (int)DateTime.Today.DayOfWeek;
if (dayOfWeek == 0)
{
dayOfWeek = 7;
} // make Sunday = 7 instead of 0
var thisMonday = DateTime.Today.AddDays(-dayOfWeek + (int)DayOfWeek.Monday);
switch (timescale)
{
case Timescale.Last30Days: // TODO [TH] Figure out why this is necessary
timescaleClause = g => DateTime.Now.Month == (g.Game.Date.AddDays(1)).Month && DateTime.Now.Year == g.Game.Date.Year;
break;
case Timescale.Last7Days:
timescaleClause = g => thisMonday <= g.Game.Date;
break;
default:
timescaleClause = g => true;
break;
}
return(timescaleClause);
}
public async Task <IActionResult> PutTimescale([FromRoute] Guid id, [FromBody] Timescale timescale)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != timescale.Id)
{
return(BadRequest());
}
timescale.UpdatedDate = DateTime.Now;
_context.Entry(timescale).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TimescaleExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Read(ReadContext c)
{
// time scale
var epoch = c.Reader.ReadInt64();
var ticksPerDay = c.Reader.ReadInt64();
c.Description.Timescale = Timescale.FromEpoch(epoch, ticksPerDay);
// time fields
var timeFieldsCount = c.Reader.ReadInt32();
var offsets = new List <int>();
timeFieldsCount.Times(() =>
offsets.Add(c.Reader.ReadInt32()));
c.Description.TimeFieldOffsets = offsets.AsReadOnly();
// adorn item description with time aspects, if available
var id = c.Description.ItemDescription;
if (id != null)
{
bool isFirstTimeField = true;
foreach (var offset in offsets)
{
var f = id.FindFieldByOffset(offset);
if (f == null)
{
throw new FileFormatException("Time format section contains an entry for a field at offset {0} but no such field was found in the item description.");
}
f.IsTime = true;
f.IsEventTime = isFirstTimeField;
isFirstTimeField = false;
}
}
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id,Name,Description,Owners,OldestWorkDate,Days,Basis")] Timescale timescale)
{
if (id != timescale.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
timescale.UpdatedDate = DateTime.Now;
_context.Update(timescale);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TimescaleExists(timescale.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(timescale));
}
public void TimeSectionValuesRoundTrip()
{
var ms = new MemoryStream();
var fio = new FileIO(ms);
var fw = new FormattedWriter(fio);
var wc = new WriteContext(fw);
wc.Description = new TeaFileDescription();
wc.Description.ItemDescription = ItemDescription.FromAnalysis <Event <C> >();
Time.Scale = Timescale.FromEpoch(33, 77);
wc.Description.Timescale = Time.Scale;
ISectionFormatter f = new TimeSectionFormatter();
f.Write(wc);
ms.Position = 0;
var fr = new FormattedReader(fio);
var rc = new ReadContext(fr);
rc.Description.Should().Not.Be.Null();
rc.Description.ItemDescription = wc.Description.ItemDescription;
f.Read(rc);
rc.Description.Timescale.Value.Epoch.Should().Be(33);
rc.Description.Timescale.Value.TicksPerDay.Should().Be(77);
Executing.This(() => f.Read(rc)).Should().Throw <EndOfStreamException>();
}
public ValueDumpWriter(SimulationScope dump, Stream stream)
{
timescale = new Timescale(1, TimeUnit.fs);
Date = DateTime.Now.ToString();
version = System.Reflection.Assembly.GetExecutingAssembly().FullName;
this.stream = stream;
this.dump = dump;
}
public ValueDumpWriter(SimulationScope dump, String FileName)
{
timescale = new Timescale(1, TimeUnit.fs);
Date = DateTime.Now.ToString();
version = System.Reflection.Assembly.GetExecutingAssembly().FullName;
stream = new FileStream(FileName, System.IO.FileMode.Create, FileAccess.Write, FileShare.None, 2 << 24, FileOptions.None);
this.dump = dump;
}
public ValueDumpWriter(SimulationScope dump, String FileName, Timescale Timescale, string Date, string Version)
{
this.version = Version;
this.timescale = Timescale;
this.date = Date;
this.stream = new FileStream(FileName, System.IO.FileMode.Create, FileAccess.Write, FileShare.None, 2 << 24, FileOptions.None);
this.dump = dump;
}
private void Init()
{
timescale = new Timescale(1, TimeUnit.fs);
variables = new List <VCD_Variable>();
CurrentVCDScope = new Stack <VCDScope>();
CurrentScope = dump;
CurrentTime = 0;
}
public ValueDumpWriter(SimulationScope dump, System.IO.Stream stream, Timescale Timescale, string Date, string Version)
{
this.version = Version;
this.timescale = Timescale;
this.date = Date;
this.stream = stream;
this.dump = dump;
}
public WaveformCore(WaveformUserControl waveformUserControl)
{
this.waveformUserControl = waveformUserControl;
dump = new SimulationScope("Root", null);
timescale = new Timescale(1, TimeUnit.fs);
currentDump = new ObservableCollection <My_Variable>();
entity = new Entity();
bookMarks = new ObservableCollection <BookMark>();
timeMeasureList = new ObservableCollection <TimeMeasureData>();
}
/// <summary>
/// The $timescale section specifies what timescale was used for the simulation.
/// </summary>
/// <param name="Words"></param>
private void OnTimescale(string[] Words)
{
StringBuilder builder = new StringBuilder();
for (int i = 1; i < Words.Length - 1; i++)
{
builder.AppendFormat("{0} ", Words[i]);
}
timescale = Timescale.Parse(builder.ToString());
}
public async Task <IActionResult> PutTimescale(int id, Timescale timescale)
{
if (id != timescale.Id)
{
return(BadRequest());
}
_context.Entry(timescale).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <IActionResult> Create([Bind("Id,Name,Description,Owners,OldestWorkDate,Days,Basis")] Timescale timescale)
{
if (ModelState.IsValid)
{
timescale.Id = Guid.NewGuid();
timescale.UpdatedDate = DateTime.Now;
_context.Add(timescale);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(timescale));
}
public async Task <IActionResult> PostTimescale([FromBody] Timescale timescale)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
timescale.UpdatedDate = DateTime.Now;
_context.Timescales.Add(timescale);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTimescale", new { id = timescale.Id }, timescale));
}
protected override void Execute(CodeActivityContext context)
{
var chID = Channel__ID.Get(context);
var readKey = Read_API_Key.Get(context) == null ? "" : "api_key=" + Read_API_Key.Get(context);
var chosenFormat = Format.ToString();
var chosenField = (FieldNumber.GetHashCode() + 1).ToString();
var results = Results.Get(context) == 0 ? "" : "&results=" + Results.Get(context).ToString();
var days = Days.Get(context) == 0 ? "" : "&days=" + Days.Get(context).ToString();
var minutes = Minutes.Get(context) == 0 ? "" : "&minutes=" + Minutes.Get(context).ToString();
var start = Start.Get(context) == null ? "" : "&start=" + Start.Get(context);
var end = End.Get(context) == null ? "" : "&end=" + End.Get(context);
var timezone = Timezone.Get(context) == null ? "" : "&timezone=" + Timezone.Get(context);
var offset = Offset.Get(context) == 0 ? "" : "&offset=" + Offset.Get(context).ToString();
var status = Status.Get(context) == true ? "&status=true" : "";
var metadata = Metadata.Get(context) == true ? "&metadata=true" : "";
var location = Location.Get(context) == true ? "&location=true" : "";
var min = Min.Get(context) == 0 ? "" : "&min=" + Min.Get(context).ToString();
var max = Max.Get(context) == 0 ? "" : "&max=" + Max.Get(context).ToString();
var round = Round.Get(context) == 0 ? "" : "&round=" + Round.Get(context).ToString();
var timescale = Timescale.Get(context) == null ? "" : "×cale=" + Timescale.Get(context);
var sum = Sum.Get(context) == null ? "" : "&sum=" + Sum.Get(context);
var average = Average.Get(context) == null ? "" : "&average=" + Average.Get(context);
var median = Median.Get(context) == null ? "" : "&median=" + Median.Get(context);
var callback = Callback.Get(context) == null ? "" : "&callback=" + Callback.Get(context);
string URL = "https://api.thingspeak.com/channels/" + chID + "/fields/" + chosenField + "." + chosenFormat + "?";
URL = URL + readKey + results + days + minutes + start + end + timezone + offset + status + metadata + location
+ min + max + round + timescale + sum + average + median + callback;
WebRequest wrGETURL = WebRequest.Create(URL);
Stream objStream = wrGETURL.GetResponse().GetResponseStream();
StreamReader objReader = new StreamReader(objStream);
string sLine = "";
string httpResponse = "";
while (sLine != null)
{
sLine = objReader.ReadLine();
if (sLine != null)
{
httpResponse = httpResponse + sLine + "\n";
}
}
objStream.Close();
//objReader.Close();
Response.Set(context, httpResponse);
}
/// <summary>
/// Загрузка VCD файла
/// </summary>
/// <param name="FileName"></param>
public void LoadVCDFile(Stream stream, string confPath)
{
VCDReader vcd = new VCDReader(stream);
dump.Clear();
Schematix.Core.UserControls.ProgressWindow.Window.RunProcess(vcd);
dump = vcd.Dump;
timescale = vcd.Timescale;
summaryInfo = vcd.SummaryInfo;
LoadConfiguration(confPath);
}
public static string TimescaleString(Timescale t)
{
switch (t)
{
case Timescale.Seconds:
return("second(s)");
case Timescale.Minutes:
return("minute(s)");
case Timescale.Hours:
return("hour(s)");
}
return(string.Empty);
}
/// <summary>
/// Загрузка VCD файла
/// </summary>
/// <param name="FileName"></param>
public void LoadVCDFile(string FileName)
{
VCDReader vcd = new VCDReader(FileName);
dump.Clear();
Schematix.Core.UserControls.ProgressWindow.Window.RunProcess(vcd);
dump = vcd.Dump;
timescale = vcd.Timescale;
summaryInfo = vcd.SummaryInfo;
string confPath = System.IO.Path.ChangeExtension(FileName, "conf");
LoadConfiguration(confPath);
}
/// <summary>
/// Returns very large time unit representing the time.
/// </summary>
/// <param name="seconds"></param>
/// <param name="scale"></param>
/// <returns></returns>
public static double Simplify(TimeSpan time, out Timescale scale)
{
Debug.Assert(time.TotalSeconds >= 0);
if (time.TotalHours > 2d)
{
scale = Timescale.Hours;
return(time.TotalHours);
}
else if (time.TotalMinutes > 2d)
{
scale = Timescale.Minutes;
return(time.TotalMinutes);
}
else
{
scale = Timescale.Seconds;
return(time.TotalSeconds);
}
}
public static double SimpleTime(double seconds, out Timescale scale)
{
Debug.Assert(seconds >= 0);
double time = seconds;
if (time > 7200.0)
{
time /= 3600.0;
scale = Timescale.Hours;
}
else if (time > 120.0)
{
time /= 60.0;
scale = Timescale.Minutes;
}
else
{
scale = Timescale.Seconds;
}
return(time);
}
public async Task <ReportDataResult> GetDataByReportId(int reportId, DateTime startTime, DateTime endTime, Timescale scale = Timescale.day)
{
var absolutePath = $"{ServiceDataHost}/{GetDataByReportIdQuery}?SubscriptionKey={subscriptionKey}";
var postData = new { reportId = reportId.ToString(), startTime = startTime.ToLongDateString(), endTime = endTime.ToLongDateString(), scale = scale };
//nameValues.Add("reportId", );
//nameValues.Add("startTime", startTime.ToLongTimeString());
//nameValues.Add("endTime", endTime.ToLongTimeString());
try
{
var reportDataResult = await SendRequestAsync <object, ReportDataResult>(HttpMethod.Post, absolutePath, postData);
return(reportDataResult);
}
catch (Exception ex)
{
logger.Error("PostCountersByDevice", ex);
}
return(default(ReportDataResult));
}
public VCDWriter(SimulationScope dump, String FileName, Timescale Timescale, string Date, string Version)
: base(dump, FileName, Timescale, Date, Version)
{
writer = new StreamWriter(stream);
variables = new List <VCD_Variable>();
}
public bool Equals(Timescale scale)
{
return this.Epoch == scale.Epoch &&
this.TicksPerDay == scale.TicksPerDay;
}
public static string TimescaleString(Timescale t, bool plural = true)
=> t switch
{
