public bool UpdateBalanceAmount(int cardId, int userId, decimal newAmount)
{
var data = new FilterDTO
{
Fields = new List<KeyValuePair<string, string>>()
{
new KeyValuePair<string, string>("hoeveelheid", newAmount.ToString(System.Globalization.CultureInfo.InvariantCulture))
}
};
UpdateDTO<Balance> result;
try
{
result = client.Send<UpdateDTO<Balance>>(data, HttpRequestType.POST, $"user/{userId}/cards/{cardId}/update");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return false;
}
if (result != null)
{
return result.Success;
}
return false;
}
public async void GetTeacherRegRequests_FacultyFilter_CheckEmptyList()
{
using (var context = InMemoryDBContext.GetDBContext())
{
// Arrange
var adminSerice = new AdminService(userManager.Object, context);
InitContext(context);
var filters = new FilterDTO[]
{
new FilterDTO
{
Name = "facultyId",
Value = "3"
}
};
// Act
var result = await adminSerice.GetTeacherRegisterRequestsAsync(filters);
var resultTeachers = result.Data;
// Assert
Assert.Empty(resultTeachers);
}
}
public async Task <List <Poster> > GetAllPostersAsync(int userId, FilterDTO filter)
{
return(await TryCatch(async() =>
{
var list = await _repository.GetAllAsync(w => w.UserId != userId && !w.IsAdopted);
if (filter.PetType.HasValue)
{
list = list.Where(w => (int)w.PetType == filter.PetType.Value).ToList();
}
if (filter.Castrated.HasValue)
{
list = list.Where(w => w.Castrated == filter.Castrated.Value).ToList();
}
if (filter.Dewormed.HasValue)
{
list = list.Where(w => w.Dewormed == filter.Dewormed.Value).ToList();
}
if (filter.DeliverToAdopter.HasValue)
{
list = list.Where(w => w.Dewormed == filter.DeliverToAdopter.Value).ToList();
}
if (!string.IsNullOrEmpty(filter.City))
{
list = list.Where(w => w.City == filter.City).ToList();
}
return list;
}));
}
public async void GetTeacherRegRequests_DepartmentFilter_CheckListSingle()
{
using (var context = InMemoryDBContext.GetDBContext())
{
// Arrange
var adminSerice = new AdminService(userManager.Object, context);
InitContext(context);
var filters = new FilterDTO[]
{
new FilterDTO
{
Name = "departmentId",
Value = "1"
}
};
// Act
var result = await adminSerice.GetTeacherRegisterRequestsAsync(filters);
var resultTeachers = result.Data;
// Assert
Assert.Single(resultTeachers);
}
}
public JsonResult ListFilter(FilterDTO filter)
{
IQueryable <Operation> res = db.Operations;
List <Expression <Func <Operation, bool> > > predicatList = new List <Expression <Func <Operation, bool> > >();
if (filter?.Category_Id.HasValue ?? false)
{
predicatList.Add(c => c.Product.Category_Id == filter.Category_Id.Value);
}
if (filter?.Product_Id.HasValue ?? false)
{
predicatList.Add(c => c.Product_Id == filter.Product_Id.Value);
}
if (filter?.OperationType.HasValue ?? false)
{
predicatList.Add(c => c.OperationType == (OperationType)filter.OperationType.Value);
}
if (filter?.Date1.HasValue ?? false)
{
predicatList.Add(c => c.PDate >= filter.Date1.Value);
}
if (filter?.Date2.HasValue ?? false)
{
predicatList.Add(c => c.PDate <= filter.Date2.Value);
}
if (predicatList.Count > 0)
{
var predicat = predicatList.Aggregate((f, s) => f.And(s));
var res2 = SelectOperations(res.Where(predicat));
return(Json(res2));
}
var result = SelectOperations(res);
return(Json(result));
}
public async void GetStudentRegRequests_GroupFilter_CheckSingle()
{
using (var context = InMemoryDBContext.GetDBContext())
{
// Arrange
var adminSerice = new AdminService(userManager.Object, context);
InitContext(context);
var filters = new FilterDTO[]
{
new FilterDTO
{
Name = "groupId",
Value = "2"
}
};
// Act
var result = await adminSerice.GetStudentRegisterRequestsAsync(filters);
var resultStudents = result.Data;
// Assert
Assert.Single(resultStudents);
}
}
static void Main(string[] args)
{
IWebclient client = new Webclient("http://pti409368core.venus.fhict.nl/api/");
var data = new FilterDTO()
{
Fields = new List <KeyValuePair <string, string> >()
{
// new KeyValuePair<string, string>("email", "*****@*****.**"),
// new KeyValuePair<string, string>("wachtwoord", "asdf123"),
// voor inloggen met code:
new KeyValuePair <string, string>("code", "55827"),
// 55827
}
};
var json = JsonConvert.SerializeObject(data);
ResultDTO <User> login = client.Send <ResultDTO <User> >(
data,
HttpRequestType.POST,
"user/login"
);
foreach (User u in login.Result)
{
var cards = client.Send <ResultDTO <Balance> >(null, HttpRequestType.GET, "api/user/" + u.ID + "/cards");
}
}
public void TestFilterEqualsSingleNumberResultValidityEquals()
{
//arange
var domainList = new List <TestDomain>();
domainList.Add(new TestDomain {
ID = 1
});
domainList.Add(new TestDomain {
ID = 2
});
domainList.Add(new TestDomain {
ID = 3
});
domainList.Add(new TestDomain {
ID = 4
});
domainList.Add(new TestDomain {
ID = 5
});
var filter = new FilterDTO();
filter.Id = 1;
IQueryable <TestDomain> query = domainList.AsQueryable();
//act
query = FilterQuery.SetFilters <TestDomain, FilterDTO>(query, filter);
var rez = query.ToList();
//assert
Assert.AreEqual(1, rez.FirstOrDefault().ID);
}
public IList <QuestionDTO> GetQuestionByServiceID(FilterDTO filterDTO)
{
IList <QuestionDTO> questionDTOs = new List <QuestionDTO>();
try
{
questionDTOs = this.UnitOfWork.GetQueryable <Question>().Where(e => e.ServiceID == filterDTO.ID)
.Select(e => new QuestionDTO()
{
ID = e.ID,
ServiceID = e.ServiceID,
Title = e.Title,
AnswerOptions = e.AnswerOptions.Select(a => new AnswerOptionDTO {
ID = a.ID,
Icon = a.Icon,
Point = a.Point,
QuestionID = a.QuestionID,
Title = a.Title
}).ToList()
}).ToList();
}
catch (Exception ex)
{
Logging.LogError("Business-GetQuestionByServiceID: ", ex);
}
return(questionDTOs);
}
public List <Book> Get(
[FromQuery] string author,
[FromQuery] string name,
[FromQuery] string genre,
[FromQuery] string illustrator,
[FromQuery] double?initialprice,
[FromQuery] double?finalprice,
[FromQuery] int?initialnumberpages,
[FromQuery] int?finalnumberpages,
[FromQuery] string orderby,
[FromQuery] bool asc
)
{
var filter = new FilterDTO
{
Author = author,
Name = name,
Genre = genre,
Illustrator = illustrator,
InitialPrice = initialprice,
FinalPrice = finalprice,
InitialNumberPages = initialnumberpages,
FinalNumberPages = finalnumberpages,
OrderBy = orderby,
Ascending = asc
};
return(_service.SearchBook(filter));
}
public IEnumerable <CarDTO> GetCars(FilterDTO searchModel)
{
Logger.Debug("BLL: GetCars(filter) called");
// Using of Automapper for projection the Car entity into the CarDTO
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Car, CarDTO>();
cfg.CreateMap <Order, OrderDTO>();
});
var mapper = config.CreateMapper();
if (searchModel == null)
{
return(mapper.Map <IEnumerable <CarDTO> >(Database.Cars.GetAll()));
}
// Comparing each car with searchModel
return(mapper.Map <IEnumerable <CarDTO> >(Database.Cars.Find(
car => (searchModel.Brands == null || searchModel.Brands.Length < 1 || searchModel.Brands.Contains(car.Brand)) &&
(searchModel.Classes == null || searchModel.Classes.Length < 1 || searchModel.Classes.Contains(car.Class)) &&
searchModel.MinPrice < car.PriceForDay &&
searchModel.MaxPrice > car.PriceForDay &&
(searchModel.AirConditioning == null || searchModel.AirConditioning == car.AirConditioning) &&
(searchModel.AutomaticTransmission == null || searchModel.AutomaticTransmission == car.AutomaticTransmission)
)));
}
public void Refresh()
{
filter = ClientRequests.getFilters();
TypeList.ItemsSource = filter.types.Select(x => x.type);
CatagoryList.ItemsSource = filter.categories.Select(x => x.category);
ServicesList.ItemsSource = filter.services.Select(x => x.name);
}
public List <MarkResultDTO> GetMarkResultsFiltered(FilterDTO filterDTO)
{
IQueryable <Mark> data = _markRepository.GetAll();
if (filterDTO.Score > 0)
{
data = data.Where(p => p.Score > filterDTO.Score);
}
if (!string.IsNullOrEmpty(filterDTO.StudentName))
{
data = data.Where(p => p.Student.FullName.ToLower().Contains(filterDTO.StudentName.ToLower()));
}
if (!string.IsNullOrEmpty(filterDTO.SubjectName))
{
data = data.Where(p => p.Subject.Name.ToLower().Contains(filterDTO.SubjectName.ToLower()));
}
return(_mapper.Map <List <MarkDTO> >(data).GroupBy(p => p.StudentId)
.Select(marks => new MarkResultDTO()
{
StudentName = marks.FirstOrDefault(p => p.StudentId == marks.Key).StudentName,
Marks = marks.ToList()
}).ToList());
}
public async Task <IActionResult> GetFilterAsync([FromBody] FilterDTO modelDto)
{
Response <IEnumerable <MicroEmpresasDTO> > response = new Response <IEnumerable <MicroEmpresasDTO> >();
try
{
response = await _Application.GetFilterAsync(modelDto);
if (response.IsSuccess)
{
return(Ok(response));
}
else
{
return(BadRequest(response));
}
}
catch (Exception ex)
{
response.Data = null;
response.IsSuccess = false;
response.Message = ex.Message;
return(BadRequest(response));
}
}
public JsonResult Login(FilterModel filterModel)
{
JsonModel model = new JsonModel();
try
{
FilterDTO filterDTO = Mapper.Map <FilterDTO>(filterModel);
UserDTO userDTO = this.Business.GetUser(filterDTO);
if (userDTO == null)
{
model = new JsonModel()
{
Result = false,
Message = "Vui lòng kiểm tra mật khẩu"
};
return(Json(model, JsonRequestBehavior.AllowGet));
}
UserContext = userDTO;
model = new JsonModel()
{
Result = true,
};
}
catch (Exception ex)
{
Logging.LogError("HomeController - ConfirmPassCode: ", ex);
}
return(Json(model, JsonRequestBehavior.AllowGet));
}
public bool DeleteFilterValue(FilterDTO f)
{
bool isAdded = false;
isAdded = DataProvider.DeleteFilterValue(f);
return(isAdded);
}
public IActionResult FilterAttractions(string category, string city)
{
List <Attractions> filteredAttractions = attractionsService.GetAttractionsByCategoryAndCity(category, city);
var filterDTO = new FilterDTO()
{
Result = "ok", Count = filteredAttractions.Count(), Attractions = filteredAttractions
};
return(Json(filterDTO));
}
public virtual string QueryFields(FilterDTO filters)
{
string query = " SET ";
filters.Fields.Where(f => f.Key.ToLower() != PrimaryKey.ToLower()).ToList().ForEach(f =>
{
query += f.Key + " = '" + f.Value + "',";
});
return(query.Substring(0, query.Length - 1));
}
public UpdateDTO <Balance> UpdateCard(FilterDTO filters, int cardId, int userId)
{
if (!filters.Fields.Any(f => f.Key.ToLower() == "hoeveelheid"))
{
throw new MissingFieldException("Missing amount for update.");
}
var newBalance = _srepo.Update(filters, cardId, userId);
return(newBalance);
}
public UpdateDTO <User> Update(FilterDTO filters)
{
if (!(filters.Fields.Any(f => f.Key.ToLower() == _repo.PrimaryKey.ToLower())))
{
return(_repo.Insert(filters));
}
else
{
return(_repo.Update(filters));
}
}
public void addCatagory(object sender, RoutedEventArgs arg)
{
if (NewCatagory.Text == "")
{
MessageBox.Show("Cannot add blank name");
return;
}
ClientRequests.addCatagory(NewCatagory.Text);
filter = ClientRequests.getFilters();
CatagoryList.ItemsSource = filter.categories.Select(x => x.category);
}
public void addService(object sender, RoutedEventArgs arg)
{
if (NewService.Text == "")
{
MessageBox.Show("Cannot add blank name");
return;
}
ClientRequests.addService(NewService.Text);
filter = ClientRequests.getFilters();
ServicesList.ItemsSource = filter.services.Select(x => x.name);
}
public IActionResult UpdateCard([FromBody] FilterDTO filters, [FromRoute] int userId, [FromRoute] int cardId)
{
try
{
return(Ok(_service.UpdateCard(filters, cardId, userId)));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public IActionResult DeleteCard([FromBody] FilterDTO filters)
{
try
{
return(Ok(_service.DeleteCard(filters)));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <IList <OrderViewModel> > GetOrdersView(FilterDTO filter)
{
//define the base query
var ordersQuery = _ordersContext
.Orders
.ProjectTo <OrderViewModel>(_mapper.ConfigurationProvider);
// apply the sort and filter
ordersQuery = ordersQuery.ToFilterView(filter);
// return the result
return(await ordersQuery.ToListAsync());
}
private List <FilterDTO> GetFiltersList()
{
List <FilterDTO> filters = new List <FilterDTO>();
foreach (ListViewItem item in listViewConditions.Items)
{
var index = comboBoxCond.Items.IndexOf(item.SubItems[1].Text);
FilterDTO fdto = new FilterDTO(item.SubItems[0].Text, (Condition)index, item.SubItems[2].Text);
filters.Add(fdto);
}
return(filters);
}
public ResultDTO <T> Get(FilterDTO filters)
{
ResultDTO <T> result = new ResultDTO <T>();
DataTable dt = Database.ExecSelect(queryGet(filters));
foreach (DataRow dr in dt.Rows)
{
result.Result.Add(FromDataRow(dr));
}
return(result);
}
public IEnumerable <People> Get(FilterDTO filterDTO)
{
IQueryable <People> query = _mongoCollection.AsQueryable();
if (!string.IsNullOrWhiteSpace(filterDTO.Name))
{
query = query.Where(x => x.Name.Contains(filterDTO.Name));
}
_mongoCollection.Find <People>(x => x.Name.Contains(filterDTO.Name));
throw new System.NotImplementedException();
}
public void GetGamesByFilter_FilterByDateTwoYear_GetedGames()
{
var filterDto = new FilterDTO()
{
FilterDate = FilterDate.twoYear
};
var gamePipeline = new GamePipeline();
gamePipeline.Register(new GameFilterByDate(filterDto.FilterDate));
var gamesAfteFilter = gamePipeline.Process(_fakeGamesForFilter);
Assert.True(gamesAfteFilter.ElementAt(0).PublishDate > gamesAfteFilter.ElementAt(1).PublishDate);
}
public void GetGamesByFilter_FilterByDateWeek_GetedGames()
{
var filterDto = new FilterDTO()
{
FilterDate = FilterDate.week
};
var gamePipeline = new GamePipeline();
gamePipeline.Register(new GameFilterByDate(filterDto.FilterDate));
var gamesAfteFilter = gamePipeline.Process(_fakeGamesForFilter);
Assert.True(gamesAfteFilter.First().PublishDate >= DateTime.Today.AddDays(-7));
}
private BaseFilter CreateBaseFilter(FilterDTO filterDTO, string locationID, string database)
{
var unit = LookUpUnit(filterDTO.Type);
if (filterDTO.Type == "C" || filterDTO.Type == "V")
{
var dict = new FilterService().GetFilterOptions(locationID, database, filterDTO.CSelect, filterDTO.CTitle, filterDTO.CName);
return new SelectFilter(filterDTO.Title, filterDTO.Name, unit, filterDTO.Type == "C", dict);
}
else if (filterDTO.Type == "D" || filterDTO.Type == "X")
{
return new DateFilter(filterDTO.Title, filterDTO.Name, unit);
}
else
{
return new TextFilter(filterDTO.Title, filterDTO.Name, unit);
}
}
