public async Task <IActionResult> Index(CountryFilterModel filter)
{
var filterRequest = new CountryFilter()
{
Page = filter.Page,
PageSize = _pagerOptions.PageSize,
Keyword = filter.Search
};
var countryPageList = await _countryService.GetAsync(filterRequest);
var countries = countryPageList.Collections.Select(x => new CountryModel()
{
Code = x.Code,
Id = x.Id,
Name = x.Name
});
var countryPage = new PageListModel <CountryModel>(countries)
{
Filter = filter,
TotalPage = countryPageList.TotalPage,
TotalResult = countryPageList.TotalResult
};
if (_httpHelper.IsAjaxRequest(Request))
{
return(PartialView("_CountryTable", countryPage));
}
return(View(countryPage));
}
public async Task <BasePageList <CountryResult> > GetAsync(CountryFilter filter)
{
var keyword = filter.Keyword != null?filter.Keyword.ToLower() : "";
var query = _countryRepository.Table
.Select(x => new CountryResult()
{
Code = x.Code,
Id = x.Id,
Name = x.Name
});
if (!string.IsNullOrEmpty(keyword))
{
query = query.Where(x => x.Code.ToLower().Contains(keyword) || x.Name.ToLower().Contains(keyword));
}
var filteredNumber = query.Select(x => x.Id).Count();
var countries = await query.OrderBy(x => x.Code).Skip(filter.PageSize * (filter.Page - 1))
.Take(filter.PageSize)
.ToListAsync();
var result = new BasePageList <CountryResult>(countries)
{
TotalResult = filteredNumber,
TotalPage = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
};
return(result);
}
public void CountryFilter(CountryFilter countryFilter)
{
CurrentCountryFilter = countryFilter;
// remove all filters first
MultipleFilter.Filter -= new FilterEventHandler(MultipleFilter.filters.CountryEUR);
MultipleFilter.Filter -= new FilterEventHandler(MultipleFilter.filters.CountryJPN);
MultipleFilter.Filter -= new FilterEventHandler(MultipleFilter.filters.CountryUSA);
// add the selected filter
switch (countryFilter)
{
case GamesLibrary.CountryFilter.ALL:
// do nothing
break;
case GamesLibrary.CountryFilter.EUR:
MultipleFilter.Filter += new FilterEventHandler(MultipleFilter.filters.CountryEUR); break;
case GamesLibrary.CountryFilter.JPN:
MultipleFilter.Filter += new FilterEventHandler(MultipleFilter.filters.CountryJPN); break;
case GamesLibrary.CountryFilter.USA:
MultipleFilter.Filter += new FilterEventHandler(MultipleFilter.filters.CountryUSA); break;
}
}
public async Task <DataGetResult <Country> > GetByFilterAsync(CountryFilter filter)
{
try
{
var bson = new BsonDocument
{
{ "ContinentId", new ObjectId(filter.ContinentId.ToString()) }
};
var asyncCursor = await Collection.FindAsync(bson);
var dbCountries = asyncCursor.ToList();
if (dbCountries == null || false == dbCountries.Any())
{
return(new DataGetResult <Country>());
}
var entities = dbCountries
.AsQueryable()
.Select(c => mapToEntity(c))
.ToList();
return(new DataGetResult <Country>(entities));
}
catch (Exception ex)
{
Logger.Error(ex);
return(new DataGetResult <Country>(ex));
}
}
public PageModel <ICountry> GetCountriesPage(CountryFilter filter)
{
var dataFilter = CountryFilterConverter.ConvertToDbValue(filter);
var tourPageData = _countryDataManager.GetCountriesPage(dataFilter);
var tourPageCollection = tourPageData.Collection.Select(c => new CountryModel(c, _countryDataManager))
.ToList();
var result = new PageModel <ICountry>(tourPageData.Count, tourPageCollection);
return(result);
}
public PageViewModel <CountryShortViewModel> GetCollection(string tourType, int skip = 0, int take = int.MaxValue)
{
var countryFilter = new CountryFilter(skip, take)
{
TourType = string.IsNullOrWhiteSpace(tourType) ? (TourTypesEnum?)null : TourTypesConverter.ConvertFromString(tourType)
};
var countriesPage = _countryManager.GetCountriesPage(countryFilter);
var result = GetCountriesPageViewModel(countriesPage);
return(result);
}
public static CountryDataFilter ConvertToDbValue(CountryFilter tourFilter)
{
CountryDataFilter result = new CountryDataFilter
{
Skip = tourFilter.Skip,
Take = tourFilter.Take,
TourType = tourFilter.TourType.HasValue ? TourTypesEnumConverter.ConvertToDbValue(tourFilter.TourType.Value) : null
};
return(result);
}
public override string GetRequestUrl()
{
if (Query == "")
{
throw new Exception("Empty Query value in Autosuggest REST Request");
}
string queryStr = string.Format("q={0}", Uri.EscapeDataString(Query));
string maxStr = string.Format("maxRes={0}", (max_maxResults < MaxResults) ? max_maxResults : MaxResults);
string locStr = null;
switch (AutoLocation)
{
case AutosuggestLocationType.userCircularMapView:
locStr = string.Format("ucmv={0}", UserCircularMapView.ToString());
break;
case AutosuggestLocationType.userMapView:
locStr = string.Format("umv={0}", UserMapView.ToString());
break;
case AutosuggestLocationType.userLocation:
if (UserLoc == null)
{
throw new Exception("User Location is Requred");
}
locStr = string.Format("ul={0}", UserLoc.ToString());
break;
}
string inclEntityStr = string.Format("inclenttype={0}", getIncludeEntityTypeString());
string cultureStr = string.Format("c={0}", Culture.ToString());
List <string> param_list = new List <string>
{
queryStr,
locStr,
inclEntityStr,
cultureStr,
maxStr,
string.Format("key={0}", BingMapsKey)
};
if (CountryFilter != null)
{
string country_filterStr = string.Format("cf={0}", CountryFilter.ToString());
param_list.Add(country_filterStr);
}
return(Domain + "Autosuggest?" + string.Join("&", param_list));
}
private PageViewModel <CountryShortViewModel> GetBeachToursPage(int skip = 0, int take = int.MaxValue)
{
var countryFilter = new CountryFilter(skip, take)
{
TourType = TourTypesEnum.Beach
};
var countriesPage = _countryManager.GetCountriesPage(countryFilter);
var result = GetCountriesPageViewModel(countriesPage);
return(result);
}
private IQueryable <Country> SetFilter(IQueryable <Country> q, CountryFilter f)
{
if (f == null)
{
return(q);
}
if (!String.IsNullOrEmpty(f.searchString))
{
q = q.Where(s => s.Name.Contains(f.searchString));
}
return(q);
}
public async Task <GetResult <Country> > GetByFilterAsync(CountryFilter filter)
{
try
{
var result = await _repository.GetByFilterAsync(filter);
return(result.ToBLLResult());
}
catch (Exception ex)
{
Logger.Error(ex);
return(new GetResult <Country>(ex));
};
}
public async Task <ProcessResult <int> > CountAsync(CountryFilter filter)
{
IQueryable <Country> q = context.Countries;
q = SetFilter(q, filter);
Func <Task <int> > action = async() =>
{
var countItems = await q.CountAsync();
return(countItems);
};
return(await Process.RunAsync(action));
}
public async Task <IActionResult> Count(CountryFilter filter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _CountryService.CountAsync(filter);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
return(Ok(result));
}
public void Initialise(System.Web.UI.Page p)
{
string z = p.Request["__EVENTTARGET"] ?? "";
if (z == "date")
{
UpdateView();
}
if (p.IsPostBack)
{
return;
}
CountryFilter.bind();
EndDateFilter.Text = DateTime.Now.ToShortDateString();
StartDateFilterModel.Text = DateTime.Now.AddDays(-6).ToShortDateString();
UpdateView();
}
public async Task<IActionResult> Lookup(string continentId)
{
try
{
var filter = new CountryFilter();
filter.ContinentId = continentId;
var result = await _service.GetByFilterAsync(filter);
if(result.Status == BusinessOperationStatus.Failure)
{
return Exception(result);
}
return Ok(result.Entities);
}
catch(Exception ex)
{
Logger.Error(ex);
return Exception(ex);
}
}
public async Task <BasePageList <CountryResult> > GetAsync(CountryFilter filter)
{
return(await _countryRepository.GetAsync(filter));
}
public async Task <Result <AffiliateManageModel> > GetAffiliate(string id)
{
int idAffiliate = 0;
if (id != null && !Int32.TryParse(id, out idAffiliate))
{
throw new NotFoundException();
}
if (idAffiliate == 0)
{
var now = DateTime.Now;
now = new DateTime(now.Year, now.Month, now.Day);
var defaultCountry = _referenceData.DefaultCountry;
return(new AffiliateManageModel()
{
StatusCode = RecordStatusCode.NotActive,
IdCountry = defaultCountry?.Id,
PaymentType = AffiliateConstants.DefaultPaymentType, //Credit
Tier = AffiliateConstants.DefaultTier,
CommissionFirst = AffiliateConstants.DefaultCommissionFirst,
CommissionAll = AffiliateConstants.DefaultCommissionAll,
});
}
var item = await _affiliateService.SelectAsync(idAffiliate);
if (item == null)
{
throw new NotFoundException();
}
AffiliateManageModel toReturn = await _mapper.ToModelAsync <AffiliateManageModel>(item);
var login = await _affiliateUserService.GetAsync(toReturn.Id);
if (login == null)
{
throw new AppValidationException(ErrorMessagesLibrary.Data[ErrorMessagesLibrary.Keys.CantFindLogin]);
}
toReturn.IsConfirmed = login.IsConfirmed;
toReturn.PublicUserId = login.PublicId;
CountryFilter filter = new CountryFilter();
var countries = await _countryService.GetCountriesAsync(filter);
var country = countries.FirstOrDefault(p => p.Id == toReturn.IdCountry);
if (country != null)
{
toReturn.CountryCode = country.CountryCode;
var state = country.States.FirstOrDefault(p => p.Id == toReturn.IdState);
if (state != null)
{
toReturn.StateCode = state.StateCode;
}
}
return(toReturn);
}
public IActionResult Search(CountryFilter filter)
{
SearchFilterHelpers.SetSearchFilter(this, filter);
return(RedirectToAction("List"));
}
private async void FilterData(object obj)
{
Window mainWindow = (Window)obj;
List <Specification <People> > SpecList = new List <Specification <People> >();
CheckBox DateCheck = mainWindow.FindName("FilterByDateCheck") as CheckBox;
CheckBox NameCheck = mainWindow.FindName("FilterByNameCheck") as CheckBox;
CheckBox LNameCheck = mainWindow.FindName("FilterByLastNameCheck") as CheckBox;
CheckBox SNameCheck = mainWindow.FindName("FilterBySurNameCheck") as CheckBox;
CheckBox CityCheck = mainWindow.FindName("FilterByCityCheck") as CheckBox;
CheckBox CountryCheck = mainWindow.FindName("FilterByCountryCheck") as CheckBox;
if (DateCheck.IsChecked == true)
{
if (DateFilter == null || DateFilter.Replace(" ", "").Length == 0)
{
EmptyFieldMessage(mainWindow, "DateFilter");
}
else
{
SpecList.Add(new FindByDateSpecification(DateTime.Parse(DateFilter)));
}
}
if (NameCheck.IsChecked == true)
{
if (NameFilter == null || NameFilter.Replace(" ", "").Length == 0)
{
EmptyFieldMessage(mainWindow, "NameFilter");
}
else
{
SpecList.Add(new FindByNameSpecification(NameFilter));
}
}
if (LNameCheck.IsChecked == true)
{
if (LastNameFilter == null || LastNameFilter.Replace(" ", "").Length == 0)
{
EmptyFieldMessage(mainWindow, "LastNameFilter");
}
else
{
SpecList.Add(new FindByLastNameSpecification(LastNameFilter));
}
}
if (SNameCheck.IsChecked == true)
{
if (SurNameFilter == null || SurNameFilter.Replace(" ", "").Length == 0)
{
EmptyFieldMessage(mainWindow, "SurNameFilter");
}
else
{
SpecList.Add(new FindBySurNameSpecification(SurNameFilter));
}
}
if (CityCheck.IsChecked == true)
{
if (CityFilter == null || CityFilter.Replace(" ", "").Length == 0)
{
EmptyFieldMessage(mainWindow, "CityFilter");
}
else
{
SpecList.Add(new FindByCitySpecification(CityFilter));
}
}
if (CountryCheck.IsChecked == true)
{
if (CountryFilter == null || CountryFilter.Replace(" ", "").Length == 0)
{
EmptyFieldMessage(mainWindow, "CountryFilter");
}
else
{
SpecList.Add(new FindByCountrySpecification(CountryFilter));
}
}
if (SpecList.Count > 0)
{
Specification <People> specification = SpecList[0];
SpecList.RemoveAt(0);
foreach (var spec in SpecList)
{
specification.And(spec);
}
using (IRepository <People> Repository = new PeopleRepository())
PeopleCollection = await Repository.Find(specification);
}
else
{
using (IRepository <People> Repository = new PeopleRepository())
PeopleCollection = await Repository.GetObjectsList();
}
}
public CountryAdapter(List <Country> countries)
{
this.countries = countries ?? new List <Country>();
sectionLetterCountries = GetSectionLetterCountriesList(this.countries);
Filter = new CountryFilter(this);
}
