public async Task Should_append_manual_checkpoint_with_rfid_disabled()
{
SystemClock.UseRealClock();
var tagListHandler =
WithCheckpointStorageService(storageService => new SimulatorBuilder(storageService).Build(false));
using var svc = CreateCheckpointService();
var checkpoints = new List <Checkpoint>();
var wsConnected = false;
ReaderStatus readerStatus = null;
var client = new CheckpointServiceClient(svc.ListenUri);
using var sub = client.CreateSubscription(DateTime.UtcNow.AddHours(-1));
sub.Checkpoints.Subscribe(cp => checkpoints.Add(cp));
sub.ReaderStatus.Subscribe(x => readerStatus = x);
sub.WebSocketConnected.Subscribe(s => wsConnected = s.IsConnected);
sub.Start();
await new Timing().ExpectAsync(() => wsConnected);
await client.AppendCheckpoint("555");
await new Timing()
.Logger(Logger)
.FailureDetails(() => $"checkpoints.Count = {checkpoints.Count}")
.ExpectAsync(() => checkpoints.Count == 1);
checkpoints.Should().Contain(x => x.RiderId == "555");
wsConnected.Should().BeTrue();
readerStatus.Should().NotBeNull();
readerStatus.IsConnected.Should().Be(false);
}
private void OnReaderStatus(ReaderStatus readerStatus)
{
logger.Swallow(async() =>
{
logger.Information($"Broadcasting reader status {readerStatus}");
await checkpointsHub.Clients.All
.SendCoreAsync("ReaderStatus", new[] { readerStatus });
}).Wait(0);
}
private async Task UpdateWrapperStatus(ReaderStatus status)
{
using (var context = new ReaderContext())
{
context.ReaderWrappers.Attach(RfidReaderWrapper);
RfidReaderWrapper.Status = status;
await context.SaveChangesAsync();
}
}
/// <summary>
/// Handles reader status change.
/// </summary>
public static void HandleStatusChange(ReaderStatus readerStatus)
{
switch (readerStatus)
{
case ReaderStatus.Disconnected:
Console.WriteLine("Card reader has been disconnected!");
break;
case ReaderStatus.Connected:
Console.WriteLine("Card reader has been connected!");
break;
}
}
public static ReaderStatus GetReaderStatus(this IndexReader reader)
{
ReaderStatus status = ReaderStatus.NotCurrent;
try
{
status = reader.IsCurrent() ? ReaderStatus.Current : ReaderStatus.NotCurrent;
}
catch (AlreadyClosedException)
{
status = ReaderStatus.Closed;
}
return(status);
}
/// <summary>
/// Detects the ICC type by parsing, and analyzing the ATR
/// </summary>
/// <returns>
/// none
/// </returns>
public void DetectCardType()
{
ReaderStatus status = cardReader.GetStatus();
Atr = status.GetAtr();
Debug.WriteLine("Status: " + status.State.ToString() + " ATR [" + Atr.Length + "] = " + BitConverter.ToString(Atr));
AtrInformation = AtrParser.Parse(Atr);
if (AtrInformation != null && AtrInformation.HistoricalBytes.Length > 0)
{
DetectCard();
}
}
private void SetStatus(ReaderStatus rdr)
{
if (InvokeRequired)
{
try
{
Invoke(new SetStatusDel(SetStatus), rdr);
}
catch (Exception ex)
{
}
return;
}
try
{
string iconName = "";
switch (rdr)
{
case ReaderStatus.Attached:
iconName = "switch_on";
break;
case ReaderStatus.Remove:
iconName = "switch_off";
break;
default:
break;
}
pictureBox1.Image = (Image)Properties.Resources.ResourceManager.GetObject(iconName);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private async Task RunAsync(FileInfo journalFile)
{
using (FileStream fs = journalFile.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (StreamReader sr = new StreamReader(fs)) {
_status = ReaderStatus.Active;
while (!_cancelReader.IsCancellationRequested)
{
while (!sr.EndOfStream)
{
ReadEvent(Parser.ParseJson(sr.ReadLine()));
}
while (sr.EndOfStream && !_cancelReader.IsCancellationRequested)
{
if (!_isReady)
{
_isReady = true;
OnReady?.Invoke(this, _isReady);
}
await Task.Delay(1000);
}
}
}
_status = ReaderStatus.Stopped;
}
internal void EventHandler(IntPtr EventPtr, IntPtr arg)
{
const uint topicTrigger = (uint)(V_EVENT.INCONSISTENT_TOPIC | V_EVENT.ALL_DATA_DISPOSED);
const uint writerTrigger = (uint)(V_EVENT.OFFERED_DEADLINE_MISSED | V_EVENT.LIVELINESS_LOST |
V_EVENT.OFFERED_INCOMPATIBLE_QOS | V_EVENT.PUBLICATION_MATCHED);
const uint readerTrigger = (uint)(V_EVENT.SAMPLE_REJECTED | V_EVENT.LIVELINESS_CHANGED |
V_EVENT.SAMPLE_LOST | V_EVENT.REQUESTED_DEADLINE_MISSED |
V_EVENT.REQUESTED_INCOMPATIBLE_QOS | V_EVENT.SUBSCRIPTION_MATCHED);
// The DATA_AVAILABLE and DATA_ON_READERS events are left out of the readerTrigger because
// they don't have a v_readerStatus that has to be copied.
Debug.Assert(EventPtr != IntPtr.Zero);
v_listenerEvent listenerEvent = Marshal.PtrToStructure(EventPtr, listenerEventType) as v_listenerEvent;
if (listenerEvent.kind == (uint)V_EVENT.TRIGGER)
{
// Nothing to deliver, so ignore.
return;
}
ListenerEvent ev = new ListenerEvent(listenerEvent.kind);
ev.Source = SacsSuperClass.fromUserData(listenerEvent.source) as Entity;
if (ev.Source == null)
{
// Apparently the Source Entity has already been deleted.
return;
}
if ((listenerEvent.kind & (uint)(V_EVENT.OBJECT_DESTROYED | V_EVENT.PREPARE_DELETE)) == 0)
{
ev.Target = SacsSuperClass.fromUserData(listenerEvent.userData) as Entity;
if (listenerEvent.eventData != IntPtr.Zero)
{
if ((listenerEvent.kind & topicTrigger) != 0)
{
v_topicStatus vTopicStatus = (v_topicStatus)Marshal.PtrToStructure(listenerEvent.eventData, typeof(v_topicStatus)) as v_topicStatus;
TopicStatus topicStatus = new TopicStatus();
vTopicStatusMarshaler.CopyOut(ref vTopicStatus, topicStatus);
ev.Status = topicStatus;
}
else if ((listenerEvent.kind & writerTrigger) != 0)
{
v_writerStatus vWriterStatus = (v_writerStatus)Marshal.PtrToStructure(listenerEvent.eventData, typeof(v_writerStatus)) as v_writerStatus;
WriterStatus writerStatus = new WriterStatus();
vWriterStatusMarshaler.CopyOut(ref vWriterStatus, writerStatus);
ev.Status = writerStatus;
}
else if ((listenerEvent.kind & readerTrigger) != 0)
{
v_readerStatus vReaderStatus = (v_readerStatus)Marshal.PtrToStructure(listenerEvent.eventData, typeof(v_readerStatus)) as v_readerStatus;
ReaderStatus readerStatus = new ReaderStatus();
vReaderStatusMarshaler.CopyOut(ref vReaderStatus, readerStatus);
ev.Status = readerStatus;
}
else
{
v_status vStatus = (v_status)Marshal.PtrToStructure(listenerEvent.eventData, typeof(v_status)) as v_status;
EntityStatus status = new EntityStatus();
vStatusMarshaler.CopyOut(ref vStatus, status);
ev.Status = status;
}
}
else
{
ev.Status = null;
}
}
Events.Add(ev);
}
/// <summary>
/// Loads title keys from a <see cref="TextReader"/> into an existing <see cref="KeySet"/>.
/// </summary>
/// <param name="keySet">The <see cref="KeySet"/> where the loaded keys will be placed.</param>
/// <param name="reader">A <see cref="Stream"/> containing the keys to load.</param>
/// <param name="logger">An optional logger that key-parsing errors will be written to.</param>
public static void ReadTitleKeys(KeySet keySet, Stream reader, IProgressReport logger = null)
{
if (reader == null)
{
return;
}
using var streamReader = new StreamReader(reader);
Span <char> buffer = stackalloc char[ReadBufferSize];
var ctx = new KvPairReaderContext(streamReader, buffer);
// Estimate the number of keys by assuming each line is about 69 bytes.
// Subtract 2 from that so we estimate slightly high.
keySet.ExternalKeySet.EnsureCapacity((int)reader.Length / 67);
while (true)
{
ReaderStatus status = GetKeyValuePair(ref ctx);
if (status == ReaderStatus.Error)
{
logger?.LogMessage($"Invalid line in key data: \"{ctx.CurrentKey.ToString()}\"");
Debugger.Break();
}
else if (status == ReaderStatus.ReadKey)
{
if (ctx.CurrentKey.Length != TitleKeySize * 2)
{
logger?.LogMessage($"Rights ID {ctx.CurrentKey.ToString()} has incorrect size {ctx.CurrentKey.Length}. (Expected {TitleKeySize * 2})");
continue;
}
if (ctx.CurrentValue.Length != TitleKeySize * 2)
{
logger?.LogMessage($"Title key {ctx.CurrentValue.ToString()} has incorrect size {ctx.CurrentValue.Length}. (Expected {TitleKeySize * 2})");
continue;
}
var rightsId = new RightsId();
var titleKey = new AccessKey();
if (!StringUtils.TryFromHexString(ctx.CurrentKey, SpanHelpers.AsByteSpan(ref rightsId)))
{
logger?.LogMessage($"Invalid rights ID \"{ctx.CurrentKey.ToString()}\" in title key file");
continue;
}
if (!StringUtils.TryFromHexString(ctx.CurrentValue, SpanHelpers.AsByteSpan(ref titleKey)))
{
logger?.LogMessage($"Invalid title key \"{ctx.CurrentValue.ToString()}\" in title key file");
continue;
}
keySet.ExternalKeySet.Add(rightsId, titleKey).ThrowIfFailure();
}
else if (status == ReaderStatus.Finished)
{
break;
}
}
}
/// <summary>
/// Loads non-title keys from a <see cref="TextReader"/> into an existing <see cref="KeySet"/>.
/// Missing keys will not be derived.
/// </summary>
/// <param name="keySet">The <see cref="KeySet"/> where the loaded keys will be placed.</param>
/// <param name="reader">A <see cref="Stream"/> containing the keys to load.</param>
/// <param name="keyList">A list of all the keys that will be loaded into the key set.
/// <see cref="DefaultKeySet.CreateKeyList"/> will create a list containing all loadable keys.</param>
/// <param name="logger">An optional logger that key-parsing errors will be written to.</param>
public static void ReadMainKeys(KeySet keySet, Stream reader, List <KeyInfo> keyList,
IProgressReport logger = null)
{
if (reader == null)
{
return;
}
using var streamReader = new StreamReader(reader);
Span <char> buffer = stackalloc char[ReadBufferSize];
var ctx = new KvPairReaderContext(streamReader, buffer);
while (true)
{
ReaderStatus status = GetKeyValuePair(ref ctx);
if (status == ReaderStatus.Error)
{
logger?.LogMessage($"Invalid line in key data: \"{ctx.CurrentKey.ToString()}\"");
}
else if (status == ReaderStatus.ReadKey)
{
if (!TryGetKeyInfo(out SpecificKeyInfo info, keyList, ctx.CurrentKey))
{
logger?.LogMessage($"Failed to match key {ctx.CurrentKey.ToString()}");
continue;
}
Span <byte> key;
// Get the dev key in the key set if needed.
if (info.IsDev && keySet.CurrentMode == KeySet.Mode.Prod)
{
keySet.SetMode(KeySet.Mode.Dev);
key = info.Key.Getter(keySet, info.Index);
keySet.SetMode(KeySet.Mode.Prod);
}
else
{
key = info.Key.Getter(keySet, info.Index);
}
if (ctx.CurrentValue.Length != key.Length * 2)
{
logger?.LogMessage($"Key {ctx.CurrentKey.ToString()} has incorrect size {ctx.CurrentValue.Length}. Must be {key.Length * 2} hex digits.");
continue;
}
if (!StringUtils.TryFromHexString(ctx.CurrentValue, key))
{
key.Clear();
logger?.LogMessage($"Key {ctx.CurrentKey.ToString()} has an invalid value. Must be {key.Length * 2} hex digits.");
}
}
else if (status == ReaderStatus.Finished)
{
break;
}
}
}
public async Task <IActionResult> Activate(
string type,
int?id,
string firstName,
string surName,
string patronimic,
string street,
string house,
short?apartment,
string lastRegDate,
string firstRegDate,
string note,
ReaderStatus status)
{
var readers = _context.Readers.Where(r => status.HasFlag(r.Status));
if (type != "Reader")
{
readers = readers.Where(r => r.Discriminator == type);
}
if (id.HasValue)
{
readers = readers.Where(r => r.Id == id);
}
if (!string.IsNullOrWhiteSpace(firstName))
{
readers = readers.Where(r => r.FirstName == firstName);
}
if (!string.IsNullOrWhiteSpace(surName))
{
readers = readers.Where(r => r.SurName == surName);
}
if (!string.IsNullOrWhiteSpace(patronimic))
{
readers = readers.Where(r => r.Patronimic == patronimic);
}
if (!string.IsNullOrWhiteSpace(street))
{
readers = readers.Where(r => r.Street == street);
}
if (!string.IsNullOrWhiteSpace(house))
{
readers = readers.Where(r => r.House == house);
}
if (apartment.HasValue)
{
readers = readers.Where(r => r.Apartment == apartment);
}
/* !todo:Исправить сравнение строк на сравнение дат */
if (!string.IsNullOrWhiteSpace(lastRegDate))
{
readers = readers.Where(r => r.LastRegistrationDate == lastRegDate);
}
if (!string.IsNullOrWhiteSpace(firstRegDate))
{
readers = readers.Where(r => r.FirstRegistrationDate == firstRegDate);
}
/* !todo */
if (!string.IsNullOrWhiteSpace(note))
{
readers = readers.Where(r => r.Note == note);
}
string view = "";
return(PartialView(view, await readers.ToListAsync()));
}
/// <summary>
/// Reads a message from the stream.
/// </summary>
public async Task <RawMessageResult> ReceiveMessageAsync(CancellationToken CancelToken)
{
log.Trace("()");
bool disconnect = false;
RawMessageResult res = new RawMessageResult();
try
{
while ((res.Data == null) && !disconnect)
{
Task <int> readTask = null;
int remain = 0;
log.Trace("Reader status is '{0}'.", readerStatus);
switch (readerStatus)
{
case ReaderStatus.ReadingHeader:
{
remain = ProtocolHelper.HeaderSize - messageHeaderBytesRead;
readTask = rawStream.ReadAsync(messageHeaderBuffer, messageHeaderBytesRead, remain, CancelToken);
break;
}
case ReaderStatus.ReadingBody:
{
remain = (int)messageSize - messageBytesRead;
readTask = rawStream.ReadAsync(messageBuffer, ProtocolHelper.HeaderSize + messageBytesRead, remain, CancelToken);
break;
}
default:
log.Error("Invalid client status '{0}'.", readerStatus);
break;
}
if (readTask != null)
{
log.Trace("{0} bytes remains to be read.", remain);
int readAmount = await readTask;
if (readAmount != 0)
{
log.Trace("Read completed: {0} bytes.", readAmount);
switch (readerStatus)
{
case ReaderStatus.ReadingHeader:
{
messageHeaderBytesRead += readAmount;
if (readAmount == remain)
{
if (messageHeaderBuffer[0] == 0x0D)
{
uint hdr = ProtocolHelper.GetValueLittleEndian(messageHeaderBuffer, 1);
if ((0 < hdr) && (hdr + ProtocolHelper.HeaderSize <= ProtocolHelper.MaxMessageSize))
{
messageSize = hdr;
readerStatus = ReaderStatus.ReadingBody;
messageBuffer = new byte[ProtocolHelper.HeaderSize + messageSize];
Array.Copy(messageHeaderBuffer, messageBuffer, messageHeaderBuffer.Length);
log.Trace("Reading of message header completed. Message size is {0} bytes.", messageSize);
}
else if (hdr == 0)
{
log.Warn("Zero message body size received.");
res.ProtocolViolation = true;
}
else
{
log.Warn("Client claimed message of size {0} which exceeds the maximum.", hdr + ProtocolHelper.HeaderSize);
res.ProtocolViolation = true;
}
}
else
{
log.Warn("Message has invalid format - it's first byte is 0x{0:X2}, should be 0x0D.", messageHeaderBuffer[0]);
res.ProtocolViolation = true;
}
}
break;
}
case ReaderStatus.ReadingBody:
{
messageBytesRead += readAmount;
if (readAmount == remain)
{
readerStatus = ReaderStatus.ReadingHeader;
messageBytesRead = 0;
messageHeaderBytesRead = 0;
log.Trace("Reading of message size {0} completed.", messageSize);
res.Data = messageBuffer;
}
break;
}
default:
log.Error("Invalid message reader status {0}.", readerStatus);
disconnect = true;
break;
}
if (res.ProtocolViolation)
{
disconnect = true;
}
}
else
{
log.Debug("Connection has been closed.");
disconnect = true;
}
}
else
{
disconnect = true;
}
}
}
catch (Exception e)
{
if ((e is ObjectDisposedException) || (e is IOException))
{
log.Debug("Connection to client has been terminated.");
}
else if (e is TaskCanceledException)
{
log.Debug("Timeout or shutdown detected.");
}
else
{
log.Error("Exception occurred: {0}", e.ToString());
}
}
log.Trace("(-):{0}", res);
return(res);
}
void OnReaderStatus(ReaderStatus status)
{
logger.Debug("OnReaderStatus {status}", status);
logger.Swallow(() => messageHub.Publish(status));
}
private void SetStatus(ReaderStatus rdr)
{
if(InvokeRequired)
{
try
{
Invoke(new SetStatusDel(SetStatus), rdr);
}
catch (Exception ex)
{
}
return;
}
try
{
string iconName = "";
switch (rdr)
{
case ReaderStatus.Attached:
iconName = "switch_on";
break;
case ReaderStatus.Remove:
iconName = "switch_off";
break;
default:
break;
}
pictureBox1.Image = (Image)Properties.Resources.ResourceManager.GetObject(iconName);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public ReaderStatusReportReplyEventArgs(Guid connectionId, byte address, ReaderStatus readerStatus)
{
ConnectionId = connectionId;
Address = address;
ReaderStatus = readerStatus;
}
public HomeReaderState(int number, ReaderStatus status)
{
this.ReaderNumber = number;
this.Status = status;
}
protected override void BecauseOf()
{
_readerStatus = Sut.GetStatus();
}
public async Task <IActionResult> SearchActions(
string type,
int?id,
string firstName,
string surName,
string patronimic,
string street,
string house,
short?apartment,
string note,
ReaderStatus status,
string actn)
{
List <Reader> readersList;
var readers = _context.Readers.Where(r => status.HasFlag(r.Status));
if (type != "Reader")
{
readers = readers.Where(r => r.Discriminator == type);
}
if (id.HasValue)
{
readers = readers.Where(r => r.Id == id);
}
if (!string.IsNullOrWhiteSpace(firstName))
{
readers = readers.Where(r => r.FirstName == firstName);
}
if (!string.IsNullOrWhiteSpace(surName))
{
readers = readers.Where(r => r.SurName == surName);
}
if (!string.IsNullOrWhiteSpace(patronimic))
{
readers = readers.Where(r => r.Patronimic == patronimic);
}
if (!string.IsNullOrWhiteSpace(street))
{
readers = readers.Where(r => r.Street == street);
}
if (!string.IsNullOrWhiteSpace(house))
{
readers = readers.Where(r => r.House == house);
}
if (apartment.HasValue)
{
readers = readers.Where(r => r.Apartment == apartment);
}
if (!string.IsNullOrWhiteSpace(note))
{
readers = readers.Where(r => r.Note == note);
}
ViewData["type"] = type == "Reader" ? typeof(Reader) :
type == "Student" ? typeof(Student) :
typeof(Worker);
if (actn == "activate")
{
readersList = await readers.Where(r => r.Status == ReaderStatus.Disabled).ToListAsync();
foreach (var r in readersList)
{
r.Status = ReaderStatus.Enabled;
r.LastRegistrationDate = DateTime.Today.ToString("dd.MM.yyyy");
}
_context.UpdateRange(readersList);
await _context.SaveChangesAsync();
}
else if (actn == "restore")
{
readersList = await readers.Where(r => r.Status == ReaderStatus.Removed).ToListAsync();
foreach (var r in readersList)
{
r.Drop.Note = $"Відновлений {DateTime.Today.ToString("dd.MM.yyyy")}";
r.Status = ReaderStatus.Disabled;
r.LastRegistrationDate = DateTime.Today.ToString("dd.MM.yyyy");
}
_context.UpdateRange(readersList);
await _context.SaveChangesAsync();
}
readersList = await readers.ToListAsync();
return(PartialView("_Readers", readersList));
}
