private void SetCurrentEvent(HistoryEvent historyEvent)
{
if (historyEvent is BookmarkHistoryEvent bookmarkHistoryEvent)
{
Core core = Core.Create(Core.LatestVersion, bookmarkHistoryEvent.Bookmark.State.GetBytes());
SetCore(core);
Display.GetFromBookmark(bookmarkHistoryEvent.Bookmark);
Auditors?.Invoke(CoreAction.LoadCore(historyEvent.Ticks, bookmarkHistoryEvent.Bookmark.State));
}
else if (historyEvent is RootHistoryEvent rootHistoryEvent)
{
Core core = Core.Create(Core.LatestVersion, Core.Type.CPC6128);
SetCore(core);
Display.GetFromBookmark(null);
Auditors?.Invoke(CoreAction.Reset(rootHistoryEvent.Ticks));
}
else
{
throw new Exception("Can't set current event to an event that isn't the root or doesn't have a bookmark.");
}
_history.CurrentEvent = historyEvent;
}
public override void LoadSave(object obj)
{
AuditorServiceSave save = obj as AuditorServiceSave;
if (save != null)
{
Auditors.Clear();
save.Validate();
foreach (var kvp in save.auditors)
{
Dictionary <string, Auditor> generatorAuditors = new Dictionary <string, Auditor>();
foreach (var kvp2 in kvp.Value)
{
generatorAuditors.Add(kvp2.Key, new Auditor(kvp2.Value));
}
Auditors.Add(kvp.Key, generatorAuditors);
}
SpeedMults.Clear();
SpeedMults.CopyFrom(save.speedMults);
IsLoaded = true;
}
else
{
LoadDefaults();
}
}
/// <summary>
/// Description : Get Auditors Details from database.
/// Created By : Pavan
/// Created Date : 23 August 2014
/// Modified By :
/// Modified Date:
/// </summary>
/// <returns></returns>
public static List<Auditors> GetAuditorDetailsByWOID(int WOID)
{
var data = new List<Auditors>();
System.Diagnostics.StackFrame stackFrame = new System.Diagnostics.StackFrame();
System.Reflection.MethodBase methodBase = stackFrame.GetMethod();
log.Debug("Start: " + methodBase.Name);
try
{
SqlParameter[] sqlParams = new SqlParameter[1];
sqlParams[0] = new SqlParameter("@WOID", WOID);
var reader = SqlHelper.ExecuteReader(ConnectionUtility.GetConnectionString(), CommandType.StoredProcedure, "[SpGetAuditorDetailsByWOID]", sqlParams);
var safe = new SafeDataReader(reader);
while (reader.Read())
{
var Auditors = new Auditors();
Auditors.FetchAuditors(Auditors, safe);
data.Add(Auditors);
}
return data;
}
catch (Exception ex)
{
log.Error("Error: " + ex);
return data;
}
finally
{
log.Debug("End: " + methodBase.Name);
}
}
private int GetCountOfActiveAuditors(int generatorId)
{
if (Auditors.ContainsKey(generatorId))
{
return(Auditors[generatorId].Where(kvp => !kvp.Value.IsCompleted).Count());
}
return(0);
}
public Dictionary <string, Auditor> GetAuditors(int generatorId)
{
if (!Auditors.ContainsKey(generatorId))
{
Auditors.Add(generatorId, new Dictionary <string, Auditor>());
}
return(Auditors[generatorId]);
}
public void ReceiveCoreAction(CoreAction coreAction)
{
if (_core == null)
{
Close();
return;
}
Auditors?.Invoke(coreAction);
_core.PushRequest(coreAction);
}
public override void AssignResponse(MessageEnvelope envelope)
{
try
{
var resultMessage = (ResultMessage)envelope.Message;
if (envelope.Signatures.Count < 1)
{
throw new RequestException(envelope, "Result message has no signatures.");
}
if (envelope.Signatures.Distinct().Count() != envelope.Signatures.Count)
{
throw new RequestException(envelope, "Duplicate signatures.");
}
if (!envelope.Signatures.Any(s => s.Signer.Equals(AlphaPubkey)))
{
throw new RequestException(envelope, "Result signature was not signed by Alpha.");
}
if (!envelope.Signatures.All(s => Auditors.Any(a => s.Signer.Equals(a)) || s.Signer.Equals(AlphaPubkey)))
{
throw new RequestException(envelope, "Unknown signer.");
}
if (!(resultMessage is ITransactionResultMessage || envelope.AreSignaturesValid()))//TODO: remove it after ITransactionResultMessage refactoring
{
throw new RequestException(envelope, "At least one signature is invalid.");
}
if (envelope.HasMajority(Auditors.Length))
{
if (finalizeSource.Task.IsCompleted)
{
throw new RequestException(envelope, "Finalize result message was already received.");
}
if (!acknowledgmentSource.Task.IsCompleted) //complete acknowledgment task if it's not completed yet
{
AssignResponseToSource(acknowledgmentSource, envelope);
}
AssignResponseToSource(finalizeSource, envelope);
}
else
{
if (acknowledgmentSource.Task.IsCompleted)
{
throw new RequestException(envelope, "Acknowledgment result message was already received.");
}
AssignResponseToSource(acknowledgmentSource, envelope);
}
}
catch (Exception exc)
{
acknowledgmentSource.TrySetException(exc);
finalizeSource.TrySetException(exc);
}
}
private void AddAuditor(Auditor auditor)
{
if (Auditors.ContainsKey(auditor.GeneratorId))
{
Auditors[auditor.GeneratorId].Add(auditor.Id, auditor);
}
else
{
Dictionary <string, Auditor> generatorAuditors = new Dictionary <string, Auditor> {
[auditor.Id] = auditor
};
Auditors.Add(auditor.GeneratorId, generatorAuditors);
}
auditor.StartAuditor();
GameEvents.OnAuditorAdded(auditor);
}
public Authority(string tableId, string productCode = null)
{
if (productCode.IsNullOrWhiteSpace())
{
productCode = Assessment_Type.B.GetDescription();
}
var _common = new Controllers.CommonController();
userAccount = Controllers.AccountController.CurrentUserInfo.Name;
Presenteds = _common.getAssessment(productCode, tableId, SetAssessmentType.Presented);
Auditors = _common.getAssessment(productCode, tableId, SetAssessmentType.Auditor);
if (Presenteds.Any(x => x.User_Account == userAccount))
{
AuthorityType = Authority_Type.Presented;
}
else if (Auditors.Any(x => x.User_Account == userAccount))
{
AuthorityType = Authority_Type.Auditor;
}
else
{
AuthorityType = Authority_Type.None;
}
}
/// <summary>
/// Delegate for logging core actions.
/// </summary>
/// <param name="core">The core the request was made for.</param>
/// <param name="request">The original request.</param>
/// <param name="action">The action taken.</param>
private void RequestProcessed(Core core, CoreRequest request, CoreAction action)
{
Auditors?.Invoke(action);
}
/// <summary>
/// Delegate for logging core actions.
/// </summary>
/// <param name="core">The core the request was made for.</param>
/// <param name="request">The original request.</param>
/// <param name="action">The action taken.</param>
private void RequestProcessed(Core core, CoreRequest request, CoreAction action)
{
if (core == _core)
{
if (action != null)
{
Auditors?.Invoke(action);
if (action.Type != CoreAction.Types.CreateSnapshot &&
action.Type != CoreAction.Types.DeleteSnapshot &&
action.Type != CoreAction.Types.RevertToSnapshot)
{
HistoryEvent e = _history.AddCoreAction(action);
switch (action.Type)
{
case CoreRequest.Types.LoadDisc:
Status = (action.MediaBuffer.GetBytes() != null) ? "Loaded disc" : "Ejected disc";
break;
case CoreRequest.Types.LoadTape:
Status = (action.MediaBuffer.GetBytes() != null) ? "Loaded tape" : "Ejected tape";
break;
case CoreRequest.Types.Reset:
Status = "Reset";
break;
}
}
if (action.Type == CoreAction.Types.RunUntil)
{
lock (_snapshots)
{
SnapshotInfo newSnapshot = _snapshots.LastOrDefault();
if (newSnapshot != null && action.AudioSamples != null)
{
newSnapshot.AudioBuffer.Write(action.AudioSamples);
}
}
}
else if (action.Type == CoreAction.Types.RevertToSnapshot)
{
HistoryEvent historyEvent = ((SnapshotInfo)request.UserData).HistoryEvent;
if (_history.CurrentEvent != historyEvent)
{
_history.CurrentEvent = historyEvent;
}
Display.CopyScreenAsync();
}
else if (action.Type == CoreAction.Types.CreateSnapshot)
{
lock (_snapshots)
{
// Figure out what history event should be set as current if we revert to this snapshot.
// If the current event is a RunUntil, it may not be "finalized" yet (i.e. it may still
// be updated), so go with its parent.
HistoryEvent historyEvent = _history.MostRecentClosedEvent(_history.CurrentEvent);
SnapshotInfo newSnapshot = new SnapshotInfo(action.SnapshotId, historyEvent);
_snapshots.Add(newSnapshot);
while (_snapshots.Count > _snapshotLimit)
{
SnapshotInfo snapshot = _snapshots[0];
_snapshots.RemoveAt(0);
_core.PushRequest(CoreRequest.DeleteSnapshot(snapshot.Id));
}
}
}
}
}
}
public override void LoadDefaults()
{
Auditors.Clear();
SpeedMults.Clear();
IsLoaded = true;
}
private Auditors FetchAuditors(Auditors Auditors, SafeDataReader dr)
{
Auditors.AuditorID = dr.GetInt32("AuditorID");
Auditors.AuditorName = dr.GetString("AuditorName");
return Auditors;
}
private bool ProcessNextRequest()
{
bool success = true;
CoreRequest firstRequest = FirstRequest();
bool removeFirst = true;
CoreRequest request = firstRequest;
CoreAction action = null;
if (request == null)
{
removeFirst = false;
if (IdleRequest != null)
{
request = IdleRequest();
}
if (request == null)
{
_requestQueueNonEmpty.WaitOne(20);
return(false);
}
}
UInt64 ticks = Ticks;
switch (request.Type)
{
case CoreRequest.Types.KeyPress:
lock (_lockObject)
{
if (_coreCLR.KeyPress(request.KeyCode, request.KeyDown))
{
action = CoreAction.KeyPress(ticks, request.KeyCode, request.KeyDown);
}
}
break;
case CoreRequest.Types.Reset:
lock (_lockObject)
{
_coreCLR.Reset();
}
action = CoreAction.Reset(ticks);
break;
case CoreRequest.Types.LoadDisc:
lock (_lockObject)
{
_coreCLR.LoadDisc(request.Drive, request.MediaBuffer.GetBytes());
}
action = CoreAction.LoadDisc(ticks, request.Drive, request.MediaBuffer);
break;
case CoreRequest.Types.LoadTape:
lock (_lockObject)
{
_coreCLR.LoadTape(request.MediaBuffer.GetBytes());
}
action = CoreAction.LoadTape(ticks, request.MediaBuffer);
break;
case CoreRequest.Types.RunUntil:
{
action = RunForAWhile(request.StopTicks);
success = (request.StopTicks <= Ticks);
}
break;
case CoreRequest.Types.CoreVersion:
lock (_lockObject)
{
byte[] state = GetState();
ICore newCore = Core.CreateVersionedCore(request.Version);
newCore.LoadState(state);
newCore.SetScreen(Display.Pitch, Display.Height, Display.Width);
_coreCLR.Dispose();
_coreCLR = newCore;
}
break;
case CoreRequest.Types.LoadCore:
lock (_lockObject)
{
_coreCLR.LoadState(request.CoreState.GetBytes());
}
action = CoreAction.LoadCore(ticks, request.CoreState);
break;
case CoreRequest.Types.CreateSnapshot:
lock (_lockObject)
{
action = CreateSnapshot(request.SnapshotId);
}
break;
case CoreRequest.Types.DeleteSnapshot:
lock (_lockObject)
{
action = DeleteSnapshot(request.SnapshotId);
}
break;
case CoreRequest.Types.RevertToSnapshot:
lock (_lockObject)
{
action = RevertToSnapshot(request.SnapshotId);
}
break;
default:
Diagnostics.Trace("Unknown core request type {0}. Ignoring request.", request.Type);
break;
}
if (removeFirst && success)
{
RemoveFirstRequest();
}
Auditors?.Invoke(this, request, action);
return(false);
}
public void updateAuditors(Auditors b)
{
ctx.Update(b);
}
public void PostAuditors(Auditors a)
{
ctx.Insert(a);
}
