private string CreateDeviceUrl(DeviceParameters parameters, PaginationResourceUrlType urlType)
{
switch (urlType)
{
case PaginationResourceUrlType.PreviousPage:
var previousParameters = new
{
pageIndex = parameters.PageIndex - 1,
pageSize = parameters.PageSize,
orderBy = parameters.OrderBy,
fields = parameters.Fields
};
return(urlHelper1.Link("GetPosts", previousParameters));
case PaginationResourceUrlType.NextPage:
var nextParameters = new
{
pageIndex = parameters.PageIndex + 1,
pageSize = parameters.PageSize,
orderBy = parameters.OrderBy,
fields = parameters.Fields
};
return(urlHelper1.Link("GetPosts", nextParameters));
default:
var currentParameters = new
{
pageIndex = parameters.PageIndex,
pageSize = parameters.PageSize,
orderBy = parameters.OrderBy,
fields = parameters.Fields
};
return(urlHelper1.Link("GetPosts", currentParameters));
}
}
/// <summary>
/// Adds or refreshes the devices parameters dictionary.
/// </summary>
private void CalculateDeviceParameters()
{
var key = String.Format("deviceParameters:{0}", Dispositivo.Id);
var parameters = LogicCache.Retrieve <DeviceParameters>(typeof(DeviceParameters), key);
if (parameters != null)
{
if (parameters.NeedsUpdate)
{
parameters.UpdateParameters(Dispositivo);
LogicCache.Store(typeof(DeviceParameters), key, parameters);
}
DeviceParameters = parameters;
}
else
{
parameters = new DeviceParameters(Dispositivo);
LogicCache.Store(typeof(DeviceParameters), key, parameters);
DeviceParameters = parameters;
}
}
public async Task <PageList <Device> > GetAllDevicesAsync(DeviceParameters deviceParameters)
{
//根据Device Name属性搜索
//后可添加模糊搜索
var query = myContext1.Devices.AsQueryable();
if (string.IsNullOrEmpty(deviceParameters.Name))
{
var Name = deviceParameters.Name.ToLowerInvariant();
query = query = query.Where(x => x.Name.ToLowerInvariant().Contains(Name));
}
;
query = query.OrderBy(x => x.Id);
var count = await query.CountAsync();
var data = await query
.Skip(deviceParameters.PageIndex *deviceParameters.PageSize)
.Take(deviceParameters.PageSize)
.ToListAsync();
return(new PageList <Device>(deviceParameters.PageIndex, deviceParameters.PageSize, count, data));
throw new NotImplementedException();
}
/// <summary>
/// Determines if the givenn date is a valid one. Invalid dates are those far into the past or the future.
/// </summary>
/// <param name="fecha"></param>
/// <param name="dp"></param>
/// <returns></returns>
protected static bool FechaInvalida(DateTime fecha, DeviceParameters dp)
{
var fechaFuturo = fecha >= DateTime.UtcNow.AddMinutes(dp.FuturePositionMinutes);
var fechaPasado = fecha < DateTime.UtcNow.AddDays(-dp.PositionsListExpiration);
return(fechaFuturo || fechaPasado);
}
public async Task <IActionResult> Get(DeviceParameters deviceParameters)
{
var devices = await deviceRepository1.GetAllDevicesAsync(deviceParameters);
var deviceResources = mapper1.Map <IEnumerable <Device>, IEnumerable <DeviceResource> >(devices);
var perivousPageLink = devices.HasPrevious ?
CreateDeviceUrl(deviceParameters, PaginationResourceUrlType.PreviousPage) : null;
var nextPageLink = devices.HasNext ?
CreateDeviceUrl(deviceParameters, PaginationResourceUrlType.NextPage) : null;
var meta = new
{
pageSize = devices.PageSize,
pageIndex = devices.PageIndex,
TotalItemsCount = devices.TotalItemsCount,
PageCount = devices.PageCount,
perivousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(meta, new JsonSerializerSettings
{
//将属性名从Header中改为小写
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
logger1.LogTrace("Get All Devices");
return(Ok(deviceResources));
}
public async Task <IActionResult> GetDevices([FromQuery] DeviceParameters deviceParameters)
{
var(devices, metadata) = await _deviceService.GetManyAsync(deviceParameters);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(devices));
}
private DeviceParameters ParseDevice(JsonElement element)
{
var propertydefinitions = ParseParameter(element.GetProperty("Parameters"));
var devicepropertydefinition = new DeviceParameters(element.GetProperty("Uuid").GetString(), propertydefinitions);
return(devicepropertydefinition);
}
/// <summary>
/// Updates this device's properties, returning a mutated form of this device.
/// </summary>
/// <param name="parameterOperator">The <see cref="Action{DeviceParameters}" /> to use when updating this device.</param>
public async Task ModifyAsync(Action <DeviceParameters> parameterOperator)
{
var parameters = new DeviceParameters();
parameterOperator(parameters);
await _client.RequestClient.SendAsync <Model>($"/v2/devices/{Identifier}", HttpMethod.Post, parameters)
.ConfigureAwait(false);
}
/// <summary>
/// Creates a device under the client's account.
/// </summary>
/// <param name="deviceParameters">The <see cref="DeviceParameters" /> to set up the new device with.</param>
/// <returns>
/// A <see cref="Task" /> representing the asynchronous post operation. This task will resolve with a
/// <see cref="Device" /> entity representing the created device.
/// </returns>
public async Task <Device> CreateDeviceAsync(DeviceParameters deviceParameters)
{
var deviceModel = await RequestClient.SendAsync <DeviceModel>("/v2/devices", HttpMethod.Post, deviceParameters)
.ConfigureAwait(false);
var device = new Device(deviceModel, this);
return(device);
}
public async Task <(IEnumerable <DeviceDto>, Metadata)> GetManyAsync(DeviceParameters deviceParameters)
{
var devices = await _repositoryManager.Device.GetAllDevicesAsync(CurrentUserId, deviceParameters);
if (devices == null)
{
_logger.LogError("Devices wasn't found in db!");
}
return(_mapper.Map <IEnumerable <DeviceDto> >(devices), devices?.Metadata);
}
private void RemoveDeviceParametersPreceeding(DateTimeOffset time)
{
if (DeviceParameters.IsEmpty)
{
return;
}
MulticlampParametersChangedArgs cParams;
if (DeviceParameters.TryPeek(out cParams))
{
}
}
public async Task <PagedList <Device> > GetAllDevicesAsync(Guid userId, DeviceParameters deviceParameters)
{
var result = await FindByCondition(x => x.User.Id.Equals(userId))
.FilterBy(deviceParameters)
.Search(deviceParameters.SearchTerm)
.Sort(deviceParameters.OrderBy)
.Include(x => x.Employee)
.Include(x => x.Accessories)
.Include(x => x.Components)
.Include(x => x.Consumables)
.ToListAsync();
return(PagedList <Device> .ToPagedList(result, deviceParameters.PageNumber, deviceParameters.PageSize));
}
public void SetDevice(DeviceParameters deviceParameters)
{
var user = Users[deviceParameters.UserId];
user.Devices.Clear();
var device = new Device()
{
Token = deviceParameters.Token,
User = user
};
user.Devices.Add(device);
}
private Maybe <MulticlampParametersChangedArgs> GetFor(DateTimeOffset dto)
{
// Open questions:
// (*) Should I be ordering (via OrderBy) the queue results, or is it safe to assume they're already in order?
// (*) Should I be removing any elements we don't use, and if so, should it be earlier or later ones?
IEnumerable <MulticlampParametersChangedArgs> e = DeviceParameters.Where((a) => a.TimeStamp.Ticks < dto.UtcTicks).OrderBy((a) => a.TimeStamp);
if (e.Count() > 0)
{
return(Maybe <MulticlampParametersChangedArgs> .Some(e.Last()));
}
else
{
return(Maybe <MulticlampParametersChangedArgs> .None());
}
}
public static IQueryable <Device> FilterBy(this IQueryable <Device> queryable, DeviceParameters deviceParameters)
{
var filters = deviceParameters.GetFilters();
foreach (var filter in filters)
{
queryable = filter switch
{
"Model" => queryable.Where(x => x.Model.Equals(deviceParameters.Model)),
"Category" => queryable.Where(x => x.Category.Equals(deviceParameters.Category)),
"Status" => queryable.Where(x => x.Status.Equals(deviceParameters.Status)),
"Manufacturer" => queryable.Where(x => x.Manufacturer.Equals(deviceParameters.Manufacturer)),
"OfficeAddress" => queryable.Where(x => x.OfficeAddress.Equals(deviceParameters.OfficeAddress)),
_ => queryable
};
}
return(queryable);
}
/// <summary>
/// Retrieves a scanner parameter
/// </summary>
/// <param name="parameter">one of the predefined parameters</param>
/// <returns></returns>
protected string GetDeviceParameter(DeviceParameters parameter)
{
int cbText = 256;
StringBuilder sb = new StringBuilder(cbText);
int retVal = API.CRTK_ScanGetDeviceParam(RTK, GetParamName(parameter), sb, ref cbText);
if (retVal == API.CRTK_SUCCESS)
return sb.ToString();
if (retVal != API.CRTK_ERR_NOT_IMPLEMENTED || ThrowExceptionOnError)
CheckStatus(retVal, "CRTK_ScanGetDeviceParam");
return String.Empty;
}
/// <summary>
/// Convert enumerated DeviceParameters value to SDK param name
/// </summary>
/// <param name="field">the Fields value to convert</param>
/// <returns></returns>
protected static string GetParamName(DeviceParameters parameter)
{
string param;
switch (parameter)
{
case DeviceParameters.ASK_CALIBRATE:
param = API.CRTK_PARAM_ASK_CALIBRATE;
break;
case DeviceParameters.CALIBRATED:
param = API.CRTK_PARAM_CALIBRATED;
break;
case DeviceParameters.CARD_PLACEMENT:
param = API.CRTK_PARAM_CARD_PLACEMENT;
break;
case DeviceParameters.COLOR_MODE:
param = API.CRTK_PARAM_COLOR_MODE;
break;
case DeviceParameters.FIRMWARE_VERSION:
param = API.CRTK_PARAM_FIRMWARE_VERSION;
break;
case DeviceParameters.PORT_NUMBER:
param = API.CRTK_PARAM_PORT_NUMBER;
break;
case DeviceParameters.PORT_TYPE:
param = API.CRTK_PARAM_PORT_TYPE;
break;
case DeviceParameters.SCANNER_MODEL:
param = API.CRTK_PARAM_SCANNER_MODEL;
break;
case DeviceParameters.SERIAL_NUMBER:
param = API.CRTK_PARAM_SERIAL_NUMBER;
break;
default:
param = "";
break;
}
return param;
}
