private IQueryable <ItemType> GetBestSearch(string pStrText, FilterEnum pEnmFilter, IQueryable <ItemType> pLstObjItemTypes)
{
IList <IQueryable <ItemType> > lLstObjQueries = new List <IQueryable <ItemType> >();
lLstObjQueries.Add(pLstObjItemTypes.Where(x => x.Code.ToUpper().Contains(pStrText.ToUpper())));
lLstObjQueries.Add(pLstObjItemTypes.Where(x => x.Name.ToUpper().Contains(pStrText.ToUpper())));
lLstObjQueries.Add(pLstObjItemTypes.Where(x => x.Code.ToUpper().StartsWith(pStrText.ToUpper())));
lLstObjQueries.Add(pLstObjItemTypes.Where(x => x.Name.ToUpper().StartsWith(pStrText.ToUpper())));
lLstObjQueries.Add(pLstObjItemTypes.Where(x => x.Code.ToUpper().EndsWith(pStrText.ToUpper())));
lLstObjQueries.Add(pLstObjItemTypes.Where(x => x.Name.ToUpper().EndsWith(pStrText.ToUpper())));
IQueryable <ItemType> lLstObjBestQuery = pLstObjItemTypes;
int lIntBestRowCount = pLstObjItemTypes.Count();
for (int i = 0; i < lLstObjQueries.Count; i++)
{
int lIntCurrentRowCount = lLstObjQueries[i].Count();
if (lIntCurrentRowCount > 0 && lIntCurrentRowCount < lIntBestRowCount)
{
lLstObjBestQuery = lLstObjQueries[i];
lIntBestRowCount = lIntCurrentRowCount;
}
}
return(lLstObjBestQuery);
}
public List <PartnerClassification> SearchPartner(string pStrText, FilterEnum pEnmFilter)
{
IList <IQueryable <PartnerClassification> > lLstObjQueries = new List <IQueryable <PartnerClassification> >();
IQueryable <PartnerClassification> lLstObjClassifications = this.GetList().Where(x =>
(
pEnmFilter == FilterEnum.ACTIVE ? x.Active && x.Customer.PartnerStatus == PartnerStatusEnum.ACTIVE :
pEnmFilter == FilterEnum.INACTIVE ? !x.Active && x.Customer.PartnerStatus == PartnerStatusEnum.INACTIVE : true
));
lLstObjQueries.Add(lLstObjClassifications.Where(x => x.Number.ToString().Equals(pStrText)));
lLstObjQueries.Add(lLstObjClassifications.Where(x => x.Customer.Code.ToUpper().Contains(pStrText.ToUpper())));
lLstObjQueries.Add(lLstObjClassifications.Where(x => x.Customer.Name.ToUpper().Contains(pStrText.ToUpper())));
lLstObjQueries.Add(lLstObjClassifications.Where(x => x.Customer.Code.ToUpper().Equals(pStrText.ToUpper())));
lLstObjQueries.Add(lLstObjClassifications.Where(x => x.Customer.Name.ToUpper().Equals(pStrText.ToUpper())));
IQueryable <PartnerClassification> lLstObjBetterQuery = lLstObjClassifications;
int lIntBetterRowCount = lLstObjClassifications.Count();
for (int i = 0; i < lLstObjQueries.Count; i++)
{
int lIntCurrentRowCount = lLstObjQueries[i].Count();
if (lIntCurrentRowCount > 0 && lIntCurrentRowCount < lIntBetterRowCount)
{
lLstObjBetterQuery = lLstObjQueries[i];
lIntBetterRowCount = lIntCurrentRowCount;
}
}
return(lLstObjBetterQuery.ToList());
}
public void FilterEnum_Passes_Returns_Correct_Results()
{
foreach (FilterCondition condition in Enum.GetValues(typeof(FilterCondition)))
{
foreach (var reverseCondition in new bool[] { false, true })
{
foreach (MyEnum value in Enum.GetValues(typeof(MyEnum)))
{
foreach (var testValue in new MyEnum?[] { null, MyEnum.Value1, MyEnum.Value2 })
{
var filter = new FilterEnum <MyEnum>()
{
Condition = condition,
ReverseCondition = reverseCondition,
Value = value
};
var result = filter.Passes(testValue);
var expectedResult = true;
if (condition == FilterCondition.Equals)
{
expectedResult = testValue == null ? false : value == testValue;
if (reverseCondition)
{
expectedResult = !expectedResult;
}
}
Assert.AreEqual(expectedResult, result, "{0}/{1}/{2}/{3}", condition, reverseCondition, value, testValue);
}
}
}
}
}
private void AddToImage(PixelSample samp, Spectrum l, Scene s, FilterEnum filter = FilterEnum.Box)
{
Spectrum xyzOrRgb = l;
double pixelWeight = 1;
double px = samp.X - (samp.I + 0.5);
double py = samp.Y - (samp.J + 0.5);
switch (filter)
{
case FilterEnum.Triangle:
pixelWeight = Math.Max(0, 1 - Math.Abs(px)) * Math.Max(0, 1 - Math.Abs(py));
break;
}
lock (finalImageSum)
{
if (finalImageSum[samp.I, samp.J] == null)
{
finalImageSum[samp.I, samp.J] = xyzOrRgb * pixelWeight;
}
else
{
finalImageSum[samp.I, samp.J].AddTo(xyzOrRgb * pixelWeight);
}
pixelWeights[samp.I, samp.J] += pixelWeight;
finalImage[samp.I, samp.J] = finalImageSum[samp.I, samp.J] * (1 / pixelWeights[samp.I, samp.J]);
totalSamples++;
}
}
public List <Partner> SearchPartnerWithStock(string pStrPartner, FilterEnum pEnmFilter, List <long> plstCustomersWithStock)
{
IList <IQueryable <Partner> > lLstObjQueries = new List <IQueryable <Partner> >();
IQueryable <Partner> lLstObjPartners = this.GetList().Where(x =>
(
pEnmFilter == FilterEnum.ACTIVE ? x.Active && x.PartnerStatus == PartnerStatusEnum.ACTIVE :
pEnmFilter == FilterEnum.INACTIVE ? !x.Active && x.PartnerStatus == PartnerStatusEnum.INACTIVE : true
) &&
plstCustomersWithStock.Contains(x.Id)
);
lLstObjQueries.Add(lLstObjPartners.Where(x => x.Code.ToUpper().Contains(pStrPartner.ToUpper())));
lLstObjQueries.Add(lLstObjPartners.Where(x => x.Name.ToUpper().Contains(pStrPartner.ToUpper())));
lLstObjQueries.Add(lLstObjPartners.Where(x => x.Code.ToUpper().Equals(pStrPartner.ToUpper())));
lLstObjQueries.Add(lLstObjPartners.Where(x => x.Name.ToUpper().Equals(pStrPartner.ToUpper())));
lLstObjQueries.Add(lLstObjPartners.Where(x => (!string.IsNullOrEmpty(pStrPartner) ? x.ForeignName.ToUpper().Equals(pStrPartner.ToUpper()) : x.ForeignName == x.ForeignName)));
IQueryable <Partner> lLstObjBetterQuery = lLstObjPartners;
int lIntBetterRowCount = lLstObjPartners.Count();
for (int i = 0; i < lLstObjQueries.Count; i++)
{
int lIntCurrentRowCount = lLstObjQueries[i].Count();
if (lIntCurrentRowCount > 0 && lIntCurrentRowCount < lIntBetterRowCount)
{
lLstObjBetterQuery = lLstObjQueries[i];
lIntBetterRowCount = lIntCurrentRowCount;
}
}
return(lLstObjBetterQuery.ToList());
}
/// <summary>
/// Decodes an enum filter's value and condition.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <param name="value"></param>
/// <returns></returns>
protected FilterEnum <T> DecodeEnumFilter <T>(string name, string value)
where T : struct, IComparable
{
var result = new FilterEnum <T>();
DecodeFilter(result, name);
var decoded = false;
if (!String.IsNullOrEmpty(value))
{
var number = QueryNInt(value);
if (number != null && Enum.IsDefined(typeof(T), number))
{
result.Value = (T)((object)number.Value);
decoded = true;
}
}
if (!decoded)
{
result = null;
}
return(result);
}
/// <summary>
/// Buscar los articulos
/// </summary>
public List <Item> SearchItem(string pStrItem, FilterEnum pEnmFilter)
{
IList <IQueryable <Item> > lLstObjQueries = new List <IQueryable <Item> >();
IQueryable <Item> lLstObjItems = this.GetList().Where(x =>
(
pEnmFilter == FilterEnum.ACTIVE ? x.Active && x.ItemStatus == ItemStatusEnum.ACTIVE :
pEnmFilter == FilterEnum.INACTIVE ? !x.Active && x.ItemStatus == ItemStatusEnum.INACTIVE : true
));
lLstObjQueries.Add(lLstObjItems.Where(x => x.Code.ToUpper().Contains(pStrItem.ToUpper())));
lLstObjQueries.Add(lLstObjItems.Where(x => x.Name.ToUpper().Contains(pStrItem.ToUpper())));
lLstObjQueries.Add(lLstObjItems.Where(x => x.Code.ToUpper().Equals(pStrItem.ToUpper())));
lLstObjQueries.Add(lLstObjItems.Where(x => x.Name.ToUpper().Equals(pStrItem.ToUpper())));
IQueryable <Item> lLstObjBestQuery = lLstObjItems;
int lIntBestRowCount = lLstObjItems.Count();
for (int i = 0; i < lLstObjQueries.Count; i++)
{
int lIntCurrentRowCount = lLstObjQueries[i].Count();
if (lIntCurrentRowCount > 0 && lIntCurrentRowCount < lIntBestRowCount)
{
lLstObjBestQuery = lLstObjQueries[i];
lIntBestRowCount = lIntCurrentRowCount;
}
}
return(lLstObjBestQuery.ToList());
}
private void AddFilterItem(FilterEnum filter, double?filterValue = null)
{
var selectedfilterItem = selectedFilters.FirstOrDefault(x => x.Filter == filter);
if (selectedfilterItem == null)
{
var filterItem = filters.FirstOrDefault(x => x.Filter == filter);
if (filterItem != null)
{
var selectedFilterItem = filterItem.Clone();
if (filterValue.HasValue)
{
selectedFilterItem.Value = filterValue;
}
selectedFilters.Add(selectedFilterItem);
}
}
else if (filterValue != null)
{
selectedfilterItem.Value = filterValue;
}
}
public bool Equals(FilterEnum obj)
{
if ((object)obj == null)
{
return(false);
}
return(StringComparer.OrdinalIgnoreCase.Equals(this.Value, obj.Value));
}
public static DateRange GetDateRange(FilterEnum selection)
{
DateRange dateRange = new DateRange();
switch (selection)
{
case FilterEnum.Today:
var today = DateTime.Today;
dateRange.Start = today;
dateRange.End = today;
break;
case FilterEnum.Yesterday:
var yesterday = DateTime.Today.AddDays(-1);
dateRange.Start = yesterday;
dateRange.End = yesterday;
break;
case FilterEnum.ThreeDays:
var threedaySpan = DateTime.Today.AddDays(-3);
dateRange.Start = threedaySpan;
dateRange.End = DateTime.Today;
break;
case FilterEnum.OneWeek:
var oneWeekOffset = DateTime.Today.AddDays(-7);
dateRange.Start = oneWeekOffset;
dateRange.End = DateTime.Today;
break;
case FilterEnum.TwoWeeks:
var twoWeeksOffset = DateTime.Today.AddDays(-14);
dateRange.Start = twoWeeksOffset;
dateRange.End = DateTime.Today;
break;
case FilterEnum.OneMonth:
var oneMonthOffset = DateTime.Today.AddMonths(-1);
dateRange.Start = oneMonthOffset;
dateRange.End = DateTime.Today;
break;
case FilterEnum.ThreeMonths:
var threeMonthsOffset = DateTime.Today.AddMonths(-3);
dateRange.Start = threeMonthsOffset;
dateRange.End = DateTime.Today;
break;
case FilterEnum.OneYear:
var oneYearOffset = DateTime.Today.AddYears(-1);
dateRange.Start = oneYearOffset;
dateRange.End = DateTime.Today;
break;
}
return(dateRange);
}
private static FilterObject Create(NoteStageType stage, string name, FilterEnum filter)
{
return(new FilterObject
{
Description = name,
Stage = stage,
Filter = filter
});
}
private void RemoveFilterItem(FilterEnum filter)
{
var selectedfilterItem = selectedFilters.FirstOrDefault(x => x.Filter == filter);
if (selectedfilterItem != null)
{
selectedFilters.Remove(selectedfilterItem);
}
}
private IQueryable <Auction> GetAuctionByFilter(FilterEnum pEnmFilter)
{
string lStrCostingCode = GetCostingCode();
return(this.GetListFilteredByCC().Where(x =>// x.Active &&
x.CostingCode == lStrCostingCode &&
(
pEnmFilter == FilterEnum.OPENED ? x.Opened :
pEnmFilter == FilterEnum.CLOSED ? !x.Opened : true
)));
}
public void FilterEnum_Constructor_Initialises_To_Known_State_And_Properties_Work()
{
var filter = new FilterEnum <MyEnum>();
TestUtilities.TestProperty(filter, r => r.Condition, FilterCondition.Invalid, FilterCondition.Equals);
TestUtilities.TestProperty(filter, r => r.ReverseCondition, false);
TestUtilities.TestProperty(filter, r => r.Value, default(MyEnum), MyEnum.Value2);
filter = new FilterEnum <MyEnum>(MyEnum.Value2);
TestUtilities.TestProperty(filter, r => r.Condition, FilterCondition.Equals, FilterCondition.Contains);
TestUtilities.TestProperty(filter, r => r.ReverseCondition, false);
TestUtilities.TestProperty(filter, r => r.Value, MyEnum.Value2, MyEnum.Value1);
}
//public List<Auction> SearchAuctions(string pStrAuction, FilterEnum pEnmFilter)
//{
// return GetBestAuctionSearch(pStrAuction, GetAuctionByFilter(pEnmFilter).Where(x => x.Category == AuctionCategoryEnum.AUCTION));
//}
//public List<Auction> SearchDirectTradeAndSheep(string pStrAuction, FilterEnum pEnmFilter)
//{
// return GetBestAuctionSearch(pStrAuction, GetAuctionByFilter(pEnmFilter).Where(x => x.Category == AuctionCategoryEnum.DIRECT_TRADE || x.Category == AuctionCategoryEnum.SHEEP));
//}
//public List<Auction> SearchDirectTrade(string pStrAuction, FilterEnum pEnmFilter)
//{
// return GetBestAuctionSearch(pStrAuction, GetAuctionByFilter(pEnmFilter).Where(x => x.Category == AuctionCategoryEnum.DIRECT_TRADE));
//}
//public List<Auction> SearchSheep(string pStrAuction, FilterEnum pEnmFilter)
//{
// return GetBestAuctionSearch(pStrAuction, GetAuctionByFilter(pEnmFilter).Where(x => x.Category == AuctionCategoryEnum.SHEEP));
//}
public List <Auction> SearchAuctions(string pStrAuction, FilterEnum pEnmFilter, AuctionSearchModeEnum pEnmSearchMode = 0)
{
return(GetBestAuctionSearch
(
pStrAuction,
GetAuctionByFilter(pEnmFilter).Where(x => pEnmSearchMode != 0 ?
(
pEnmSearchMode == AuctionSearchModeEnum.AUCTION ?
x.Category == AuctionCategoryEnum.AUCTION :
pEnmSearchMode == AuctionSearchModeEnum.DIRECT_TRADE ?
x.Category == AuctionCategoryEnum.DIRECT_TRADE : true
) : true)
));
}
private AircraftListJsonBuilderFilter DecodeEnumFilter<T>(string prefix, string key, string value, AircraftListJsonBuilderFilter result, Action<AircraftListJsonBuilderFilter, FilterEnum<T>> assignFilter)
where T: struct, IComparable
{
if(!String.IsNullOrEmpty(value) && Enum.TryParse<T>(value, out T enumValue)) {
if(Enum.IsDefined(typeof(T), enumValue)) {
var filter = new FilterEnum<T>() {
Value = enumValue,
};
if(DecodeFilter(prefix, filter, key) == 'Q') {
DoAssignFilter(ref result, assignFilter, filter);
}
}
}
return result;
}
public static string Format(this FilterEnum filter)
{
switch (filter)
{
case FilterEnum.Include:
return("include");
case FilterEnum.Exclude:
return("exclude");
case FilterEnum.Only:
return("only");
default:
throw new ArgumentException(nameof(filter));
}
}
/// <summary>
/// Возвращает список записей со стены пользователя или сообщества
/// </summary>
/// <param name="ownerId">
/// Идентификатор пользователя или сообщества, со стены которого необходимо получить записи (по
/// умолчанию — текущий пользователь). Идентификатор сообщества необходимо указывать со знаком "-"
/// </param>
/// <param name="domain">Короткий адрес пользователя или сообщества</param>
/// <param name="offset">Смещение, необходимое для выборки определенного подмножества записей</param>
/// <param name="count">Количество записей, которое необходимо получить (но не более 100)</param>
/// <param name="filter">Определяет, какие типы записей на стене необходимо получить</param>
/// <returns>Список записей со стены</returns>
public static VKList<VKPost> Get(
Int64? ownerId = null,
String domain = "",
Int32? offset = null,
Int32? count = null,
FilterEnum? filter = null
)
{
VKParams param = parseGetParam(ownerId, domain, offset, count, filter, false);
string response = VKSession.Instance.DoRequest("wall.get", param);
JObject obj = JObject.Parse(response);
VKList<VKPost> objArr =
JsonConvert.DeserializeObject<VKList<VKPost>>((obj["response"] ?? String.Empty).ToString());
return objArr;
}
public static List <Sale> LoadAll(FilterEnum state, String searchWord, Boolean includeCanceled)
{
IQueryable <Sale> result = MyDataContext.Default.Sales
.Include(runner => runner.SaleItems)
.Include(runner => runner.SaleItems.Select(r => r.Article))
.Where(runner =>
(state == FilterEnum.All) ||
(state == FilterEnum.NotMailed && (runner.MailingId == null || !runner.Mailing.DateOfShipping.HasValue)) ||
(state == FilterEnum.NotPaied && runner.DateOfPayment == null) ||
(state == FilterEnum.NotPaidNotMailed && (runner.DateOfPayment == null || runner.MailingId == null)))
.Where(runner => includeCanceled || (!runner.Canceled.HasValue && (!(runner.SaleItems.All(c => c.CancelDate.HasValue)) || runner.SaleItems.Count == 0)))
.OrderBy(runner => runner.DateOfSale)
.ThenByDescending(current => current.DateOfPayment);
Boolean mustSearch = !String.IsNullOrWhiteSpace(searchWord) && searchWord != "*";
if (mustSearch)
{
result = result
.Where(current =>
current.InvoiceStreet1.ToLower().Contains(searchWord) ||
current.InvoiceStreet2.ToLower().Contains(searchWord) ||
current.InvoiceCity.ToLower().Contains(searchWord) ||
current.InvoiceCountry.ToLower().Contains(searchWord) ||
current.InvoicePostcode.ToLower().Contains(searchWord) ||
current.InvoiceRegion.ToLower().Contains(searchWord) ||
current.ShippingStreet1.ToLower().Contains(searchWord) ||
current.ShippingStreet2.ToLower().Contains(searchWord) ||
current.ShippingCity.ToLower().Contains(searchWord) ||
current.ShippingCountry.ToLower().Contains(searchWord) ||
current.ShippingPostcode.ToLower().Contains(searchWord) ||
current.ShippingRegion.ToLower().Contains(searchWord) ||
current.EbayName.ToLower().Contains(searchWord) ||
current.EMailAddress.ToLower().Contains(searchWord) ||
current.SourceId.ToLower().Contains(searchWord) ||
current.NameOfBuyer.ToLower().Contains(searchWord) ||
current.PhoneNumber.ToLower().Contains(searchWord) ||
current.SaleItems.Any(c2 => c2.ExternalArticleName.Contains(searchWord)) ||
current.SaleItems.Any(c2 => c2.ExternalArticleNumber.Contains(searchWord)) ||
current.SaleItems.Any(c2 => c2.InternalArticleNumber.Contains(searchWord)))
.OrderBy(runner => runner.DateOfSale)
.ThenByDescending(runner => runner.DateOfPayment);
}
return(result.ToList());
}
public static FilterEnum GetFilterEnum(string filterLabel)
{
if (Char.IsDigit(filterLabel[0]))
{
var number = Convert.ToInt32(filterLabel[0].ToString());
var numberInLabel = GetWrittenformat(number);
string Label = numberInLabel + filterLabel.Substring(2).First().ToString().ToUpper() + filterLabel.Substring(3);
FilterEnum filter = (FilterEnum)Enum.Parse(typeof(FilterEnum), Label);
return(filter);
}
else
{
FilterEnum filter = (FilterEnum)Enum.Parse(typeof(FilterEnum), filterLabel);
return(filter);
}
}
private static VKParams parseGetParam(
Int64? ownerId,
String domain,
Int32? offset,
Int32? count,
FilterEnum? filter,
Boolean extended
)
{
VKParams param = new VKParams();
if (ownerId.HasValue) param.Add("owner_id", ownerId.Value);
if (!String.IsNullOrWhiteSpace(domain)) param.Add("domain", domain);
if (offset.HasValue) param.Add("offset", offset.Value);
if (count.HasValue) param.Add("count", count.Value);
if (filter.HasValue) param.Add("filter", filter.Value);
param.Add("extended", extended ? "1" : "0");
return param;
}
/// <responseCode>200 Ok</responseCode>
public async Task <Response <Right <IEnumerable <GenesisAddress> > > > GetAddressInfoAsync(
uint page,
uint pageSize,
FilterEnum filter)
{
var path = new StringBuilder(HttpHelper.UrlCombine(
PathConstants.Api,
PathConstants.Genesis,
PathConstants.Address));
var queryParams = new Dictionary <string, object>();
queryParams.Add(nameof(page), page);
queryParams.Add(nameof(pageSize), pageSize);
queryParams.Add(nameof(filter), filter.GetValue());
path.Append(queryParams.ToQueryString());
return(await GetRequest.GetAsync <Right <IEnumerable <GenesisAddress> > >(path.ToString()));
}
public async Task <IEnumerable <VacationDto> > FilterVacations(FilterEnum type)
{
var vacations = await _vacationRepository.GetAsync <Vacation>(UrlName.GetApiUrl());
switch (type)
{
case FilterEnum.Closed:
{
var result = Mapper.Map <IEnumerable <VacationDto> >(vacations.Where(x => x.VacationStatus == VacationStatus.Closed));
return(result);
}
case FilterEnum.Opened:
return(Mapper.Map <IEnumerable <VacationDto> >(vacations.Where(x => x.VacationStatus != VacationStatus.Closed)));
default:
return(Mapper.Map <IEnumerable <VacationDto> >(vacations));
}
}
public UCSearchItemType(string pStrText, List <ItemType> pLstObjItemTypes, FilterEnum pEnmFilter)
{
InitializeComponent();
mObjInventoryServicesFactory = new InventoryServicesFactory();
if (!string.IsNullOrEmpty(pStrText))
{
txtSearch.Text = pStrText;
txtSearch.Focus();
}
else
{
dgDataGrid.Focus();
}
mLcvListData = new ListCollectionView(pLstObjItemTypes);
dgDataGrid.ItemsSource = null;
dgDataGrid.ItemsSource = mLcvListData;
mEnmFilter = pEnmFilter;
}
public UCSearchBusinessPartner(string pStrText, List <Partner> pLstObjPartners, FilterEnum pEnmFilter)
{
InitializeComponent();
mObjBusinessServicesFactory = new BusinessServicesFactory();
if (!string.IsNullOrEmpty(pStrText))
{
txtSearch.Text = pStrText;
txtSearch.Focus();
}
else
{
dgDataGrid.Focus();
}
mLcvListData = new ListCollectionView(pLstObjPartners);
dgDataGrid.ItemsSource = null;
dgDataGrid.ItemsSource = mLcvListData;
mEnmFilter = pEnmFilter;
}
/// <summary></summary>
/// <param name="filters"></param>
/// <param name="filter"></param>
/// <returns>EcnomicApi.Economic.Objects.CollectionOfProduct</returns>
public CollectionOfProduct Find(FilterPart[] filters, FilterEnum filter)
{
if (filters == null)
{
throw new ArgumentNullException();
}
string query = Helpers.CollectFilters(filters, filter);
string url = Client.GetUrl("/products/?filter=" + query);
try
{
var response = JsonClient.Get <CollectionOfProduct>(url, Client.GetHeaders());
return(response);
}
catch
{
throw;
}
}
public UCSearchAuction(string pStrText, List<Auction> pLstObjAuctions, FilterEnum pEnmFilter, AuctionSearchModeEnum pEnmSearchMode)
{
InitializeComponent();
mObjAuctionServiceFactory = new AuctionsServicesFactory();
if (!string.IsNullOrEmpty(pStrText))
{
txtSearch.Text = pStrText;
txtSearch.Focus();
}
else
{
dgDataGrid.Focus();
}
mLcvListData = new ListCollectionView(pLstObjAuctions);
dgDataGrid.ItemsSource = null;
dgDataGrid.ItemsSource = mLcvListData;
mEnmFilter = pEnmFilter;
mEnmSearchMode = pEnmSearchMode;
}
public static string ToString(this FilterEnum filterEnum)
{
switch (filterEnum)
{
case FilterEnum.Nashville:
return("nashville");
case FilterEnum.Clarendon:
return("clarendon");
case FilterEnum.Moon:
return("moon");
case FilterEnum.Toaster:
return("toaster");
case FilterEnum.XPro2:
return("xpro2");
default:
throw new ArgumentOutOfRangeException(nameof(filterEnum), filterEnum, null);
}
}
public IActionResult GetMails(int page, SortingEnum sorting, FilterEnum filter, string filterPhrase)
{
int userID = int.Parse(User.Claims.First(x => x.Type == ClaimTypes.NameIdentifier).Value);
return(new JsonResult(_mailService.GetUserMails(userID, page, sorting, filter, filterPhrase)));
}
internal IPAddressCollection(IPNetwork ipnetwork, FilterEnum filter)
{
this._ipnetwork = ipnetwork;
this._filter = filter;
Reset();
}
public PagingMailInboxView GetUserMails(int userID, int page, SortingEnum sorting, FilterEnum filter, string filterPhrase)
{
filterPhrase ??= "";
bool firstPage = (page == 1);
var userMails = _context.UserMails
.Include(x => x.Mail)
.ThenInclude(x => x.Sender)
.Where(x => x.UserID == userID).AsQueryable();
switch (filter)
{
case FilterEnum.FilterTopic:
userMails = userMails.Where(x => x.Mail.Topic.StartsWith(filterPhrase)).AsQueryable();
break;
case FilterEnum.FilterSenderName:
userMails = userMails.Where(x => x.Mail.Sender.FirstName.StartsWith(filterPhrase)).AsQueryable();
break;
case FilterEnum.FilterSenderSurname:
userMails = userMails.Where(x => x.Mail.Sender.LastName.StartsWith(filterPhrase)).AsQueryable();
break;
}
switch (sorting)
{
case SortingEnum.ByDateFromNewest:
userMails = userMails.OrderByDescending(x => x.Mail.Date);
break;
case SortingEnum.ByDateFromOldest:
userMails = userMails.OrderBy(x => x.Mail.Date);
break;
case SortingEnum.BySenderAZ:
userMails = userMails.OrderBy(x => x.Mail.Sender.FirstName).ThenBy(x => x.Mail.Sender.LastName).ThenByDescending(x => x.Mail.Date);
break;
case SortingEnum.BySenderZA:
userMails = userMails.OrderByDescending(x => x.Mail.Sender.FirstName).ThenByDescending(x => x.Mail.Sender.LastName).ThenByDescending(x => x.Mail.Date);
break;
case SortingEnum.ByTopicAZ:
userMails = userMails.OrderBy(x => x.Mail.Topic).ThenByDescending(x => x.Mail.Date);
break;
case SortingEnum.ByTopicZA:
userMails = userMails.OrderByDescending(x => x.Mail.Topic).ThenByDescending(x => x.Mail.Date);
break;
}
bool lastPage = (userMails.Count() <= 5 * page);
userMails = userMails.Skip((page - 1) * 5).Take(5);
List <MailInboxView> mails = new List <MailInboxView>();
foreach (var um in userMails)
{
MailInboxView miv = new MailInboxView
{
MailID = um.MailID,
Read = um.Read,
Sender = new UserGlobalView
{
Name = um.Mail.Sender.FirstName,
Surname = um.Mail.Sender.LastName,
Address = um.Mail.Sender.Email
},
Topic = um.Mail.Topic,
Date = um.Mail.Date,
};
mails.Add(miv);
}
return(new PagingMailInboxView {
Mails = mails, FirstPage = firstPage, LastPage = lastPage
});
}
/// <summary>
/// Возвращает список записей со стены пользователя или сообщества
/// </summary>
/// <param name="ownerId">
/// Идентификатор пользователя или сообщества, со стены которого необходимо получить записи (по
/// умолчанию — текущий пользователь). Идентификатор сообщества необходимо указывать со знаком "-"
/// </param>
/// <param name="domain">Короткий адрес пользователя или сообщества</param>
/// <param name="offset">Смещение, необходимое для выборки определенного подмножества записей</param>
/// <param name="count">Количество записей, которое необходимо получить (но не более 100)</param>
/// <param name="filter">Определяет, какие типы записей на стене необходимо получить</param>
/// <param name="token">Токен для отмены выполнения запроса</param>
/// <returns>Список записей со стены</returns>
public static async Task<VKList<VKPost>> GetAsync(
Int64? ownerId = null,
String domain = "",
Int32? offset = null,
Int32? count = null,
FilterEnum? filter = null,
CancellationToken? token = null
)
{
VKParams param = parseGetParam(ownerId, domain, offset, count, filter, false);
string response = await VKSession.Instance.DoRequestAsync("wall.get", param);
JObject obj = JObject.Parse(response);
VKList<VKPost> objArr =
await JsonConvert.DeserializeObjectAsync<VKList<VKPost>>((obj["response"] ?? String.Empty).ToString());
if (token.HasValue) token.Value.ThrowIfCancellationRequested();
return objArr;
}
public FilterAttribute(FilterEnum filter, bool disableCodeGenerationOnService)
{
Filter = filter;
DisableCodeGenerationOnService = disableCodeGenerationOnService;
}
