public async Task <ICollection <Database.Entities.Device> > GetDevices(DeviceParams deviceParams = null)
{
var deviceQuery = _context.Devices
.Include(x => x.Component)
.Include(x => x.Kind)
.Include(x => x.Category)
.Include(x => x.Address)
.AsQueryable();
if (deviceParams is null)
{
return(await deviceQuery.ToListAsync());
}
if (deviceParams.KindId.HasValueGreaterThan(0))
{
deviceQuery = deviceQuery.Where(x => x.KindId == deviceParams.KindId);
}
if (deviceParams.CategoryId.HasValueGreaterThan(0))
{
deviceQuery = deviceQuery.Where(x => x.CategoryId == deviceParams.CategoryId);
}
return(await deviceQuery.OrderBy(x => x.Name).ToListAsync());
}
public async Task <IActionResult> GetDevicesByCriteria([FromQuery] DeviceParams deviceParams)
{
var devicesFromRepo = await _repo.GetDevicesByCriteria(deviceParams);
// var devicesToReturn = _mapper.Map<IEnumerable<DeviceToReturnDto>>(devicesFromRepo.Devices);
return(Ok(devicesFromRepo));
}
protected virtual void ApplyDeviceParams()
{
if (updating)
{
return;
}
DeviceParams deviceParams = null;
if (device != null)
{
deviceParams = device.Parameters;
device.Dispose();
}
else
{
deviceParams = new DeviceParams();
}
if (newDeviceType == null)
{
newDeviceType = GraphicsDeviceType;
}
switch (newDeviceType)
{
case DeviceType.Gdi:
device = new GdiGraphicsDevice(graphics, GetCurrentViewport());
break;
case DeviceType.Direct3D:
Type xnaDeviceType = GetXnaGraphicsDeviceType();
if (xnaDeviceType == null)
{
goto case DeviceType.Gdi;
}
device = (GraphicsDevice)Activator.CreateInstance(xnaDeviceType, this.Handle, GetCurrentViewport());
break;
default:
device = null;
break;
}
if (device != null)
{
deviceParams.Viewport = null;
device.Parameters = deviceParams;
}
Scene original = scene;
RecreateScene(device, original.Camera, original.Projection);
newDeviceType = null;
Invalidate();
}
public DevicesWithFilterForCountSpec(DeviceParams deviceParams)
: base(x =>
(string.IsNullOrEmpty(deviceParams.Search) || x.Name.ToLower()
.Contains(deviceParams.Search)) &&
(!deviceParams.CategoryId.HasValue || x.CategoryId == deviceParams.CategoryId) &&
(!deviceParams.MakerId.HasValue || x.MakerId == deviceParams.MakerId)
)
{
}
public async Task <string> RegisterDevice(string url)
{
var device = new DeviceParams
{
Type = "WP",
Token = url
};
var result = await GetResponseAsync <DeviceParams, GetDeviceIdResult>("Devices", device);
return(result.Id);
}
private void InitializeGameFramework()
{
parm = new DeviceParams();
DeviceCaps _device_caps = AGT_GameFramework.GetDeviceCapabilities().DeviceCaps;
parm.ClrFlags = ClearFlags.Target | ClearFlags.ZBuffer;
parm.ZDepth = 1.0f;
parm.Stencil = 0;
parm.TargetControl = this;
parm.OnResize = new DeviceResizeHandler(OnResize);
parm.PresentationParameters = new PresentParameters();
parm.PresentationParameters.Windowed = true;
parm.PresentationParameters.SwapEffect = SwapEffect.Discard;
if (parm.PresentationParameters.Windowed)
{
parm.PresentationParameters.PresentationInterval = PresentInterval.Default;
parm.PresentationParameters.EnableAutoDepthStencil = true;
parm.PresentationParameters.AutoDepthStencilFormat = DepthFormat.D16;
}
else
{
parm.PresentationParameters.PresentationInterval = PresentInterval.Immediate;
parm.PresentationParameters.EnableAutoDepthStencil = false;
parm.PresentationParameters.BackBufferCount = 1;
parm.PresentationParameters.BackBufferHeight = Microsoft.DirectX.Direct3D.Manager.Adapters.Default.CurrentDisplayMode.Height;
parm.PresentationParameters.BackBufferWidth = Microsoft.DirectX.Direct3D.Manager.Adapters.Default.CurrentDisplayMode.Width;
parm.PresentationParameters.BackBufferFormat = Microsoft.DirectX.Direct3D.Manager.Adapters.Default.CurrentDisplayMode.Format;
}
if (_device_caps.SupportsHardwareTransformAndLight)
{
parm.Flags = CreateFlags.HardwareVertexProcessing;
if (_device_caps.SupportsPureDevice)
{
parm.Flags |= CreateFlags.PureDevice;
parm.Flags |= CreateFlags.MultiThreaded;
}
}
else
{
parm.Flags = CreateFlags.SoftwareVertexProcessing;
parm.Flags |= CreateFlags.MultiThreaded;
}
gf = new AGT_GameFramework(parm);
}
public async Task<IActionResult> GetDevices([FromQuery] DeviceParams deviceParams)
{
try
{
var devices = await _repo.GetDevices(deviceParams);
var devicesToReturn = _mapper.Map<IEnumerable<DeviceDto>>(devices);
return Ok(devicesToReturn);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return StatusCode((int)HttpStatusCode.InternalServerError, "Error!");
}
}
public Device(string DeviceName, DeviceParams Params = null)
{
var ParamsJson = (Params == null) ? "{}" : JSONUtility.stringify(Params);
var DeviceNameAscii = System.Text.ASCIIEncoding.ASCII.GetBytes(DeviceName + "\0");
var ParamsJsonAscii = System.Text.ASCIIEncoding.ASCII.GetBytes(ParamsJson + "\0");
var ErrorBuffer = new byte[100];
Instance = PopCameraDevice_CreateCameraDevice(DeviceNameAscii, ParamsJsonAscii, ErrorBuffer, ErrorBuffer.Length);
var Error = GetString(ErrorBuffer);
if (Instance.Value <= 0)
{
throw new System.Exception("Failed to create Camera device with name " + DeviceName + "; " + Error);
}
if (!String.IsNullOrEmpty(Error))
{
Debug.LogWarning("Created PopCameraDevice(" + Instance.Value + ") but error was not empty (length = " + Error.Length + ") " + Error);
}
}
public DeviceParams GetDeviceParams(int idx)
{
var nadp = new NativeMethods.NativeAudioDeviceParams();
int hr = NativeMethods.WWSASGetDeviceParams(mInstanceId, idx, ref nadp);
if (hr < 0)
{
throw new IndexOutOfRangeException();
}
var adp = new DeviceParams();
adp.id = nadp.id;
adp.defaultDevice = nadp.isDefaultDevice != 0;
adp.name = nadp.name;
adp.mute = nadp.mute != 0;
adp.peak = nadp.peak;
adp.masterVolumeLevelDecibel = nadp.masterVolumeLevel;
return(adp);
}
public async Task <ActionResult <Pagination <DeviceListToReturnDTO> > > GetDevices([FromQuery] DeviceParams deviceParams)
{
// record count with filters applied
var countSpec = new DevicesWithFilterForCountSpec(deviceParams);
var totalDevices = await _unitOfWork.Repository <Device>().CountAsync(countSpec);
var devices = _unitOfWork.Repository <Device>()
.Find(new DevicesWithCategoryAndMakerAndEmployeeDevices(deviceParams))
.ToList();
var data = _mapper.Map <IEnumerable <DeviceListToReturnDTO> >(devices);
return(Ok(new Pagination <DeviceListToReturnDTO>(
deviceParams.Page,
deviceParams.RecordsPerPage,
totalDevices,
data)
));
}
//vraca uredjaje u zavisnosti od vrijednosti parametara
public async Task <DeviceListDto> GetDevicesByCriteria(DeviceParams deviceParams)
{
var devices = _context.Devices
.Include(d => d.DevicePropertyValues)
.Include(d => d.DeviceType).ThenInclude(d => d.DeviceTypeProperty)
.Include(d => d.DeviceType).ThenInclude(d => d.ParentDeviceType).ThenInclude(d => d.DeviceTypeProperty)
.AsQueryable();
//ako postoji Name parametar, vraca uredjaje koji sadrze zadato ime
if (!string.IsNullOrEmpty(deviceParams.Name))
{
var searchName = deviceParams.Name.Trim().ToLowerInvariant();
devices = devices.Where(d => d.Name.Contains(searchName));
}
//ako postoji Type parametar, vraca uredjaje odgovarajuceg tipa
if (!string.IsNullOrEmpty(deviceParams.Type))
{
var searchType = deviceParams.Type.Trim().ToLowerInvariant();
devices = devices.Where(d => d.DeviceType.Name.Contains(searchType));
//ukoliko postoje Type i PropertyValue parametri
//vraca uredjaje tog tipa sa odgovarajucim vrijednostima osobina
if (!string.IsNullOrEmpty(deviceParams.PropertyValue))
{
var searchPropertyValue = deviceParams.PropertyValue.Trim().ToLowerInvariant();
devices = devices.Where(d => d.DevicePropertyValues
.Any(p => p.Value.Contains(searchPropertyValue)));
}
}
//ako postoji compare operator (<,>,<=,>=) i cijena, vraca odgovarajuce uredjaje
if (!string.IsNullOrEmpty(deviceParams.CompareOperator) && deviceParams.Price != null)
{
switch (deviceParams.CompareOperator)
{
case "<":
devices = devices.Where(d => d.Price < deviceParams.Price);
break;
case ">":
devices = devices.Where(d => d.Price > deviceParams.Price);
break;
case ">=":
devices = devices.Where(d => d.Price >= deviceParams.Price);
break;
case "<=":
devices = devices.Where(d => d.Price <= deviceParams.Price);
break;
case "=":
devices = devices.Where(d => d.Price == deviceParams.Price);
break;
default:
devices = devices.OrderByDescending(d => d.Price);
break;
}
}
//izvrsava paging na osnovu zadatih vriijednosti parametara
var pagedDevices = await devices
.Skip(deviceParams.PageSize *(deviceParams.PageNumber - 1))
.Take(deviceParams.PageSize)
.ToListAsync();
var devicesMapped = _mapper.Map <IEnumerable <DeviceToReturnDto> >(pagedDevices);
var objectToReturn = new DeviceListDto(devicesMapped, devices.Count());
return(objectToReturn);
}
public DevicesWithCategoryAndMakerAndEmployeeDevices(DeviceParams deviceParams)
: base(x =>
(string.IsNullOrEmpty(deviceParams.Search) ||
x.Name.ToLower().Contains(deviceParams.Search) ||
x.ProductId.ToLower().Contains(deviceParams.Search) ||
x.Id.ToString().Contains(deviceParams.Search)
) &&
(!deviceParams.CategoryId.HasValue || x.CategoryId == deviceParams.CategoryId) &&
(!deviceParams.MakerId.HasValue || x.MakerId == deviceParams.MakerId)
)
{
AddInclude(q => q.Include(d => d.Category));
AddInclude(q => q.Include(d => d.Maker));
AddInclude(q => q.Include(d => d.EmployeeDevice).ThenInclude(d => d.Employee));
if (!string.IsNullOrEmpty(deviceParams.Sort))
{
switch (deviceParams.Sort)
{
// productId
case "productIdAsc":
ApplyOrderBy(d => d.ProductId);
break;
case "productIdDesc":
ApplyOrderByDescending(d => d.ProductId);
break;
// category
case "categoryAsc":
ApplyOrderBy(d => d.Category.Name);
break;
case "categoryDesc":
ApplyOrderByDescending(d => d.Category.Name);
break;
// makers
case "makerAsc":
ApplyOrderBy(d => d.Maker.Name);
break;
case "makerDesc":
ApplyOrderByDescending(d => d.Maker.Name);
break;
// employees
case "employeesAssignedAsc":
ApplyOrderBy(d => d.EmployeeDevice.Count);
break;
case "employeesAssignedDesc":
ApplyOrderByDescending(d => d.EmployeeDevice.Count);
break;
// purchasedDate
case "purchasedAsc":
ApplyOrderBy(d => d.Purchased);
break;
case "purchasedDesc":
ApplyOrderByDescending(d => d.Purchased);
break;
// value
case "valueAsc":
ApplyOrderBy(d => d.Value);
break;
case "valueDesc":
ApplyOrderByDescending(d => d.Value);
break;
// Name
case "nameAsc":
ApplyOrderBy(d => d.Name);
break;
case "nameDesc":
ApplyOrderByDescending(d => d.Name);
break;
// Id (PK)
case "idAsc":
ApplyOrderBy(d => d.Id);
break;
case "idDesc":
ApplyOrderByDescending(d => d.Id);
break;
default:
ApplyOrderByDescending(d => d.Id);
break;
}
}
else // default sort
{
ApplyOrderByDescending(d => d.Id);
}
var skip = (deviceParams.Page - 1) * deviceParams.RecordsPerPage;
ApplyPaging(skip, deviceParams.RecordsPerPage);
}
public async Task <ActionResult <IEnumerable <EmployeeForReturnDTO> > > GetEmployees([FromQuery] DeviceParams pagination)
{
var entityCount = await _unitOfWork.Repository <Employee>().CountAsync(d => d.Id != 0);
await HttpContext.InsertPaginationParametersInResponse(entityCount, pagination.RecordsPerPage);
var employees = _unitOfWork.Repository <Employee>()
.Find(new EmployeesSpec((pagination.Page - 1) * pagination.RecordsPerPage, pagination.RecordsPerPage))
.ToList();
return(Ok(_mapper
.Map <IEnumerable <EmployeeForReturnDTO> >(employees)));
}
