public override string GetLine()
{
var builder = new StringBuilder(8 + Params.Length * 2);
builder.Append(EventType.ToString());
builder.Append(',');
builder.Append(((int)Easing).ToInvariant());
builder.Append(',');
builder.Append(StartTime.ToInvariant());
builder.Append(',');
if (!Precision.AlmostEquals(StartTime, EndTime))
{
builder.Append(EndTime.ToInvariant());
}
foreach (var param in Params)
{
builder.Append(',');
builder.Append(param.ToInvariant());
}
return(builder.ToString());
}
/// <summary>
/// Compares two charge detail records for equality.
/// </summary>
/// <param name="ChargeDetailRecord">A charge detail record to compare with.</param>
/// <returns>True if both match; False otherwise.</returns>
public Boolean Equals(ChargeDetailRecord ChargeDetailRecord)
{
if ((Object)ChargeDetailRecord == null)
{
return(false);
}
return(CDRNature.Equals(ChargeDetailRecord.CDRNature) &&
ServiceSessionId.Equals(ChargeDetailRecord.ServiceSessionId) &&
RequestedServiceId.Equals(ChargeDetailRecord.RequestedServiceId) &&
EVSEId.Equals(ChargeDetailRecord.EVSEId) &&
UserContractIdAlias.Equals(ChargeDetailRecord.UserContractIdAlias) &&
UserId.Equals(ChargeDetailRecord.UserId) &&
StartTime.Equals(ChargeDetailRecord.StartTime) &&
EndTime.Equals(ChargeDetailRecord.EndTime) &&
ExecPartnerSessionId.Equals(ChargeDetailRecord.ExecPartnerSessionId) &&
ExecPartnerOperatorId.Equals(ChargeDetailRecord.ExecPartnerOperatorId) &&
SalesPartnerSessionId.Equals(ChargeDetailRecord.SalesPartnerSessionId) &&
SalesPartnerOperatorId.Equals(ChargeDetailRecord.SalesPartnerOperatorId) &&
PartnerProductId.Equals(ChargeDetailRecord.PartnerProductId) &&
MeterReports.Equals(ChargeDetailRecord.MeterReports));
}
public string ForDisplay()
{
string result = StartTime.ToShortTimeString() + " - " + EndTime.ToShortTimeString();
TimeSpan diff = EndTime.Subtract(StartTime);
result = TimeRecordType == TimeRecordTypeEnum.FunTimePeriod ? "Fun: " : "Work: ";
result += " at " + StartTime.ToShortTimeString();
result += " for "; // + diff.
if (diff.Hours > 0)
{
result += diff.Hours + " hh";
}
if (diff.Minutes > 0)
{
result += diff.Minutes + " min";
}
if (diff.Seconds > 0)
{
result += diff.Seconds + " sec";
}
return(result);
}
private DateTime[] getOofTime(string workingHours)
{
DateTime[] OofTimes = new DateTime[2];
DateTime StartTime, EndTime;
//add new variant that can handle OnCallMode - don't convert old code to this at this time due to the risk
if (!OOFData.Instance.IsOnCallModeOn && !OOFData.Instance.useNewOOFMath)
{
CalculateOOFTimes(OOFData.Instance.WorkingHours.Split('|'), out StartTime, out EndTime);
}
else
{
CalculateOOFTimes2(out StartTime, out EndTime, OOFData.Instance.IsOnCallModeOn);
}
OofTimes[0] = StartTime;
OofTimes[1] = EndTime;
OOFSponder.Logger.Info("Calculated OOF StartTime = " + StartTime.ToString());
OOFSponder.Logger.Info("Calculated OOF EndTime = " + EndTime.ToString());
return(OofTimes);
}
public TimerViewModel()
{
//StartTimerCommand = new Command(OnStartTimeExecute);
StartTime = TimeSpan.FromSeconds(1);
// StartTime = TimeSpan.FromSeconds(60);
Duration = StartTime.ToString();
OnStartTimeExecute();
ProcessAnswerCommand = new Command((optionId) =>
{
var questions = QuestionData.GetQuestions.questions;
var question = questions.Find(x => x.Id == Id);
var option = question.Options.Find(x => x.Id == (int)optionId);
option.IsSelected = !option.IsSelected;
});
FlagQuestionCommand = new Command(() =>
{
var questions = QuestionData.GetQuestions.questions;
var question = questions.Find(x => x.Id == Id);
question.IsFlagged = !question.IsFlagged;
});
}
public Game BriefGame()
{
Game game = new Game();
int left = (int)(StartTime.AddSeconds((double)TimeLimit) - DateTime.Now).TotalSeconds;
if (GameState == "completed" || left <= 0)
{
TimeLeft = 0;
GameState = "completed";
}
else
{
TimeLeft = left;
}
game.Board = null;
game.TimeLeft = TimeLeft;
game.GameState = GameState;
game.Player1 = Player1.BriefUser();
game.Player2 = Player2.BriefUser();
return(game);
}
/// <summary>
/// Return the HashCode of this object.
/// </summary>
/// <returns>The HashCode of this object.</returns>
public override Int32 GetHashCode()
{
unchecked
{
return(Location.GetHashCode() * 11 ^
(StartTime.HasValue
? StartTime.GetHashCode() * 7
: 0) ^
(StopTime.HasValue
? StopTime.GetHashCode() * 5
: 0) ^
(Retries.HasValue
? Retries.GetHashCode() * 3
: 0) ^
(RetryInterval.HasValue
? RetryInterval.GetHashCode()
: 0));
}
}
public override int GetHashCode()
{
int hash = 1;
if (Result != 0)
{
hash ^= Result.GetHashCode();
}
if (StartTime != 0L)
{
hash ^= StartTime.GetHashCode();
}
hash ^= badges_.GetHashCode();
if (gymBadges_ != null)
{
hash ^= GymBadges.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public ReqRpt014TableViewModel(ReqRpt014PostModel postModel)
{
StartTime = DateTime.ParseExact(postModel.StartDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture);
if (postModel.StartCategory == "day")
{
StartTime = StartTime.Add(StartOfDay);
}
else
{
StartTime = StartTime.Add(EndOfDay);
}
EndTime = DateTime.ParseExact(postModel.EndDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture);
if (postModel.EndCategory == "day")
{
EndTime = EndTime.Add(StartOfDay);
}
else
{
EndTime = EndTime.Add(EndOfDay);
}
ProductID = postModel.ProductID;
Initialize();
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Date != null)
{
hashCode = hashCode * 59 + Date.GetHashCode();
}
if (StartTime != null)
{
hashCode = hashCode * 59 + StartTime.GetHashCode();
}
if (EndTime != null)
{
hashCode = hashCode * 59 + EndTime.GetHashCode();
}
hashCode = hashCode * 59 + BreakDuration.GetHashCode();
return(hashCode);
}
}
/// <summary>
/// Build video url
/// </summary>
/// <returns></returns>
protected string BuildVideoUrl()
{
if (TransBegin.Equals(DBNull.Value) || TransEnd.Equals(DBNull.Value))
{
return(string.Empty);
}
string urlFormat = "{0}?t1={1:yyyyMMdd-HHmmss}&t2={2:yyyyMMdd-HHmmss}&speed={3}";
string NVRSeverIP = CommonDictionary4Monitor.DataSource.cf_station.FirstOrDefault().VIDEO_SERVER_IP.ToString();
int NVRServerPort = CommonDictionary4Monitor.DataSource.cf_station.FirstOrDefault().VIDEO_SERVER_PORT.ConvertToInt();
// Quân edit 01-10-2015
// comment đoạn này vì cú pháp rtsp để xem video playback hiện tại là rtsp://nvrip:nvrport/ipcamera?t1=&t2=&speed=1
//string urlVideo = string.Format("rtsp://{0}{1}/{2}{3}", DBOption.NVRServerID, DBOption.NVRServerPort > 0 ? (":"+ DBOption.NVRServerPort) : string.Empty, IPCamera, PortCamera > 0 ? (":"+ PortCamera) : string.Empty);
string urlVideo = string.Format("rtsp://{0}{1}/{2}{3}", NVRSeverIP, NVRServerPort > 0 ? (":" + NVRServerPort) : string.Empty, IPCamera, string.Empty);
// Teardown video hiện tại, streaming video mới với thời gian bằng thời gian bắt đầu và thời gian đã phát
//return "rtsp://192.168.6.150:8888:8554/192.168.7.61?t1=20140727-103700&t2=20140727-104700&speed=1";
//rtsp://192.168.6.150:8888:8554/192.168.7.61?t1=20140727-101700&t2=20140727-104700&speed=1
DateTime EndTime = TransEnd;
Console.WriteLine(string.Format(urlFormat, urlVideo, StartTime.AddSeconds(-15), EndTime.AddSeconds(15), Speed));
return(string.Format(urlFormat, urlVideo, StartTime.AddSeconds(-15), EndTime.AddSeconds(15), Speed));
//return string.Format(urlFormat, urlVideo, StartTime, TransactionRow.TRANS_END, Speed); // tạm thời cho lùi lại 30s cho tất cả các transaction
}
public int DurationInHours()
{
string[] hrsmins = StartTime.Split(':');
int startTimehrs = 0;
int startTimemins = 0;
Int32.TryParse(hrsmins[0], out startTimehrs);
Int32.TryParse(hrsmins[1], out startTimemins);
string[] endTimehrsmins = EndTime.Split(':');
int endTimehrs = 0;
int endTimemins = 0;
Int32.TryParse(endTimehrsmins[0], out endTimehrs);
Int32.TryParse(endTimehrsmins[1], out endTimemins);
DateTime start = new DateTime(2018, 1, 1, startTimehrs, startTimemins, 0);
DateTime end = new DateTime(2018, 1, 1, endTimehrs, endTimemins, 0);
TimeSpan duration = end - start;
return(duration.Hours);
}
} // End of Update
/// <summary>
/// A time period has lapsed, trigger a save/queue of the current value of data.
/// </summary>
/// <param name="fillForward">Data stream is a fillforward type</param>
/// <param name="isQCData">The data stream is a QCManaged stream</param>
public void TriggerArchive(bool fillForward, bool isQCData)
{
lock (_lock)
{
try
{
Console.Write(".");
//When there's nothing to do:
if (_data == null && !fillForward)
{
Log.Debug("StreamStore.TriggerArchive(): No data to store, and not fill forward: " + Symbol);
}
if (_data != null && _data.Time < StartTime)
{
//Create clone and reset original
Log.Debug("StreamStore.TriggerArchive(): Enqueued new data: S:" + _data.Symbol + " V:" + _data.Value);
_previousData = _data.Clone();
_queue.Enqueue(_data.Clone());
_data = null;
}
else if (fillForward && _data == null && _previousData != null || (!isQCData && _data == null && _previousData != null))
{
//There was no other data in this timer period, and this is a fillforward subscription:
Log.Debug("StreamStore.TriggerArchive(): Fillforward, Previous Enqueued: S:" + _previousData.Symbol + " V:" + _previousData.Value);
var cloneForward = _previousData.Clone();
cloneForward.Time = StartTime.Subtract(_config.Increment);
_queue.Enqueue(cloneForward);
}
}
catch (Exception err)
{
Log.Error("StreamStore.TriggerAchive(fillforward): Failed to archive: " + err.Message);
}
}
}
public StringBuilder ToString(ReportFormat reportFormat)
{
StringBuilder sb = new StringBuilder();
switch (reportFormat)
{
case ReportFormat.Head:
sb.AppendLine("======================================================================================================");
sb.AppendLine("Proccess URI: " + StartUri.AbsoluteUri);
sb.AppendLine("Start At : " + StartTime.ToString("yyyy-MM-dd hh:mm:ss", CultureInfo.CurrentUICulture));
sb.AppendLine("------------------------------------------------------------------------------------------------------");
return(sb);
case ReportFormat.Body:
int index = 0;
int count = PageStates.Count;
foreach (WebPageState state in PageStates)
{
sb.AppendLine(String.Format(CultureInfo.CurrentUICulture, "{0,4}/{1,-4}: {2}", ++index, count, state));
}
return(sb);
case ReportFormat.Footer:
sb.AppendLine();
sb.AppendLine("------------------------------------------------------------------------------------------------------");
sb.AppendLine("Pages Processed: " + PagesProcessed);
sb.AppendLine("Pages Pending : " + PagesPending);
sb.AppendLine("End At : " + EndTime.ToString("yyyy-MM-dd hh:mm:ss", CultureInfo.CurrentUICulture));
sb.AppendLine(String.Format(CultureInfo.CurrentUICulture, "Elasped Time : {0}h {1}m {2}s {3}ms", ElapsedTime.Hours,
ElapsedTime.Minutes, ElapsedTime.Seconds, ElapsedTime.Milliseconds));
sb.AppendLine("======================================================================================================");
return(sb);
default:
return(sb);
}
}
/// <summary>
/// <para>Cancels the timer. Returns true if it hasn't and won't fire; false if it has or will, or has already been cancelled.</para>
/// </summary>
internal override bool Cancel()
{
if (_timerState == TimerState.Ready)
{
lock (_queueLock)
{
if (_timerState == TimerState.Ready)
{
// Remove it from the list. This keeps the list from getting too big when there are a lot of rapid creations
// and cancellations. This is done before setting it to Cancelled to try to prevent the Fire() loop from
// seeing it, or if it does, of having to take a lock to synchronize with the state of the list.
Next.Prev = Prev;
Prev.Next = Next;
// Just cleanup. Doesn't need to be in the lock but is easier to have here.
Next = null;
Prev = null;
_callback = null;
_context = null;
_timerState = TimerState.Cancelled;
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("TimerThreadTimer#" + StartTime.ToString() + "::Cancel() (success)");
}
return(true);
}
}
}
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("TimerThreadTimer#" + StartTime.ToString() + "::Cancel() (failure)");
}
return(false);
}
ChatTimer(TimeSpan duration, [CanBeNull] string message, [NotNull] string startedBy)
{
if (startedBy == null)
{
throw new ArgumentNullException("startedBy");
}
StartedBy = startedBy;
Message = message;
StartTime = DateTime.UtcNow;
EndTime = StartTime.Add(duration);
Duration = duration;
int oneSecondRepeats = (int)duration.TotalSeconds + 1;
if (duration > Hour)
{
announceIntervalIndex = AnnounceIntervals.Length - 1;
lastHourAnnounced = (int)duration.TotalHours;
}
else
{
for (int i = 0; i < AnnounceIntervals.Length; i++)
{
if (duration <= AnnounceIntervals[i])
{
announceIntervalIndex = i - 1;
break;
}
}
}
task = Scheduler.NewTask(TimerCallback, this);
Id = Interlocked.Increment(ref timerCounter);
AddTimerToList(this);
IsRunning = true;
task.RunRepeating(TimeSpan.Zero,
TimeSpan.FromSeconds(1),
oneSecondRepeats);
}
protected override void ProcessRecord()
{
var queries = new Dictionary <string, string>();
if (Types != null && Types.Any())
{
List <string> types = Types.ToList().ConvertAll <string>(x => x.ToString().First().ToString().ToLower() + x.ToString().Substring(1));
queries.Add("taskTypes", string.Join(",", types));
}
if (Ids != null && Ids.Any())
{
queries.Add("taskIds", string.Join(",", Ids));
}
if (StartTime.HasValue)
{
queries.Add("startTimeUsecs", StartTime.ToString());
}
if (EndTime.HasValue)
{
queries.Add("endTimeUsecs", EndTime.ToString());
}
var queryString = string.Empty;
if (queries.Any())
{
queryString = "?" + string.Join("&", queries.Select(q => $"{q.Key}={q.Value}"));
}
var url = $"/public/restore/tasks{queryString}";
var result = Session.ApiClient.Get <IEnumerable <RestoreTask> >(url);
WriteObject(result, true);
}
public void SetProgram(IProgram program)
{
IProgramRecordingStatus recordingStatus = program as IProgramRecordingStatus;
if (recordingStatus != null)
{
IsScheduled = recordingStatus.RecordingStatus != RecordingStatus.None;
}
try
{
_settingProgram = true;
if (program != null)
{
ProgramId = program.ProgramId;
Title = program.Title;
Description = program.Description;
StartTime = program.StartTime;
EndTime = program.EndTime;
Genre = program.Genre;
}
else
{
ProgramId = 0;
Title = string.Empty;
Description = string.Empty;
StartTime = FormatHelper.GetDay(DateTime.Now);
EndTime = StartTime.AddDays(1);
Genre = string.Empty;
}
UpdateDuration();
}
finally
{
_settingProgram = false;
}
}
private EtlPerformanceStats CreatePerformanceStats(bool completed)
{
return(new EtlPerformanceStats(Scope.Duration)
{
Id = Id,
Started = StartTime,
Completed = completed ? StartTime.Add(Scope.Duration) : (DateTime?)null,
Details = Scope.ToPerformanceOperation("ETL"),
LastLoadedEtag = Stats.LastLoadedEtag,
NumberOfLoadedItems = Stats.NumberOfLoadedItems,
LastExtractedEtags = Stats.LastExtractedEtags,
LastTransformedEtags = Stats.LastTransformedEtags,
LastFilteredOutEtags = Stats.LastFilteredOutEtags,
NumberOfExtractedItems = Stats.NumberOfExtractedItems,
NumberOfTransformedItems = Stats.NumberOfTransformedItems,
NumberOfTransformedTombstones = Stats.NumberOfTransformedTombstones,
TransformationErrorCount = Scope.TransformationErrorCount,
SuccessfullyLoaded = Stats.SuccessfullyLoaded,
BatchTransformationCompleteReason = Stats.BatchTransformationCompleteReason,
BatchStopReason = Stats.BatchStopReason,
CurrentlyAllocated = new Size(Stats.CurrentlyAllocated.GetValue(SizeUnit.Bytes)),
BatchSize = new Size(Stats.BatchSize.GetValue(SizeUnit.Bytes)),
});
}
/// <summary>
/// Returns the VCalendar item
/// </summary>
/// <returns>a string output of the VCalendar item</returns>
public virtual string GetVCalendar()
{
StringBuilder FileOutput = new StringBuilder();
FileOutput.AppendLine("BEGIN:VCALENDAR");
FileOutput.AppendLine("VERSION:1.0");
FileOutput.AppendLine("BEGIN:VEVENT");
StartTime = StartTime.AddHours(-TimeZoneAdjustment);
EndTime = EndTime.AddHours(-TimeZoneAdjustment);
string Start = StartTime.ToString("yyyyMMdd") + "T" + StartTime.ToString("HHmmss");
string End = EndTime.ToString("yyyyMMdd") + "T" + EndTime.ToString("HHmmss");
FileOutput.Append("DTStart:").AppendLine(Start);
FileOutput.Append("DTEnd:").AppendLine(End);
FileOutput.Append("Location;ENCODING=QUOTED-PRINTABLE:").AppendLine(Location);
FileOutput.Append("SUMMARY;ENCODING=QUOTED-PRINTABLE:").AppendLine(Subject);
FileOutput.Append("DESCRIPTION;ENCODING=QUOTED-PRINTABLE:").AppendLine(Description);
FileOutput.Append("UID:").Append(Start).Append(End).AppendLine(Subject);
FileOutput.AppendLine("PRIORITY:3");
FileOutput.AppendLine("End:VEVENT");
FileOutput.AppendLine("End:VCALENDAR");
return(FileOutput.ToString());
}
/// <summary>
/// Looks for overlapping times in frequencies
/// </summary>
public bool IsOverlapping(Frequency other)
{
TimeOfDay startTime = new TimeOfDay()
{
Hours = int.Parse(StartTime.Split(':')[0]),
Minutes = int.Parse(StartTime.Split(':')[1]),
Seconds = int.Parse(StartTime.Split(':')[2])
};
TimeOfDay endTime = new TimeOfDay()
{
Hours = int.Parse(EndTime.Split(':')[0]),
Minutes = int.Parse(EndTime.Split(':')[1]),
Seconds = int.Parse(EndTime.Split(':')[2])
};
TimeOfDay otherStartTime = new TimeOfDay()
{
Hours = int.Parse(other.StartTime.Split(':')[0]),
Minutes = int.Parse(other.StartTime.Split(':')[1]),
Seconds = int.Parse(other.StartTime.Split(':')[2])
};
TimeOfDay otherEndTime = new TimeOfDay()
{
Hours = int.Parse(other.EndTime.Split(':')[0]),
Minutes = int.Parse(other.EndTime.Split(':')[1]),
Seconds = int.Parse(other.EndTime.Split(':')[2])
};
if (startTime.TotalSeconds < otherStartTime.TotalSeconds)
{
return(endTime.TotalSeconds > otherStartTime.TotalSeconds);
}
else
{
return(otherEndTime.TotalSeconds > startTime.TotalSeconds);
}
}
/// <summary>
/// Returns true if StoreOpenHour instances are equal
/// </summary>
/// <param name="input">Instance of StoreOpenHour to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(StoreOpenHour input)
{
if (input == null)
{
return(false);
}
return
((
DayIndex == input.DayIndex ||
DayIndex != null &&
DayIndex.Equals(input.DayIndex)
) &&
(
StartTime == input.StartTime ||
StartTime != null &&
StartTime.Equals(input.StartTime)
) &&
(
EndTime == input.EndTime ||
EndTime != null &&
EndTime.Equals(input.EndTime)
));
}
public override int GetHashCode()
{
int hashcode = 157;
unchecked {
if (__isset.startMessageId)
{
hashcode = (hashcode * 397) + StartMessageId.GetHashCode();
}
if (__isset.endMessageId)
{
hashcode = (hashcode * 397) + EndMessageId.GetHashCode();
}
if (__isset.startTime)
{
hashcode = (hashcode * 397) + StartTime.GetHashCode();
}
if (__isset.endTime)
{
hashcode = (hashcode * 397) + EndTime.GetHashCode();
}
}
return(hashcode);
}
/// <summary>
/// Compares to.
/// </summary>
/// <param name="p">The p.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">p</exception>
/// <exception cref="System.Exception">An error occurred while comparing Period values.</exception>
public int CompareTo(IPeriod p)
{
if (p == null)
{
throw new ArgumentNullException("p");
}
if (Equals(p))
{
return(0);
}
if (StartTime.LessThan(p.StartTime))
{
return(-1);
}
if (StartTime.GreaterThanOrEqual(p.StartTime))
{
return(1);
}
throw new Exception("An error occurred while comparing Period values.");
}
void gntDetail_MouseMove(object sender, MouseEventArgs e)
{
int i = gntDetail.MouseOverDBIndex;
//update the label if the mouse is over a valid bar
if (i > -1 && i < _DS.Tables[0].Rows.Count)
{
DataRow dr = _DS.Tables[0].Rows[i];
if (dr.RowState == DataRowState.Deleted)
{
lblJobDetail.Text = "";
return;
}
TimeSpan ts = new TimeSpan(0, Convert.ToInt32(dr["Run Time"]), 0);
DateTime StartTime, EndTime;
string tmp = lblJobDetail.Text;
EndTime = (DateTime)dr["End Time"];
StartTime = EndTime - ts;
tmp = i.ToString() + " Product: " + dr["Product Number"].ToString() + ", " + dr["Product Name"].ToString() +
" Start: " + StartTime.ToString() + " Finish: " + dr["End Time"].ToString() +
" Run Time: " + dr["Run Time"].ToString();
if (Convert.ToInt32(dr["Setup Time"]) > 0)
{
tmp = tmp + " Setup Time " + dr["Setup Time"].ToString();
}
if (!dr.IsNull("Time Due"))
{
tmp = tmp + " Time Due: " + dr["Time Due"].ToString();
}
lblJobDetail.Text = tmp;
}
else
{
lblJobDetail.Text = "";
}
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
int hashCode = 41;
if (Date != null)
{
hashCode = hashCode * 59 + Date.GetHashCode();
}
if (Closed != null)
{
hashCode = hashCode * 59 + Closed.GetHashCode();
}
if (StartTime != null)
{
hashCode = hashCode * 59 + StartTime.GetHashCode();
}
if (EndTime != null)
{
hashCode = hashCode * 59 + EndTime.GetHashCode();
}
return(hashCode);
}
}
private void CUPONESBtn_Click(object sender, EventArgs e)
{
TIQUETBtn.Image = Properties.Resources.icons8_purchase_order_50px;
if (USERLbl.Text == "UserName")
{
Paper = "Voucher";
AcceptLOGIN.Visible = true;
LOGIN.Visible = true;
LOGINTXT.Visible = true;
LOGO.Visible = true;
LOGINTXT.Focus();
}
else
{
MiddlePanel.Controls.Clear();
Voucher VC = new Voucher();
MiddlePanel.Controls.Add(VC);
VC.Dock = DockStyle.Fill;
StartTime.Interval = 1;
StartTime.Start();
VC.Show();
CUPONESBtn.Image = Properties.Resources.icons8_voucher_50px_1;
}
}
public void MergeFrom(TimeWindow other)
{
if (other == null)
{
return;
}
if (other.startTime_ != null)
{
if (startTime_ == null)
{
startTime_ = new global::Google.Protobuf.WellKnownTypes.Timestamp();
}
StartTime.MergeFrom(other.StartTime);
}
if (other.endTime_ != null)
{
if (endTime_ == null)
{
endTime_ = new global::Google.Protobuf.WellKnownTypes.Timestamp();
}
EndTime.MergeFrom(other.EndTime);
}
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
public int CompareTo(RegisteredAction other)
{
if (ReferenceEquals(this, other))
{
return(0);
}
if (ReferenceEquals(null, other))
{
return(1);
}
var idComparison = string.Compare(Id, other.Id, StringComparison.Ordinal);
if (idComparison != 0)
{
return(idComparison);
}
var startTimeComparison = StartTime.CompareTo(other.StartTime);
if (startTimeComparison != 0)
{
return(startTimeComparison);
}
var durationComparison = Duration.CompareTo(other.Duration);
if (durationComparison != 0)
{
return(durationComparison);
}
var projectMemberIdComparison = string.Compare(ProjectMemberId, other.ProjectMemberId, StringComparison.Ordinal);
if (projectMemberIdComparison != 0)
{
return(projectMemberIdComparison);
}
return(string.Compare(ProjectActionId, other.ProjectActionId, StringComparison.Ordinal));
}
public int CompareTo(CommonEvent other)
{
if (other == null)
{
return(1);
}
if (StartTime > other.StartTime)
{
return(1);
}
if (StartTime.Equals(other.StartTime))
{
return(0);
}
if (StartTime < other.StartTime)
{
return(-1);
}
throw new ArgumentOutOfRangeException(nameof(other));
}
public bool NextItem(MediaItem mediaItem, StartTime startTime)
{
string mimeType;
string title;
if (!mediaItem.GetPlayData(out mimeType, out title) || mimeType != LiveTvMediaItem.MIME_TYPE_TV)
{
ServiceRegistration.Get<ILogger>().Debug("SlimTvHandler: Cannot reuse current player for new mimetype {0}", mimeType);
return false;
}
Stop();
// Set new resource locator for existing player, this avoids interim close of player slot
IResourceLocator resourceLocator = mediaItem.GetResourceLocator();
ServiceRegistration.Get<ILogger>().Debug("SlimTvHandler: Changing file/stream for player to {0}", resourceLocator.NativeResourcePath);
SetMediaItem(resourceLocator, mimeType);
return true;
}
public bool Play(MediaItem mediaItem, StartTime startTime)
{
IPlayer player = null;
try
{
IReusablePlayer rp;
lock (SyncObj)
{
CheckActive();
player = _player;
rp = _player as IReusablePlayer;
}
if (rp != null)
{
if (rp.NextItem(mediaItem, startTime))
{
OnPlayerStarted(rp);
return true;
}
}
ReleasePlayer_NoLock();
ICollection<Exception> exceptions;
player = _playerManager.BuildPlayer_NoLock(mediaItem, out exceptions);
if (player == null)
HandleUnableToPlay(mediaItem, exceptions);
else
{
IMediaPlaybackControl mpc;
IDisposable disposePlayer = null;
lock (SyncObj)
{
if (_player != null)
disposePlayer = _player as IDisposable; // If we got a race condition between the locks
_player = player;
mpc = player as IMediaPlaybackControl;
}
RegisterPlayerEvents_NoLock(player);
CheckAudio_NoLock();
if (disposePlayer != null)
disposePlayer.Dispose();
OnPlayerStarted(player);
if (mpc != null)
mpc.Resume();
return true;
}
return false;
}
catch (Exception e)
{
ServiceRegistration.Get<ILogger>().Warn("PlayerSlotController: Slot {0} - error playing '{1}'", e, _slotIndex, mediaItem);
IDisposable disposePlayer = player as IDisposable;
if (disposePlayer != null)
disposePlayer.Dispose();
player = null;
return false;
}
finally
{
if (player != null)
SetSlotState(PlayerSlotState.Playing);
}
}
protected bool DoPlay_NoLock(MediaItem mediaItem, StartTime startTime)
{
if (mediaItem == null)
return false;
IServerConnectionManager scm = ServiceRegistration.Get<IServerConnectionManager>();
IContentDirectory cd = scm.ContentDirectory;
if (cd != null)
cd.NotifyPlayback(mediaItem.MediaItemId);
_currentMediaItem = mediaItem;
IPlayerSlotController psc = _slotController;
if (psc == null)
return false;
return psc.IsActive && psc.Play(mediaItem, startTime);
}
public bool NextItem(MediaItem mediaItem, StartTime startTime)
{
string mimeType;
string title;
if (!mediaItem.GetPlayData(out mimeType, out title))
return false;
IResourceLocator locator = mediaItem.GetResourceLocator();
if (locator == null)
return false;
IInputSource inputSource = _inputSourceFactory.CreateInputSource(locator, mimeType);
if (inputSource == null)
return false;
lock (_syncObj)
_externalState = PlayerState.Active;
_controller.MoveToNextItem_Async(inputSource, startTime);
_mediaItemTitle = title; // This is a bit too early because we're not switching to the next item at once, but doesn't matter
return true;
}
/// <summary>
/// Enqueues the given input source for playback and starts playback if nessecary.
/// </summary>
/// <param name="inputSource">The input source for the media item to play.</param>
/// <param name="startTime">Time to start the new media item.</param>
public void MoveToNextItem_Async(IInputSource inputSource, StartTime startTime)
{
Log.Info("Preparing for playback: '{0}'", inputSource);
_playbackProcessor.SetNextInputSource(inputSource);
if (startTime == StartTime.AtOnce)
_playbackProcessor.ScheduleMoveToNextInputSource();
else
_playbackProcessor.ScheduleNextInputSourceAvailable();
}
public bool Play(MediaItem mediaItem, StartTime startTime)
{
IPlayer player = null;
try
{
IReusablePlayer rp;
lock (SyncObj)
{
CheckActive();
player = _player;
rp = _player as IReusablePlayer;
}
if (rp != null)
{
if (rp.NextItem(mediaItem, startTime))
{
OnPlayerStarted(rp);
return true;
}
}
ReleasePlayer_NoLock();
ICollection<Exception> exceptions;
player = _playerManager.BuildPlayer_NoLock(mediaItem, out exceptions);
if (player == null)
{
HandleUnableToPlay(mediaItem, exceptions);
OnPlaybackError(null);
}
else
{
IMediaPlaybackControl mpc;
IDisposable disposePlayer = null;
lock (SyncObj)
{
if (_player != null)
disposePlayer = _player as IDisposable; // If we got a race condition between the locks
_player = player;
mpc = player as IMediaPlaybackControl;
}
RegisterPlayerEvents_NoLock(player);
CheckAudio_NoLock();
if (disposePlayer != null)
disposePlayer.Dispose();
OnPlayerStarted(player);
// Handling of resume info.
object resumeObject;
if (ContextVariables.TryGetValue(PlayerContext.KEY_RESUME_STATE, out resumeObject))
{
IResumeState resumeState = (IResumeState) resumeObject;
IResumablePlayer resumablePlayer = player as IResumablePlayer;
if (resumablePlayer != null)
resumablePlayer.SetResumeState(resumeState);
}
if (mpc != null)
mpc.Resume();
return true;
}
return false;
}
catch (Exception e)
{
ServiceRegistration.Get<ILogger>().Warn("PlayerSlotController: Error playing '{0}'", e, mediaItem);
IDisposable disposePlayer = player as IDisposable;
if (disposePlayer != null)
disposePlayer.Dispose();
return false;
}
}
public bool NextItem(MediaItem mediaItem, StartTime startTime)
{
string mimeType;
string title;
if (!mediaItem.GetPlayData(out mimeType, out title))
return false;
IResourceLocator locator = mediaItem.GetResourceLocator();
if (locator == null)
return false;
if (!CanPlay(locator, mimeType))
return false;
RightAngledRotation rotation = RightAngledRotation.Zero;
bool flipX = false;
bool flipY = false;
MediaItemAspect imageAspect = mediaItem[ImageAspect.ASPECT_ID];
if (imageAspect != null)
{
int orientationInfo = (int) imageAspect[ImageAspect.ATTR_ORIENTATION];
ImageRotation imageRotation;
ImageAspect.OrientationToRotation(orientationInfo, out imageRotation);
rotation = PlayerRotationTranslator.TranslateToRightAngledRotation(imageRotation);
ImageAspect.OrientationToFlip(orientationInfo, out flipX, out flipY);
}
SetMediaItemData(locator, title, rotation, flipX, flipY);
return true;
}
public bool NextItem(MediaItem mediaItem, StartTime startTime)
{
string resourcePath;
string title;
if (!MediaItemAspect.TryGetAttribute(mediaItem.Aspects, ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, out resourcePath)
|| !MediaItemAspect.TryGetAttribute(mediaItem.Aspects, MediaAspect.ATTR_TITLE, out title))
return false;
ResourcePath rp = ResourcePath.Deserialize(resourcePath);
if (rp.LastPathSegment.ProviderId != RawUrlResourceProvider.RAW_URL_RESOURCE_PROVIDER_ID)
return false;
_itemTitle = title;
string url = rp.LastPathSegment.Path;
UpdateTexture(url);
return true;
}
protected bool DoPlay_NoLock(MediaItem mediaItem, StartTime startTime)
{
if (mediaItem == null)
return false;
NotifyPlayback(mediaItem);
_currentMediaItem = mediaItem;
IPlayerSlotController psc = _slotController;
if (psc == null)
return false;
return !psc.IsClosed && psc.Play(mediaItem, startTime);
}
public bool NextItem(MediaItem mediaItem, StartTime startTime)
{
string mimeType;
string title;
if (!mediaItem.GetPlayData(out mimeType, out title))
return false;
if (mimeType != "video/livetv")
return false;
IResourceLocator locator = mediaItem.GetResourceLocator();
if (locator == null)
return false;
Shutdown();
SetMediaItem(locator, title);
return true;
}
