public ActionResult Index(GenericListingPage model, FilteringModel filteringModel)
{
var service = new GenericListingPageService();
var viewModel = service.GetViewModel(model, filteringModel);
return(CurrentTemplate(viewModel));
}
public JsonResult GetAllSearchedBooks([FromBody] FilteringModel filteringModel)
{
List <BookShelf> bookList = new List <BookShelf>();
string sqlExpression = "FindSearchedBook";
var SearchedTitle = new SqlParameter("@searchedTitle", filteringModel.Title);
var SearchedAuthor = new SqlParameter("@searchedAuthor", filteringModel.Author);
var BookGener = new SqlParameter("@bookGener", filteringModel.Gener);
var BookType = new SqlParameter("@bookType", filteringModel.Type);
try
{
using (SqlConnection connection = new SqlConnection(_context.Database.GetDbConnection().ConnectionString))
{
SqlCommand command = new SqlCommand(sqlExpression, connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add(SearchedTitle);
command.Parameters.Add(SearchedAuthor);
command.Parameters.Add(BookGener);
command.Parameters.Add(BookType);
connection.Open();
var reader = command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
bookList.Add(
new BookShelf
{
Id = (reader.IsDBNull(0)) ? 0 : reader.GetInt32(0),
Author = (reader.IsDBNull(1)) ? null : reader.GetString(1),
CreateOn = (reader.IsDBNull(2)) ? new DateTime(1900, 01, 01) : reader.GetDateTime(2),
Description = (reader.IsDBNull(3)) ? null : reader.GetString(3),
Price = (reader.IsDBNull(4)) ? new Decimal(0.00) : reader.GetDecimal(4),
Title = (reader.IsDBNull(5)) ? null : reader.GetString(5),
ContributorFirstName = (reader.IsDBNull(6)) ? null : reader.GetString(6),
ContributorLastName = (reader.IsDBNull(7)) ? null : reader.GetString(7),
FirstName = (reader.IsDBNull(8)) ? null : reader.GetString(8),
LastName = (reader.IsDBNull(9)) ? null : reader.GetString(9),
PhoneNumber = (reader.IsDBNull(10)) ? null : reader.GetString(10),
Genre = (reader.IsDBNull(11)) ? null : reader.GetString(11),
BookType = (reader.IsDBNull(12)) ? null : reader.GetString(12),
LongtiudeCoordinate = reader.IsDBNull(13) ? null : reader.GetString(13),
AltitudeCoordinate = (reader.IsDBNull(14) ? null : reader.GetString(14))
});
}
}
reader.Close();
connection.Close();
}
return(Json(bookList));
}
catch (Exception ex)
{
return(Json("zrada"));
}
}
public Filtering()
{
Model = new FilteringModel
{
Filter = FilteringModel.FilterType.Login.ToString()
};
InitializeComponent();
BindingContext = this;
}
private Expression <Func <Device, bool> > GetFilterExpression(FilteringModel filter)
{
FillFiltering(filter);
Expression <Func <Device, bool> > expression = (Device device) => device.IsDeleted == false;
foreach (var prop in filter.GetType().GetProperties())
{
if (prop.GetValue(filter) != null)
{
expression = expression.AND(_filteringRules.GetValueOrDefault(prop.Name.ToLower()) ?? expression);
}
}
return(expression);
}
public IHttpActionResult SaveSetting([FromBody] FilteringModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var selected = model.Items.Select(x => x.FieldId).ToList();
_filterService.SaveProductFilteringFields(selected);
AddSuccessMessage(GetString("General.Item.Updated"));
return(Ok(model));
}
private void FillFiltering(FilteringModel filter)
{
_filteringRules = new Dictionary <string, Expression <Func <Device, bool> > >();
Expression <Func <Device, bool> > quickSearchFunc = x => !string.IsNullOrEmpty(x.DeviceName) ? x.DeviceName.ToLower().Contains(filter.SearchPhrase.ToLower()) ||
x.Udid.ToLower().Contains(filter.SearchPhrase.ToLower()) ||
x.Id.ToString().ToLower().Contains(filter.SearchPhrase.ToLower()) :
x.Udid.ToLower().Contains(filter.SearchPhrase.ToLower()) ||
x.Id.ToString().ToLower().Contains(filter.SearchPhrase.ToLower());
_filteringRules.Add(nameof(FilteringModel.CompanyIds).ToLower(), (Device device) => filter.CompanyIds.Contains(device.CompanyId));
_filteringRules.Add(nameof(FilteringModel.IsOnline).ToLower(), (Device device) => device.DeviceHistory.Any() &&
device.DeviceHistory.OrderByDescending(x => x.CreatedOn).Take(1).All(x => x.IsOnline == filter.IsOnline));
_filteringRules.Add(nameof(FilteringModel.BranchIds).ToLower(), (Device device) => filter.BranchIds.Contains(device.BranchId));
_filteringRules.Add(nameof(FilteringModel.SearchPhrase).ToLower(), quickSearchFunc);
}
public async Task ShouldReturnQuickSearchedEmptyForAdmin()
{
// Arrange
CreateDevicesAndSetupMockWithParams();
var searchPhrase = "";
var filter = new FilteringModel {
SearchPhrase = searchPhrase
};
// Act
var result = await _deviceService.GetAll(filter, new LazyLoadParameters(), new Sorting(), It.IsAny <string>());
//Assert
Assert.NotEmpty(result.Result);
Assert.Equal(_baseTest.DbContext.Devices.Count(), result.Result.Count());
}
public async Task ShouldReturnQuickSearchedByUdidDevicesForAdmin()
{
// Arrange
CreateDevicesAndSetupMockWithParams();
var searchPhrase = _baseTest.DbContext.Devices.First().Udid.Substring(0, 3);
var filter = new FilteringModel {
SearchPhrase = searchPhrase
};
// Act
var result = await _deviceService.GetAll(filter, new LazyLoadParameters(), new Sorting(), It.IsAny <string>());
//Assert
Assert.NotEmpty(result.Result);
Assert.True(result.Result.All(x => x.Id.ToString().ToLower().Contains(searchPhrase.ToLower()) || x.Udid.ToLower().Contains(searchPhrase.ToLower())));
}
public async Task ShouldReturnFilteredIsOnlineDevicesForAdmin(bool isOnline)
{
// Arrange
CreateDevicesAndSetupMockWithParams();
var filter = new FilteringModel {
IsOnline = isOnline
};
// Act
var result = await _deviceService.GetAll(filter, new LazyLoadParameters(), new Sorting(), It.IsAny <string>());
//Assert
Assert.NotEmpty(result.Result);
Assert.True(result.Result.All(x => x.IsOnline == isOnline));
Assert.False(result.Result.Any(x => x.IsOnline != isOnline));
}
public async Task <IActionResult> GetAll([FromQuery] FilteringModel filter, [FromQuery] LazyLoadParameters lazyLoadFilters, [FromQuery] Sorting sorting)
{
try
{
var devices = await _deviceService.GetAll(filter, lazyLoadFilters, sorting, Token);
return(Ok(devices));
}
catch (ArgumentNullException ex)
{
return(BadRequest($"{ex.ParamName} ---- {ex.Message}"));
}
catch (ApplicationException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task ShouldReturnQuickSearchedEmptyForSuperviser()
{
// Arrange
var comapnyId = 100500;
CreateDevicesAndSetupMockWithParams(comapnyId);
var searchPhrase = "";
var filter = new FilteringModel {
SearchPhrase = searchPhrase
};
// Act
var result = await _deviceService.GetAll(filter, new LazyLoadParameters(), new Sorting(), It.IsAny <string>());
//Assert
Assert.NotEmpty(result.Result);
Assert.True(result.Result.All(x => x.Company.Id == comapnyId));
Assert.Equal(_baseTest.DbContext.Devices.Count(x => x.CompanyId == comapnyId), result.Result.Count());
}
public async Task ShouldReturnFilteredByBranchIdsDevicesForAdmin()
{
// Arrange
CreateDevicesAndSetupMockWithParams();
var branchIds = new List <Guid> {
_baseTest.DbContext.Devices.First().BranchId, _baseTest.DbContext.Devices.Last().BranchId
};
var filter = new FilteringModel {
BranchIds = branchIds
};
// Act
var result = await _deviceService.GetAll(filter, new LazyLoadParameters(), new Sorting(), It.IsAny <string>());
//Assert
Assert.NotEmpty(result.Result);
Assert.True(result.Result.All(x => filter.BranchIds.Contains(x.Branch.Id)));
Assert.False(result.Result.Any(x => !filter.BranchIds.Contains(x.Branch.Id)));
}
public async Task <IActionResult> Index(FilteringModel filtering, SortingModel sorting, PagingModel paging)
{
ViewBag.Filter = filtering;
ViewBag.Sort = sorting;
ViewBag.Paging = paging;
ViewBag.PageSize = new SelectList(new List <int> {
2, 5, 10, 25, 50, 100
}, paging.PageSize);
var filterDTO = _mapper.Map <IFilteringModel>(filtering);
var sortDTO = _mapper.Map <ISortingModel>(sorting);
var pagingDTO = _mapper.Map <IPagingModel>(paging);
var makes = await _vehicleService.GetPagedMakesAsync(filterDTO, sortDTO, pagingDTO);
var viewModel = _mapper.Map <IPagedList <IVehicleMake>, IPagedList <VehicleMakeViewModel> >(makes);
return(View(viewModel));
}
public async Task ShouldReturnFilteredByCompanyIdsDevicesForSuperviser()
{
// Arrange
var comapnyId = 100500;
CreateDevicesAndSetupMockWithParams(comapnyId);
var companyIds = new List <int> {
_baseTest.DbContext.Devices.First().CompanyId, _baseTest.DbContext.Devices.Last().CompanyId
};
var filter = new FilteringModel {
CompanyIds = companyIds
};
// Act
var result = await _deviceService.GetAll(filter, new LazyLoadParameters(), new Sorting(), It.IsAny <string>());
//Assert
Assert.NotEmpty(result.Result);
Assert.True(result.Result.All(x => x.Company.Id == comapnyId));
}
public async Task ShouldReturnFilteredIsOnlineDevicesForSuperviser(bool isOnline)
{
// Arrange
var comapnyId = 100500;
CreateDevicesAndSetupMockWithParams(comapnyId);
var devices = _baseTest.DbContext.Devices.ToList();
var history = devices.First(x => x.CompanyId == comapnyId).DeviceHistory.OrderByDescending(x => x.CreatedOn).First();
history.IsOnline = isOnline;
_baseTest.DbContext.DeviceHistory.Update(history);
_baseTest.DbContext.SaveChanges();
var filter = new FilteringModel {
IsOnline = isOnline
};
// Act
var result = await _deviceService.GetAll(filter, new LazyLoadParameters(), new Sorting(), It.IsAny <string>());
//Assert
Assert.NotEmpty(result.Result);
Assert.True(result.Result.All(x => x.Company.Id == comapnyId));
Assert.True(result.Result.All(x => x.IsOnline == isOnline));
Assert.False(result.Result.Any(x => x.IsOnline != isOnline));
}
/// <inheritdoc />
public async Task <LazyLoadedResult <DeviceModel> > GetAll(FilteringModel filter, LazyLoadParameters lazyLoadFilters, Sorting sorting, string token)
{
var resultLazy = new LazyLoadedResult <DeviceModel>();
var deviceList = new List <DeviceModel>();
var companyId = await _validationHelper.GetCompanyIdByPermission(token, new [] { Const.Permissions.Device.AdminRead });
List <TenantFullModel> tenants = new List <TenantFullModel>();
if (companyId != null)
{
filter.CompanyIds = new List <int> {
companyId.Value
};
var tenant = await _httpService.GetTenantSingleByCompanyId(companyId.Value, token);
tenants.Add(tenant);
}
else
{
if (filter.TenantIds.Any())
{
var tenantIdsString = filter.TenantIds.Select(x => x.ToString()).ToList();
tenants = await _httpService.GetTenantsByIds(token, GetQuery("TenantIds", tenantIdsString));
var companyIds = tenants.SelectMany(x => x.Companies).Select(x => x.Id).ToList();
filter.CompanyIds = filter.CompanyIds != null ? companyIds.Count > 0 ? filter.CompanyIds.Intersect(companyIds).ToList() :
null : companyIds;
}
else
{
tenants = await _httpService.GetTenantsByIds(token);
}
}
var devices = await _deviceRepository.GetWithoutIncludeAsync(GetFilterExpression(filter));
var devicesHistories = await _deviceHistoryRepository.GetAsync();
if (!devices.Any())
{
return(resultLazy);
}
var compIds = (from device in devices select device.CompanyId.ToString()).ToList();
var branchIds = (from device in devices select device.BranchId.ToString()).ToList();
var deviceAndLastHistoryQuery = (from device in devices
from history in devicesHistories.Where(x => x.DeviceId == device.Id).OrderByDescending(x => x.CreatedOn).Take(1)
select new
{
Device = device,
LastHistory = history
});
var usersIds = deviceAndLastHistoryQuery.Where(x => x.LastHistory.LoggedInUserId.HasValue).Select(x => x.LastHistory.LoggedInUserId.ToString().ToLower()).Distinct().ToList();
//var companies = await _httpService.GetCompaniesByIds(GetQuery("CompanyIds", compIds), token);
var companyTenant = tenants.SelectMany(tenant => tenant.Companies, (tenant, company) => new
{
Company = company,
Tenant = tenant
});
var branches = await _httpService.GetBranchesByIds(GetQuery("BranchIds", branchIds), token);
var users = await _httpService.GetUsersByIdsAsync(token, GetQuery("UsersId", usersIds));
var fdeviceList = (from deviceInfo in deviceAndLastHistoryQuery
join company in companyTenant on deviceInfo.Device.CompanyId equals company.Company.Id into _c
from company in _c.DefaultIfEmpty()
join branch in branches on deviceInfo.Device.BranchId equals branch.Id into _b
from branch in _b.DefaultIfEmpty()
join user in users on deviceInfo.LastHistory.LoggedInUserId equals user.Id into _u
from user in _u.DefaultIfEmpty()
select new DeviceModel
{
Id = deviceInfo.Device.Id,
Udid = deviceInfo.Device.Udid,
CreatedOn = deviceInfo.Device.CreatedOn,
HexnodeUdid = deviceInfo.Device.HexnodeUdid,
DeviceName = deviceInfo.Device.DeviceName,
IsPending = deviceInfo.Device.IsPending,
Latitude = deviceInfo.Device.Latitude,
Longitude = deviceInfo.Device.Longitude,
Radius = deviceInfo.Device.Radius,
IsDeleted = deviceInfo.Device.IsDeleted,
IsOnline = deviceInfo.LastHistory.IsOnline,
IsInLocation = deviceInfo.LastHistory.IsInLocation,
StatusSince = deviceInfo.LastHistory.CreatedOn,
Branch = branch,
Company = company.Company,
Tenant = company.Tenant.Adapt <TenantModel>(),
LoggedInAs = user,
Phone = deviceInfo.Device.Phone,
CurrentDeviceLocationLatitude = deviceInfo.LastHistory.CurrentDeviceLocationLatitude,
CurrentDeviceLocationLongitude = deviceInfo.LastHistory.CurrentDeviceLocationLongitude,
});
resultLazy = GetSorted(fdeviceList, sorting).GetPart(lazyLoadFilters);
return(resultLazy);
}
