/// <summary>
/// Gets a list of devices that match the filter criteria.
/// </summary>
/// <param name="deviceFilter">The device filter.</param>
/// <returns>An array of DeviceInformation objects.</returns>
public static DeviceInformation[] GetDevices(DeviceFilter deviceFilter)
{
List <DeviceInformation> result = new List <DeviceInformation>();
Guid emptyGuid = Guid.Empty;
int filter;
if (deviceFilter == DeviceFilter.AllDevices || deviceFilter == DeviceFilter.AllPciDevices)
{
filter = (int)DIGCF.DIGCF_ALLCLASSES;
}
else
{
filter = (int)DIGCF.DIGCF_ALLCLASSES | (int)DIGCF.DIGCF_PRESENT;
}
IntPtr deviceInfoSet =
Win32SetupApi.SetupDiGetClassDevs(
ref emptyGuid,
IntPtr.Zero,
IntPtr.Zero,
filter);
SP_DEVINFO_DATA deviceInfoData =
new SP_DEVINFO_DATA();
deviceInfoData.Size = Marshal.SizeOf(typeof(SP_DEVINFO_DATA));
for (int i = 0; Win32SetupApi.SetupDiEnumDeviceInfo(deviceInfoSet, i, ref deviceInfoData); i++)
{
DeviceInformation deviceInformation =
GetDeviceInformation(deviceInfoSet, deviceInfoData);
switch (deviceFilter)
{
case DeviceFilter.PresentPciDevices:
case DeviceFilter.AllPciDevices:
if (!deviceInformation.LocationInfo
.ToLowerInvariant().Contains("pci"))
{
continue; // relates to the for-loop
}
else
{
break; // relates to the switch
}
case DeviceFilter.AllDevices:
default:
break;
}
result.Add(deviceInformation);
}
Win32SetupApi.SetupDiDestroyDeviceInfoList(deviceInfoSet);
return(result.ToArray());
}
public void Add(DeviceList deviceList, DeviceFilter filter)
{
Throw.If.Null(deviceList, "deviceList").Null(filter, "filter");
var oldDevices = new Device[0];
Action updateDeviceList = () =>
{
var newDevices = deviceList.GetAllDevices(filter).ToArray();
lock (_refCounts)
{
foreach (var newDevice in newDevices)
{
IncrementRefCount(newDevice);
}
foreach (var oldDevice in oldDevices)
{
DecrementRefCount(oldDevice);
}
}
oldDevices = newDevices;
RaiseChangedIfDirty();
};
_areDriversBeingInstalled.Add(() => deviceList.AreDriversBeingInstalled);
deviceList.Changed += (sender, e) => updateDeviceList();
updateDeviceList();
}
public async Task <bool> AnyDevicesWithSerialNumber(string serialNumber)
{
var service = ServicesManager.SelfService;
var Filter = new DeviceFilter();
Filter.SerialNumberFilter = serialNumber;
try
{
GetDevicesResponse deviceResponse = await service.GetDevices(Token, Filter);
if (deviceResponse == null || deviceResponse.Error != ErrorCode.OK)
{
Notify(deviceResponse);
return(true);
}
else if (deviceResponse.Devices != null && deviceResponse.Devices.Any())
{
return(true);
}
}
catch (ServiceException ex)
{
//TODO: HIGH Add logging
Notify(ex.Message);
}
return(false);
}
public ICollection <DeviceSyncDto> GetDevices(IEnumerable <DeviceSyncDto> devices)
{
var filter = new DeviceFilter
{
Ids = devices.Select(s => s.Id)
};
return(ServiceHandler.Get(filter).ToList());
}
public List <Device> GetAll(DeviceFilter filter = null)
{
using (var context = new DeviceHiveContext())
{
return(context.Devices
.Include(e => e.Network)
.Include(e => e.DeviceClass.Equipment)
.Filter(filter).ToList());
}
}
public List <Device> GetByNetwork(int networkId, DeviceFilter filter = null)
{
using (var context = new DeviceHiveContext())
{
return(context.Devices
.Include(e => e.Network)
.Include(e => e.DeviceClass.Equipment)
.Where(e => e.Network.ID == networkId)
.Filter(filter).ToList());
}
}
public List <Device> GetByUser(int userId, DeviceFilter filter = null)
{
using (var context = new DeviceHiveContext())
{
return(context.Devices
.Include(e => e.Network)
.Include(e => e.DeviceClass.Equipment)
.Where(e => context.UserNetworks.Any(n => n.UserID == userId && n.NetworkID == e.NetworkID))
.Filter(filter).ToList());
}
}
// полчить все газоанализаторы по фильтру
public async Task <List <Device> > GetAllDevicesFiltered(DeviceFilter filter)
{
var fb = Builders <Device> .Filter;
FilterDefinition <Device> f =
fb.Eq("Name", filter.ByName) |
fb.Eq("Manufacturer", filter.ByManufacturer) |
fb.Eq("ScopeOfApplication", filter.ByScopeOfApplication) |
fb.Eq("Type", filter.ByType);
if (filter.BySubstance != null)
{
f |= fb.All("Substance", filter.BySubstance);
}
return(await DeviceCollection.Find(f).ToListAsync());
}
public Device Get(string id, User user = null)
{
IFilter <Device> filter = new DeviceFilter();
if (user != null)
{
filter = new IdentityDeviceFilter(filter, user);
}
Device device = deviceRepository.GetById(id, filter);
if (device == null)
{
throw new NotFoundException(typeof(Device));
}
return(device);
}
public ActionResult <GetDevicesResponse> GetDevices(DeviceFilter filter)
{
var devices = _deviceService.Get(filter);
var overall = _deviceService.BaseDeviceCount();
int pages = overall / filter.PageSize;
if ((overall % filter.PageSize) != 0)
{
pages++;
}
return(new GetDevicesResponse()
{
Count = filter.PageSize,
Devices = devices,
From = filter.PageSize * filter.Page,
Overall = overall,
Pages = pages
});
}
public static string ToQueryParams(this DeviceFilter filter)
{
string queryParams = string.Empty;
if (filter.Users?.Any() ?? false)
{
foreach (var userId in filter.Users)
{
queryParams = QueryParamsHelper.AddParams(queryParams, $"users={userId}");
}
}
if (!string.IsNullOrWhiteSpace(filter.OperativeSystem))
{
queryParams = QueryParamsHelper.AddParams(queryParams, $"operativeSystem={filter.OperativeSystem}");
}
if (!string.IsNullOrWhiteSpace(filter.Name))
{
queryParams = QueryParamsHelper.AddParams(queryParams, $"name={filter.Name}");
}
return(queryParams);
}
public PaginatedItems <Device> GetAll(DeviceFilter filter, int rowsPerPage, int pageNumber)
{
return(deviceRepository.GetAllPaginated(filter, rowsPerPage, pageNumber));
}
public async Task <IActionResult> Get([FromQuery] DeviceFilter filter, [FromQuery] int rowsPerPage = 0, [FromQuery] int pageNumber = 1)
{
var devices = deviceService.GetAll(filter, rowsPerPage, pageNumber);
return(Ok(Mapper.Map <PaginatedItemsDto <DeviceOverviewDto> >(devices)));
}
public ICollection <DeviceSyncDto> GetDevices()
{
var filter = new DeviceFilter();
return(ServiceHandler.Get(filter).ToList());
}
public List <Device> GetAll(DeviceFilter filter = null)
{
return(_mongo.Devices.AsQueryable().Filter(filter).ToList());
}
public SetDeviceFilterOption(Expression <Func <T, bool> > prepicate, IQueryable <T> devices, DeviceFilter <T> filter)
: base(prepicate, devices, filter)
{
}
public Task <OperationResult <IList <Device> > > GetAllAsync(DeviceFilter filter) => _apiClient.GetAsync <OperationResult <IList <Device> > >(URL + filter.ToQueryParams());
public List <Device> GetByUser(int userId, DeviceFilter filter = null)
{
var networkIds = _mongo.UserNetworks.AsQueryable().Where(e => e.UserID == userId).Select(e => (int?)e.NetworkID).ToArray();
return(_mongo.Devices.AsQueryable().Where(e => networkIds.Contains(e.NetworkID)).Filter(filter).ToList());
}
public List <Device> GetByNetwork(int networkId, DeviceFilter filter = null)
{
return(_mongo.Devices.AsQueryable().Where(e => e.NetworkID == networkId).Filter(filter).ToList());
}
// получить страницу газоанализаторов с учётом фильтра
public async Task <List <Device> > GetPageOfDevicesFiltered(int pageNumber, int pageSize, DeviceFilter filter)
{
var fb = Builders <Device> .Filter;
FilterDefinition <Device> f =
fb.Eq("Name", filter.ByName) |
fb.Eq("Manufacturer", filter.ByManufacturer) |
fb.Eq("ScopeOfApplication", filter.ByScopeOfApplication) |
fb.Eq("Type", filter.ByType);
if (filter.BySubstance != null)
{
f |= fb.All("Substance", filter.BySubstance);
}
return(await DeviceCollection.Find(f).Skip((pageNumber - 1) * pageSize).Limit(pageSize).ToListAsync());
}
public async Task <GetDevicesResponse> GetDevices(string token, DeviceFilter filter)
{
var devices = await RequestHandler.ProcessPostRequest <GetDevicesResponse, DeviceFilter>(POST_GETDEVICES, filter, token);
return(devices);
}
public DeviceViewModel()
{
Filter = new DeviceFilter();
}
public static IQueryable <Device> Filter(this IQueryable <Device> query, DeviceFilter filter)
{
if (filter == null)
{
return(query);
}
if (filter.Name != null)
{
query = query.Where(e => e.Name == filter.Name);
}
if (filter.NamePattern != null)
{
query = query.Where(e => e.Name.Contains(filter.NamePattern));
}
if (filter.Status != null)
{
query = query.Where(e => e.Status == filter.Status);
}
if (filter.NetworkID != null)
{
query = query.Where(e => e.NetworkID == filter.NetworkID.Value);
}
if (filter.NetworkName != null)
{
query = query.Where(e => e.Network.Name == filter.NetworkName);
}
if (filter.DeviceClassID != null)
{
query = query.Where(e => e.DeviceClassID == filter.DeviceClassID.Value);
}
if (filter.DeviceClassName != null)
{
query = query.Where(e => e.DeviceClass.Name == filter.DeviceClassName);
}
if (filter.DeviceClassVersion != null)
{
query = query.Where(e => e.DeviceClass.Version == filter.DeviceClassVersion);
}
if (filter.SortField != DeviceSortField.None)
{
switch (filter.SortField)
{
case DeviceSortField.ID:
query = query.OrderBy(e => e.ID, filter.SortOrder);
break;
case DeviceSortField.Name:
query = query.OrderBy(e => e.Name, filter.SortOrder);
break;
case DeviceSortField.Status:
query = query.OrderBy(e => e.Status, filter.SortOrder)
.ThenBy(e => e.Name, filter.SortOrder);
break;
case DeviceSortField.Network:
query = query.OrderBy(e => e.Network.Name, filter.SortOrder)
.ThenBy(e => e.Name, filter.SortOrder);
break;
case DeviceSortField.DeviceClass:
query = query.OrderBy(e => e.DeviceClass.Name, filter.SortOrder)
.ThenBy(e => e.DeviceClass.Version, filter.SortOrder)
.ThenBy(e => e.Name, filter.SortOrder);
break;
}
}
if (filter.Skip != null)
{
query = query.Skip(filter.Skip.Value);
}
if (filter.Take != null)
{
query = query.Take(filter.Take.Value);
}
return(query);
}
public IActionResult Get([FromQuery] DeviceFilter filter)
{
IEnumerable <Device> devices = deviceService.Get(filter);
return(Ok(mapper.Map <IEnumerable <string> >(devices)));
}
public IEnumerable <Device> GetDevices(DeviceTypes types, DeviceFilter filter)
{
Throw.If.Null(filter, "filter");
return(GetDevices(types).Where(device => filter(device)));
}
/// <summary>
/// Gets a list of connected devices, filtered by some criteria.
/// </summary>
/// <param name="filter">The filter criteria.</param>
/// <returns>The filtered device list.</returns>
public IEnumerable <Device> GetAllDevices(DeviceFilter filter)
{
Throw.If.Null(filter, "filter");
return(GetAllDevices().Where(device => filter(device)));
}
