public LockDto GetLockByPatientId(string patientId)
{
var sync = (from s in _dbContext.Set <Sync>()
join u in _dbContext.Set <User>() on s.Owner equals u.UniqueID
select new SyncDto
{
OrderID = s.OrderID,
SyncType = s.SyncType,
Owner = s.Owner,
OwnerName = u.LocalName,
LoginName = u.LoginName,
OwnerIP = s.OwnerIP,
CreateTime = s.CreateTime,
ModuleID = s.ModuleID,
PatientID = s.PatientID,
AccNo = s.AccNo,
PatientName = s.PatientName,
Counter = s.Counter,
ProcedureIDs = s.ProcedureIDs,
Domain = s.Domain
}).FirstOrDefault();
LockDto lockitem = new LockDto();
if (sync != null)
{
lockitem.IsLock = true;
lockitem.Lock = sync;
return(lockitem);
}
return(lockitem);
}
private static void CalculatePartialMatches(LockDto lockDto, IReadOnlyList <string> searchTerms, IReadOnlyList <string> fullyMatchedProperties)
{
foreach (var searchTerm in searchTerms)
{
if (!fullyMatchedProperties.Contains(nameof(lockDto.Name)) &&
(lockDto.Name?.ContainsInvariant(searchTerm) ?? false))
{
lockDto.Weight += NameWeight;
}
if (!fullyMatchedProperties.Contains(nameof(lockDto.Description)) &&
(lockDto.Description?.ContainsInvariant(searchTerm) ?? false))
{
lockDto.Weight += DescriptionWeight;
}
if (!fullyMatchedProperties.Contains(nameof(lockDto.Floor)) &&
(lockDto.Floor?.ContainsInvariant(searchTerm) ?? false))
{
lockDto.Weight += FloorWeight;
}
if (!fullyMatchedProperties.Contains(nameof(lockDto.RoomNumber)) &&
(lockDto.RoomNumber?.ContainsInvariant(searchTerm) ?? false))
{
lockDto.Weight += RoomWNumberWeight;
}
if (!fullyMatchedProperties.Contains(nameof(lockDto.SerialNumber)) &&
(lockDto.SerialNumber?.ContainsInvariant(searchTerm) ?? false))
{
lockDto.Weight += SerialNumberWeight;
}
}
}
private void Initialize(LockOptions lockOptions, IGpioPinFactory gpioPinFactory, LockDbContext lockDbContext)
{
DateTime now = DateTime.Now;
async Task InitializeLock(LockConfiguration lockConfiguration)
{
LockDto lockDto = await lockDbContext.Locks.FindAsync(lockConfiguration.Id);
LockState mode = lockDto?.State ?? LockState.Locked;
bool timedOut = lockDto?.Timeout <= now;
if (timedOut)
{
mode = mode.Toggle();
}
Lock @lock = new Lock(lockConfiguration.Id, gpioPinFactory.CreatePin((BcmPin)lockConfiguration.Pin), (LockState)(-1));
if (!timedOut)
{
@lock.Timeout = lockDto?.Timeout;
}
await SetAsync(@lock, mode, "INITIALIZE");
IdToLock.Add(@lock.Id, @lock);
}
Task.WaitAll(lockOptions.LockConfigurations.Select(InitializeLock).ToArray());
UpdateTimerAsync().Wait();
}
private static void CalculateTypeWeight(LockDto lockDto, IReadOnlyList <string> searchTerms)
{
var lockTypeString = lockDto.Type.ToString("G");
if (searchTerms.Any(x => x.ContainsInvariant(lockTypeString)))
{
lockDto.Weight += TypeWeight * FullMatchMultiplier;
}
else if (searchTerms.Any(x => lockTypeString.ContainsInvariant(x)))
{
lockDto.Weight += TypeWeight;
}
}
// Extract relevant Locks
private void GetRelevantLocks()
{
// check all the Locks
foreach (var lockObj in _dataService.GetEntitiesData().locks)
{
// calculate the weight of a Lock record
lockObj.CalculateEntityWeight(_searchText);
// if weight is not 0 then add it in the result array
if (lockObj.Weight > 0)
{
var lockTemp = new LockDto();
lockTemp.Put(lockObj);
_searchResults.Add(lockTemp);
// for next search make the calculated weight zero
lockObj.Weight = 0;
}
}
}
private async Task UpdateLockDto(string id, LockState state, DateTime?timeout)
{
LockDto lockDto = LockDbContext.Locks.Find(id);
if (lockDto == null)
{
lockDto = new LockDto()
{
Id = id,
State = state,
Timeout = timeout
};
LockDbContext.Add(lockDto);
}
else
{
lockDto.State = state;
lockDto.Timeout = timeout;
LockDbContext.Update(lockDto);
}
await LockDbContext.SaveChangesAsync();
}
private static IReadOnlyList <string> CalculateFullMatch(LockDto lockDto, string searchQuery)
{
var fullyMatchedProperties = new List <string>();
if (searchQuery.ContainsInvariant(lockDto.Name))
{
lockDto.Weight += NameWeight * FullMatchMultiplier;
fullyMatchedProperties.Add(nameof(lockDto.Name));
}
if (searchQuery.ContainsInvariant(lockDto.Description))
{
lockDto.Weight += DescriptionWeight * FullMatchMultiplier;
fullyMatchedProperties.Add(nameof(lockDto.Description));
}
if (searchQuery.ContainsInvariant(lockDto.Floor))
{
lockDto.Weight += FloorWeight * FullMatchMultiplier;
fullyMatchedProperties.Add(nameof(lockDto.Floor));
}
if (searchQuery.ContainsInvariant(lockDto.RoomNumber))
{
lockDto.Weight += RoomWNumberWeight * FullMatchMultiplier;
fullyMatchedProperties.Add(nameof(lockDto.RoomNumber));
}
if (searchQuery.ContainsInvariant(lockDto.SerialNumber))
{
lockDto.Weight += SerialNumberWeight * FullMatchMultiplier;
fullyMatchedProperties.Add(nameof(lockDto.SerialNumber));
}
return(fullyMatchedProperties);
}
public LockViewModel()
{
Lock = new LockDto();
}
public void Post([FromBody] LockDto lockDto)
{
lockService.Register(lockDto.Id, lockDto.Name);
}
