private static bool SetMatches(CardSet set, string name, SearchTypes searchTypes, bool caseSensitive = false)
{
var setName = caseSensitive
? set.Name
: set.Name.ToLower();
var promptName = caseSensitive
? name
: name.ToLower();
switch (searchTypes)
{
case SearchTypes.StartsWith:
return setName.StartsWith(promptName);
case SearchTypes.EndsWith:
return setName.EndsWith(promptName);
case SearchTypes.Equals:
return setName == promptName;
case SearchTypes.Contains:
default:
return setName.Contains(promptName);
}
}
/// <summary>
/// Holds search criteria for scheduling log searches
/// </summary>
/// <param name="player"></param>
/// <param name="gamelogtype"></param>
/// <param name="timefrom"></param>
/// <param name="timeto"></param>
/// <param name="searchkey">null or empty string to indicate this requires no match search</param>
/// <param name="searchtype"></param>
internal SearchData(string player, GameLogTypes gamelogtype, DateTime timefrom, DateTime timeto, string searchkey, SearchTypes searchtype)
{
this.Player = player;
this.GameLogType = gamelogtype;
this.TimeFrom = timefrom;
this.TimeTo = timeto;
if (searchkey != null) this.SearchKey = searchkey;
else this.SearchKey = "";
this.SearchType = searchtype;
}
private string SearchTypesToString(SearchTypes T)
{
string type = "ssdp:all";
switch (T)
{
case SearchTypes.rootdevice:
type = "upnp:rootdevice";
break;
case SearchTypes.InternetGatewayDevice:
type = "urn:schemas-upnp-org:device:InternetGatewayDevice:1";
break;
case SearchTypes.MediaServer:
type = "urn:schemas-upnp-org:device:MediaServer:1";
break;
case SearchTypes.MediaRenderer:
type = "urn:schemas-upnp-org:device:MediaRenderer:1";
break;
default:
break;
}
return type;
}
public bool HasMultivaluedSearchType()
{
return(GetAllFields().Select(f => f.SearchType).Distinct().Any(st => SearchTypes.First(s => s.Name == st).MultiValued));
}
public static List <string> Split(string line, string delimiter, SearchTypes search, bool trim)
{
return(Split(line, delimiter, search, MatchTypes.WordOnly, STRINGQUOTE, trim));
}
public static Match NextMatch(string line, string pattern, SearchTypes search, MatchTypes validMatch = MatchTypes.WordOnly, string seqdelim = STRINGQUOTE)
{
return(NextMatch(line, pattern, 0, search, validMatch, seqdelim));
}
/// <summary>
/// Set the search criteria
/// </summary>
/// <param name="player">Player name, case sensitive</param>
/// <param name="gamelogtype">Type of the log</param>
/// <param name="timefrom">Begin date boundary</param>
/// <param name="timeto">End date boundary</param>
/// <param name="searchkey">Text to search for, or regex expression for regex search type</param>
/// <param name="searchtype">Search type</param>
/// <param name="PM_recipient">
/// In case this is PM-log search criteria, this should be the PM recipient name.
/// Not supplying this value will result in a general PM search trough all conversations.
/// </param>
public void SetSearchCriteria(string player, GameLogTypes gamelogtype, DateTime timefrom, DateTime timeto, string searchkey, SearchTypes searchtype, string PM_recipient = null)
{
SearchCriteria = new SearchData(player, gamelogtype, timefrom, timeto, searchkey, searchtype);
if (PM_recipient != null) this.SetPM_Player(PM_recipient);
}
public void setSearchType(SearchTypes type)
{
searchType = type;
}
/// <summary>
/// Obtiene el texto de un control.
/// </summary>
/// <param name="searchString">Texto con el que se busca el Elemento.</param>
/// <param name="searchType">Tipo de búsqueda.</param>
/// <returns>Retorna el texto del control.</returns>
public string GetText(string searchString, SearchTypes searchType)
{
return(FindElement(searchString, searchType).GetAttribute("value"));
}
private void button4_Click(object sender, EventArgs e)
{
// Alles weergeven
CurrentSearchType = SearchTypes.DEFAULT;
plot();
}
public void setSession(Session s)
{
this.session = s;
CurrentSearchType = SearchTypes.DEFAULT;
plot();
}
public static string GetNameForSearchType(SearchTypes type)
{
return EnumToNameMap[type];
}
/// <summary>
/// Executes an advanced search using pagination, sorting, filters, facets, and highlighting.
/// </summary>
/// <param name="searchText">The text used for the search. When empty all results are returned.</param>
/// <param name="totalRecords">The returned total number of records in the results</param>
/// <param name="currentPage">The current page of results to return</param>
/// <param name="pageSize">The size of the result set to return (default=20). Maximum is 1000.</param>
/// <param name="filter">
/// A set of comma or semicolon separated field names to searching.
/// Only fields marked with the 'IsSearchable' attribute can be included.
/// The default is empty and all searchable fields will be searched.
/// ///
/// </param>
/// <param name="selectFields"></param>
/// A set of comma or semicolon separated field names to return values for.
/// Default is empty and will return all field values
/// <param name="orderBy">
/// A set of comma or semicolon separated sort terms.
/// Default is empty and will return results sorted by score relevance.
/// For example, OrganisationName, SicName DESC
/// Only fields marked with the 'IsSortable' attribute can be included.
/// </param>
/// <param name="facets">
/// Specifies the facets to query and returns the facet results
/// The default is empty and no facets will be applied.
/// Only fields marked with the 'IsFacetable' attribute can be included.
/// Call by specifing field names as keys in the dictionary.
/// The resulting dictionary for each field returns all possible values and their count for that field.
/// ///
/// </param>
/// <param name="filter">
/// A filter expression using OData syntax (see
/// https://docs.microsoft.com/en-us/rest/api/searchservice/odata-expression-syntax-for-azure-search)
/// The default is empty and no filter will be applied.
/// Only fields marked with the 'IsFilterable' attribute can be included.
/// String comparisons are case sensitive.
/// You can also use the operators '==','!=', '>=', '>', '<=', '<', '&&', '||' which will be automatically replaced with OData counterparts 'EQ','NE', 'GE', 'GT', 'LE', 'LT', 'AND', 'OR'.
/// Special functions also include search.in(myfield, 'a, b, c')
/// /// </param>
/// <param name="highlights">
/// A set of comma or semicolon separated field names used for hit highlights.
/// Only fields marked with the 'IsSearchable' attribute can be included.
/// By default, Azure Search returns up to 5 highlights per field.
/// The limit is configurable per field by appending -
/// <max # of highlights>
/// following the field name.
/// For example, highlight=title-3,description-10 returns up to 3 highlighted hits from the title field and up to
/// 10 hits from the description field. <max # of highlights> must be an integer between 1 and 1000 inclusive.
/// </param>
public async Task <PagedResult <SicCodeSearchModel> > SearchAsync(string searchText,
int currentPage,
SearchTypes searchType,
int pageSize = 20,
string searchFields = null,
string selectFields = null,
string orderBy = null,
Dictionary <string, Dictionary <object, long> > facets = null,
string filter = null,
string highlights = null,
SearchModes searchMode = SearchModes.Any)
{
// Execute search based on query string
var sp = new SearchParameters
{
SearchMode = (SearchMode)searchMode,
Top = pageSize,
Skip = (currentPage - 1) * pageSize,
IncludeTotalResultCount = true,
QueryType = QueryType.Simple
};
//Specify the fields to search
if (!string.IsNullOrWhiteSpace(searchFields))
{
sp.SearchFields = searchFields.SplitI().ToList();
}
//Limit result fields
if (!string.IsNullOrWhiteSpace(selectFields))
{
sp.Select = selectFields.SplitI().ToList();
}
// Define the sort type or order by relevance score
if (!string.IsNullOrWhiteSpace(orderBy) && !orderBy.EqualsI("Relevance", "Relevance desc", "Relevance asc"))
{
sp.OrderBy = orderBy.SplitI().ToList();
}
// Add filtering
sp.Filter = string.IsNullOrWhiteSpace(filter) ? null : filter;
//Add facets
if (facets != null && facets.Count > 0)
{
sp.Facets = facets.Keys.ToList();
}
//Execute the search
var searchIndexClient = await _searchIndexClient.Value;
var results = searchIndexClient.Documents.Search <SicCodeSearchModel>(searchText, sp);
//Return the total records
var totalRecords = results.Count.Value;
/* There are too many empty searches being executed (about 1200). This needs further investigation to see if/how they can be reduced */
if (!string.IsNullOrEmpty(searchText))
{
var telemetryProperties = new Dictionary <string, string>
{
{ "TimeStamp", VirtualDateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") },
{ "QueryTerms", searchText },
{ "ResultCount", totalRecords.ToString() },
{ "Top", sp.Top.ToString() },
{ "Skip", sp.Skip.ToString() }
};
_telemetryClient?.TrackEvent("Gpg_Search", telemetryProperties);
await SearchLog.WriteAsync(telemetryProperties);
}
//Return the facet results
if (sp.Facets != null && sp.Facets.Any())
{
foreach (var facetGroupKey in results.Facets.Keys)
{
if (facets[facetGroupKey] == null)
{
facets[facetGroupKey] = new Dictionary <object, long>();
}
foreach (var facetResult in results.Facets[facetGroupKey])
{
facets[facetGroupKey][facetResult.Value] = facetResult.Count.Value;
}
}
}
//Return the results
var searchResults = new PagedResult <SicCodeSearchModel>
{
Results = results.Results.Select(r => r.Document).ToList(),
CurrentPage = currentPage,
PageSize = pageSize,
ActualRecordTotal = totalRecords,
VirtualRecordTotal = totalRecords
};
return(searchResults);
}
public SearchType GetSearchTypeForFile(string validFile)
{
String extension = Path.GetExtension(validFile);
return(SearchTypes.SingleOrDefault(s => String.Compare(extension, s.Extension, true) == 0));
}
public SearchType(SearchTypes type, string name)
{
Type = type;
Name = name;
}
public async Task <PagedResultOutput <APHeaderTransactionsUnitDto> > GetAPHeaderTransactionUnits(SearchInputDto input)
{
bool unPosted = false;
var query = from invoices in _apHeaderTransactionsUnitRepository.GetAll()
join user in _userUnitRepository.GetAll() on invoices.CreatorUserId equals user.Id
into users
from userunits in users.DefaultIfEmpty()
join pcaccount in _pettyCashAccountUnitRepository.GetAll() on invoices.PettyCashAccountId equals pcaccount.Id
into pcaccountunit
from pcaccountunits in pcaccountunit.DefaultIfEmpty()
join account in _accountUnitRepository.GetAll() on pcaccountunits.AccountId equals account.Id
into accountunit
from accountunits in accountunit.DefaultIfEmpty()
join paymentterms in _vendorPaymentTermUnitRepository.GetAll() on invoices.PaymentTermId equals paymentterms.Id
into paymenttermsunit
from paymenttermunits in paymenttermsunit.DefaultIfEmpty()
join batch in _batchUnitRepository.GetAll() on invoices.BatchId equals batch.Id
into batchunit
from batchunits in batchunit.DefaultIfEmpty()
join vendor in _vendorUnitRepository.GetAll() on invoices.VendorId equals vendor.Id
into vendorunit
from vendors in vendorunit.DefaultIfEmpty()
join bankaccount in _bankAccountUnitRepository.GetAll() on invoices.BankAccountId equals bankaccount.Id
into bankaccountunit
from bankaccounts in bankaccountunit.DefaultIfEmpty()
select new
{
Invoices = invoices,
BatchName = batchunits.Description,
VendorName = vendors.LastName,
CreatedUser = userunits.UserName,
PaymentTerm = paymenttermunits.Description,
BankAccount = bankaccounts.BankAccountNumber,
PettyCashAccount = accountunits.Caption
};
if (!ReferenceEquals(input.Filters, null))
{
SearchTypes mapSearchFilters = Helper.MappingFilters(input.Filters);
if (!ReferenceEquals(mapSearchFilters, null))
{
query = query.CreateFilters(mapSearchFilters);
}
}
query = query
.Where(u => u.Invoices.TypeOfAccountingDocumentId == TypeOfAccountingDocument.AccountsPayable &&
u.Invoices.IsPosted == unPosted);
var resultCount = await query.CountAsync();
var results = await query
.AsNoTracking()
.OrderBy(Helper.GetSort("Invoices.Description ASC", input.Sorting))
.PageBy(input)
.ToListAsync();
return(new PagedResultOutput <APHeaderTransactionsUnitDto>(resultCount, results.Select(item =>
{
var dto = item.Invoices.MapTo <APHeaderTransactionsUnitDto>();
dto.BatchName = item.BatchName;
dto.VendorName = item.VendorName;
dto.CreatedUser = item.CreatedUser;
dto.PaymentTerm = item.PaymentTerm;
dto.BankAccount = item.BankAccount;
dto.PettyCashAccount = item.PettyCashAccount;
dto.TypeOfCheckGroup = item.Invoices.TypeOfCheckGroupId != null ? item.Invoices.TypeOfCheckGroupId.ToDisplayName() : "";
dto.TypeOfInvoice = item.Invoices.TypeOfInvoiceId.ToDisplayName();
dto.AccountingDocumentId = item.Invoices.Id;
return dto;
}).ToList()));
}
protected void Page_Load(object sender, EventArgs e)
{
bool saveSearch = false;
string searchText = string.Empty;
//get the text in the search box
searchBox = (TextBox)FindControl("ctl00$txtSearchBox");
//validate page vars
PageVariablesCollection vars = new PageVariablesCollection();
vars.Add(new RequestVariable("p", typeof(int), false));
vars.Add(new RequestVariable("founderId", typeof(int), false));
vars.Add(new RequestVariable("searchType", typeof(SearchTypes), true));
vars.Add(new RequestVariable("sort", typeof(bool), false));
Page.ValidateVariables(vars);
//the page variable (browsing pages with a result set)
//_searchType = (SearchTypes)Enum.Parse(typeof(SearchTypes), vars["type"].Value.ToString());
_searchType = (SearchTypes)vars["searchType"].Value;
_sort = vars["sort"].HasValue ? (bool)vars["sort"].Value : false;
//check for page variable
if (vars["p"].HasValue)
{
_page = (int)vars["p"].Value;
}
switch (_searchType)
{
case SearchTypes.Founders:
//check to see if a founderId is supplied (i.e. the search is for all things related to a founder)
if (vars["founderId"].HasValue)
{
_founderId = (int)vars["founderId"].Value;
}
//load founder quotes
LoadQuotesByFounder(_founderId);
PanelFounder.Visible = true;
PanelFounderQuotesSummary.Visible = true;
PanelSearchSummary.Visible = false;
break;
case SearchTypes.Quotes:
//upon search postback (the user searched in the search box from this page)
if (IsPostBack)
{
this.SearchQuotes(searchBox.Text, true);
}
//the request is an initial one, or from another page
else
{
//a supplied search string was given
if (Request.QueryString["SearchText"] != null)
{
//find out if this was a custom search
if (Request.QueryString["Custom"] != null)
{
saveSearch = (Request.QueryString["Custom"] == "true") ? true : false;
}
//search
this.SearchQuotes(Request.QueryString["SearchText"], saveSearch);
}
//no search string -- redirect back to home
else
{
Response.Redirect("Default.aspx");
}
}
break;
case SearchTypes.Documents:
//do nothing
break;
}
}
public static Search Create(SearchTypes type)
{
ConsensusSite site = ConsensusDomain.Configuration[ConsensusDomain.Configuration.DefaultSite];
return(Search.Create(site, type));
}
public IEnumerable <Post> Search(SearchTypes search)
{
var data = Read();
var blogQuery = data.OfType <Post>();
switch (search)
{
case SearchTypes.SearchByBlogName:
Menu.displayMessage("Enter a Blog Name");
var blogName = Menu.getStringInput();
var SearchByBlogName = blogQuery
.Where(p => p.Blog.Name.Contains(blogName));
if (SearchByBlogName is IEnumerable <Post> )
{
return(SearchByBlogName);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery);
}
case SearchTypes.SearchByBlogId:
Menu.displayMessage("Enter a Blog Id");
var blogId = Menu.getIntInput();
var SearchByBlogId = blogQuery
.Where(p => p.BlogId.Equals(blogId));
if (SearchByBlogId is IEnumerable <Post> )
{
return(SearchByBlogId);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery);
}
case SearchTypes.SearchByPostId:
Menu.displayMessage("Enter a Post Id");
var postId = Menu.getIntInput();
var SearchByPostId = blogQuery
.Where(p => p.PostID.Equals(postId));
if (SearchByPostId is IEnumerable <Post> )
{
return(SearchByPostId);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery);
}
case SearchTypes.SearchByPostTitle:
Menu.displayMessage("Enter a Post Title");
var postTitle = Menu.getStringInput();
var SearchByPostTitle = blogQuery
.Where(p => p.Title.Contains(postTitle));
if (SearchByPostTitle is IEnumerable <Post> )
{
return(SearchByPostTitle);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery);
}
case SearchTypes.SearchByPostContent:
Menu.displayMessage("Enter a Post Title");
var postContent = Menu.getStringInput();
var SearchByPostContent = blogQuery
.Where(p => p.Content.Contains(postContent));
if (SearchByPostContent is IEnumerable <Post> )
{
return(SearchByPostContent);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery);
}
case SearchTypes.SearchError:
Menu.displayMessage("Could not Determine Search Type");
return(blogQuery);
default:
return(blogQuery);
}
}
public void Start(SearchTypes T)
{
SSniffer.Search(SearchTypesToString(T));
}
public void Browse()
{
SearchTypes searchType = Menu.getSearchType();
Menu.displayBlogs(Search(searchType));
}
public static Match LastMatchWordOnly(string line, string pattern, int start, SearchTypes search, string seqdelim = STRINGQUOTE)
{
return(NextMatchWordOnly(line, pattern, start, search, -1, StopDecrementingAt, SubstringBackward, closer, opener, RegexOptions.RightToLeft, seqdelim));
}
public Blog Find(SearchTypes search)
{
var data = Read();
var blogQuery = data.OfType <Blog>();
switch (search)
{
case SearchTypes.SearchByBlogName:
Menu.displayMessage("Enter a Blog Name");
var blogName = Menu.getStringInput();
var SearchByBlogName = blogQuery
.Where(b => b.Name.Contains(blogName))
.FirstOrDefault();
if (SearchByBlogName is Blog)
{
return(SearchByBlogName);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery.Single());
}
case SearchTypes.SearchByBlogId:
Menu.displayMessage("Enter a Blog Id");
var blogId = Menu.getIntInput();
var SearchByBlogId = blogQuery
.Where(b => b.BlogId.Equals(blogId))
.FirstOrDefault();
if (SearchByBlogId is Blog)
{
return(SearchByBlogId);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery.Single());
}
case SearchTypes.SearchByPostId:
Menu.displayMessage("Enter a Post Id");
var postId = Menu.getIntInput();
var SearchByPostId = blogQuery
.Where(b => b.Posts.Exists(p => p.PostID.Equals(postId)))
.FirstOrDefault();
if (SearchByPostId is Blog)
{
return(SearchByPostId);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery.Single());
}
case SearchTypes.SearchByPostTitle:
Menu.displayMessage("Enter a Post Title");
var postTitle = Menu.getStringInput();
var SearchByPostTitle = blogQuery
.Where(b => b.Posts.Exists(p => p.Title.Contains(postTitle)))
.FirstOrDefault();
if (SearchByPostTitle is Blog)
{
return(SearchByPostTitle);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery.Single());
}
case SearchTypes.SearchByPostContent:
Menu.displayMessage("Enter a Post Title");
var postContent = Menu.getStringInput();
var SearchByPostContent = blogQuery
.Where(b => b.Posts.Exists(p => p.Content.Contains(postContent)))
.FirstOrDefault();
if (SearchByPostContent is Blog)
{
return(SearchByPostContent);
}
else
{
Menu.displayMessage("Could not find blog");
return(blogQuery.Single());
}
case SearchTypes.SearchError:
Menu.displayMessage("Could not Determine Search Type");
return(blogQuery.Single());
default:
return(blogQuery.Single());
}
}
public static Match LastMatch(string line, string pattern, SearchTypes search, MatchTypes validMatch = MatchTypes.WordOnly, string seqdelim = STRINGQUOTE)
{
return(LastMatch(line, pattern, line.Length - 1, search, validMatch, seqdelim));
}
public Task <List <SearchFileResult> > SearchFilesAsync(string searchPhrase = null,
SearchTypes searchType = SearchTypes.SearchCaseInsensitiveText)
{
return(Task.Run(() => SearchFiles(searchPhrase, searchType)));
}
public static async Task<CardSet> GetCardSetByNameAsync(this MtgDb.Info.Driver.Db database, string name, SearchTypes searchTypes = SearchTypes.Contains)
{
var cardSets = await database.GetCardSetsAsync();
return cardSets.FirstOrDefault(cs => SetMatches(cs, name, searchTypes));
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="searchType"></param>
/// <param name="searchString"></param>
public READ_PublicationBySearch(SearchTypes searchType, string searchString)
{
SearchType = searchType;
SearchString = searchString;
}
///<summary>
///constructor
///</summary>
///<param name="searchType"></param>
protected GraphSearchTimeSliced(SearchTypes searchType, Entity.Bot.BotEntity bot)
{
_bot = bot;
_searchType = searchType;
}
private Type generateNewSearch(Type[] searchArgs, Type branchID, bool?filterBranch)
{
branchID = branchID ?? typeof(AccessInfo.branchID);
SearchParamTypes argsTypes = 0;
SearchTypes searchType = 0;
var typesDict = new Dictionary <Type, Type>();
foreach (Type arg in searchArgs)
{
if (typeof(IBqlJoin).IsAssignableFrom(arg))
{
typesDict[typeof(IBqlJoin)] = arg;
argsTypes |= SearchParamTypes.Join;
}
else if (typeof(IBqlWhere).IsAssignableFrom(arg))
{
typesDict[typeof(IBqlWhere)] = arg;
argsTypes |= SearchParamTypes.Where;
}
else if (typeof(IBqlAggregate).IsAssignableFrom(arg))
{
typesDict[typeof(IBqlAggregate)] = arg;
argsTypes |= SearchParamTypes.Aggregate;
}
else if (typeof(IBqlOrderBy).IsAssignableFrom(arg))
{
typesDict[typeof(IBqlOrderBy)] = arg;
argsTypes |= SearchParamTypes.OrderBy;
}
}
Type newSearch = null;
Type newSearchType = null;
switch (argsTypes & (SearchParamTypes.Aggregate | SearchParamTypes.OrderBy))
{
case SearchParamTypes.Aggregate:
newSearchType = typeof(Search5 <, , ,>);
searchType = SearchTypes.Search54;
break;
case SearchParamTypes.OrderBy:
newSearchType = typeof(Search2 <, , ,>);
searchType = SearchTypes.Search24;
break;
case (SearchParamTypes.Aggregate | SearchParamTypes.OrderBy):
newSearchType = typeof(Search5 <, , , ,>);
searchType = SearchTypes.Search55;
break;
case 0:
newSearchType = typeof(Search2 <, ,>);
searchType = SearchTypes.Search23;
break;
}
if (newSearchType != null)
{
if (typesDict.ContainsKey(typeof(IBqlJoin)))
{
typesDict[typeof(IBqlJoin)] = BqlCommand.Compose(
typeof(InnerJoin <, ,>),
typeof(Account),
typeof(On <, ,>),
typeof(Account.accountID),
typeof(Equal <CashAccount.accountID>),
typeof(And2 <,>),
typeof(Match <Account, Current <AccessInfo.userName> >),
typeof(And <>),
typeof(Match <,>),
typeof(Account),
typeof(Optional <>),
branchID,
typeof(InnerJoin <, ,>),
typeof(Sub),
typeof(On <Sub.subID, Equal <CashAccount.subID>, And <Match <Sub, Current <AccessInfo.userName> > > >),
typesDict[typeof(IBqlJoin)]);
}
else
{
typesDict[typeof(IBqlJoin)] = typeof(InnerJoin <Account,
On <Account.accountID, Equal <CashAccount.accountID>, And <Match <Account, Current <AccessInfo.userName> > > >,
InnerJoin <Sub, On <Sub.subID, Equal <CashAccount.subID>, And <Match <Sub, Current <AccessInfo.userName> > > > > >);
}
List <Type> args = new List <Type>
{
typeof(Where2 <,>),
typeof(Not <>),
typeof(FeatureInstalled <FeaturesSet.branch>),
typeof(Or <, ,>),
typeof(CashAccount.restrictVisibilityWithBranch),
typeof(Equal <>),
typeof(False),
typeof(Or <,>),
typeof(CashAccount.branchID)
};
Type[] filterConditions = filterBranch == true ? new Type[] { typeof(Equal <>), typeof(Current <>), branchID }
: new Type[] { typeof(IsNotNull) };
args.AddRange(filterConditions);
if (typesDict.ContainsKey(typeof(IBqlWhere)))
{
args.Insert(0, typeof(Where2 <,>));
args.AddRange(new Type[] { typeof(And <>), typesDict[typeof(IBqlWhere)] });
}
typesDict[typeof(IBqlWhere)] = BqlCommand.Compose(args.ToArray());
var newSearchList = new List <Type> {
newSearchType, typeof(CashAccount.cashAccountID), typesDict[typeof(IBqlJoin)], typesDict[typeof(IBqlWhere)]
};
if (searchType == SearchTypes.Search54 || searchType == SearchTypes.Search55)
{
newSearchList.Add(typesDict[typeof(IBqlAggregate)]);
}
if (searchType == SearchTypes.Search24 || searchType == SearchTypes.Search55)
{
newSearchList.Add(typesDict[typeof(IBqlOrderBy)]);
}
newSearch = BqlCommand.Compose(newSearchList.ToArray());
}
return(newSearch);
}
private List <Invoice> searchInvoices(SearchTypes searchType, SearchFilterTypes filterType)
{
//begin - shan - mar 14, 2012 - set default value to be error value (-999)
//based on that differentiate whether zero has been entered or fields has been left empty
//while searching based on the amount
//decimal startAmount = 0;
//decimal.TryParse(txtStartAmount.Text.Trim(), out startAmount);
//decimal endAmount = 0;
//decimal.TryParse(txtEndAmount.Text.Trim(), out endAmount);
var invoices = new List <Invoice>();
decimal startAmount = -999;
decimal endAmount = -999;
startAmount = decimal.TryParse(txtStartAmount.Text.Trim(), out startAmount) ? startAmount : -999;
endAmount = decimal.TryParse(txtEndAmount.Text.Trim(), out endAmount) ? endAmount : -999;
var searchValue = txtSearchBy.Text.Trim();
if (searchType == SearchTypes.ByDateOrAmount)
{
invoices = InvoiceProvider.SearchInvoice(new InvoiceSearchFilter()
{
SearchByDateOrAmount = true,
FromDate = FromDate.SelectedDate,
ToDate = ToDate.SelectedDate,
StartAmount = (0 > startAmount) ? (decimal?)null : startAmount,
EndAmount = (0 > endAmount) ? (decimal?)null : endAmount,
}, DistributorID);
}
else
{
var searchFilter = new InvoiceSearchFilter();
searchFilter.SearchByDateOrAmount = false;
searchFilter.FirstName = (filterType == SearchFilterTypes.FirstName) ? searchValue : string.Empty;
searchFilter.LastName = (filterType == SearchFilterTypes.LastName) ? searchValue : string.Empty;
searchFilter.StreetAddress = (filterType == SearchFilterTypes.StreetAddress) ? searchValue : string.Empty;
searchFilter.City = (filterType == SearchFilterTypes.City) ? searchValue : string.Empty;
searchFilter.State = (filterType == SearchFilterTypes.State) ? searchValue : string.Empty;
searchFilter.ZipCode = (filterType == SearchFilterTypes.ZipCode) ? searchValue : string.Empty;
searchFilter.SKU = (filterType == SearchFilterTypes.SKU) ? searchValue : string.Empty;
searchFilter.Description = (filterType == SearchFilterTypes.Description) ? searchValue : string.Empty;
//begin - shan - mar 14, 2012 - assign null based on error value
//to differentiate whether to search by 0 or empty field
//based on this, while filtering check for null or 0
decimal parseValue = -999;
parseValue = decimal.TryParse(searchValue, out parseValue) ? parseValue : -999;
{
searchFilter.TotalVolumePoints = (filterType == SearchFilterTypes.TotalVolumePoints) ?
(0 < parseValue ? parseValue : (decimal?)null) : (decimal?)null;
searchFilter.InvoiceTotal = (filterType == SearchFilterTypes.InvoiceTotal) ?
(0 < parseValue ? parseValue : (decimal?)null) : (decimal?)null;
}
invoices = InvoiceProvider.SearchInvoice(searchFilter, DistributorID);
//shan - mar 15, 2012 - to set secondary sorting to be of invoice #
//sort the invoices to be ordered by invoice # descendingg
//while applying sorting from grid that should get filter as the primary sorting
if (null != invoices && invoices.Count > 0)
{
invoices = invoices.OrderByDescending(inv => inv.DistributorInvoiceNumber).ToList();
}
}
return(invoices);
}
private static Match MatchGroup(string line, string pattern, ref int tracker, ref int len, SearchTypes search,
int shiftFactor, CodeStub NextStart, RegexOptions orientation)
{
int index = -1;
string value = "";
GroupCollection groups = null;
switch (search)
{
case SearchTypes.STRING:
{
index = line.Substring(NextStart(tracker, len), len).IndexOf(pattern, StringComparison.Ordinal);
if (index >= 0)
{
value = pattern;
}
break;
}
case SearchTypes.REGEX:
{
System.Text.RegularExpressions.Match match =
Regex.Match(line.Substring(NextStart(tracker, len), len), pattern, orientation | RegexOptions.Multiline);
if (match.Success)
{
value = match.Value;
index = match.Index;
groups = match.Groups;
}
break;
}
default:
{
throw new ArgumentException();
}
}
if (index >= 0)
{
return(new Match(value, NextStart(tracker, len) + index, value.Length, groups));
}
tracker += shiftFactor * len;
return(Fail());
}
public static void StartSearch()
{
new Thread(() =>
{
Cancel = false;
StatusChanged?.Invoke(SearchStatus.Started);
SearchFileChanged?.Invoke("Starting...");
try
{
if (SearchType == SearchTypes.Folder)
{
string folder = SearchTarget[0];
SearchFileChanged?.Invoke(folder);
SearchTarget = Directory.GetFiles(folder, "*.h", SearchOption.AllDirectories);
SearchType = SearchTypes.File;
}
if (SearchType == SearchTypes.File)
{
for (int i = 0; i < SearchTarget.Length; i++)
{
var file = new FileInfo(SearchTarget[i]);
SearchFileChanged?.Invoke(file.FullName, i + 1, SearchTarget.Length);
var cache = GetCacheForFile(file);
var searchResult = cache.SearchHere(SearchWhat);
foreach (var result in searchResult)
{
StatusChanged?.Invoke(SearchStatus.FoundSomething, result);
}
}
}
if (SearchType == SearchTypes.Cache)
{
for (int i = 0; i < Cache.Count; i++)
{
var cache = Cache[i];
SearchFileChanged?.Invoke(cache.File.FullName, i + 1, Cache.Count);
var searchResult = cache.SearchHere(SearchWhat);
foreach (var result in searchResult)
{
StatusChanged?.Invoke(SearchStatus.FoundSomething, result);
}
}
}
}
catch (Exception ex)
{
StatusChanged?.Invoke(SearchStatus.Error, ex);
}
StatusChanged?.Invoke(SearchStatus.Finished);
}).Start();
}
private static Match NextMatchWordOnly(string line, string pattern, int start, SearchTypes search,
int shiftFactor, CodeStub StopAt, CodeStub NextStart,
string pushSymbols, string popSymbols,
RegexOptions orientation, string seqdelim = STRINGQUOTE)
{
Match match = Fail();
int tracker = start;
int len;
while (!match.Success && tracker >= 0 && tracker < line.Length)
{
if (seqdelim.Contains(line[tracker]))
{
tracker += shiftFactor * NextLiteralSequenceLength(line, tracker, StopAt(tracker, line.Length), shiftFactor, seqdelim);
continue;
}
if (pushSymbols.Contains(line[tracker]))
{
tracker += shiftFactor * NextGroupLength(line, tracker, StopAt(tracker, line.Length), shiftFactor, pushSymbols, popSymbols);
continue;
}
len = NextWordLength(line, tracker, StopAt(tracker, line.Length), shiftFactor, pushSymbols + popSymbols + seqdelim);
match = MatchGroup(line, pattern, ref tracker, ref len, search, shiftFactor, NextStart, orientation);
}
return(match);
}
/// <summary>
/// Hace clic en un control.
/// </summary>
/// <param name="searchString">Texto con el que se busca el Elemento.</param>
/// <param name="searchType">Tipo de búsqueda.</param>
public void Click(string searchString, SearchTypes searchType)
{
FindElement(searchString, searchType).Click();
}
public static Match NextMatchNonLiteralSequence(string line, string pattern, int start, SearchTypes search, string seqdelim = STRINGQUOTE)
{
return(NextMatchNonLiteralSequence(line, pattern, start, search, 1, StopIncrementingAt, SubstringForward, RegexOptions.None, seqdelim));
}
private bool SearchAttributeSet(DicomAttributeCollection set, string filename, SearchTypes searchType)
{
if (searchType == SearchTypes.PrivateSequence)
{
foreach (DicomAttribute attrib in set)
{
if (attrib.Tag.IsPrivate && attrib.Tag.VR.Equals(DicomVr.SQvr))
{
Platform.Log(LogLevel.Info, "Found file with private SQ: {0}", filename);
return(true);
}
if (!attrib.Tag.VR.Equals(DicomVr.SQvr) || attrib.IsNull)
{
continue;
}
// Recursive search
foreach (DicomSequenceItem item in (DicomSequenceItem[])attrib.Values)
{
SearchAttributeSet(item, filename, searchType);
}
}
}
else if (searchType == SearchTypes.Overlay)
{
foreach (DicomAttribute attrib in set)
{
if ((attrib.Tag.TagValue & 0xFF000000) == 0x60000000)
{
Platform.Log(LogLevel.Info, "Found embedded overlay in file: {0}", filename);
return(true);
}
if (attrib.Tag.TagValue > 0x70000000)
{
return(false);
}
}
}
else if (searchType == SearchTypes.PaletteColor)
{
if (set.Contains(DicomTags.PhotometricInterpretation))
{
if (set[DicomTags.PhotometricInterpretation].ToString().Equals("PALETTE COLOR"))
{
return(true);
}
}
return(false);
}
return(false);
}
public static Match NextMatchNonGroup(string line, string pattern, int start, SearchTypes search)
{
return(NextMatchNonGroup(line, pattern, start, search, 1, StopIncrementingAt, SubstringForward, opener, closer, RegexOptions.None));
}
//public ActionResult Search()//no search parameters given
//{
// return View(db.Song.ToList());
//}
public ActionResult Search(string searchTitle, SearchTypes? searchType, int? searchArtist, bool? ORSearch)
{
var songs = from s in db.Song
select s;
//songs.Include(s => s.Artist);
if (ORSearch == false) //this is an AND search
{
if (String.IsNullOrEmpty(searchTitle) == false)
{
if (searchType == SearchTypes.KEYWORD)
{
songs = songs.Where(s => s.Name.Contains(searchTitle));
}
else
{
songs = songs.Where(s => s.Name == searchTitle);
}
}
if (searchArtist != null && searchArtist != -1) //there is something to search for in artist
{
songs = songs.Where(s => s.Artist.ArtistID == searchArtist);
}
}
else if (ORSearch == true) //this is an or search
{
if (searchType == SearchTypes.KEYWORD)
{
songs = songs.Where(s => s.Name.Contains(searchTitle) || s.Artist.ArtistID == searchArtist);
}
else if (searchType == SearchTypes.EXACT)
{
songs = songs.Where(s => s.Name == searchTitle || s.Artist.ArtistID == searchArtist);
}
}
ViewBag.AllArtists = UpdateArtists.GetAllArtistsWithAll(db);
return View(songs.ToList());
}
public static Match NextMatchWordOnly(string line, string pattern, int start, SearchTypes search, string seqdelim = STRINGQUOTE)
{
return(NextMatchWordOnly(line, pattern, start, search, 1, StopIncrementingAt, SubstringForward, opener, closer, RegexOptions.None, seqdelim));
}
private bool SearchAttributeSet(DicomAttributeCollection set, string filename, SearchTypes searchType)
{
if (searchType == SearchTypes.PrivateSequence)
{
foreach (DicomAttribute attrib in set)
{
if (attrib.Tag.IsPrivate && attrib.Tag.VR.Equals(DicomVr.SQvr))
{
Platform.Log(LogLevel.Info, "Found file with private SQ: {0}", filename);
return true;
}
if (!attrib.Tag.VR.Equals(DicomVr.SQvr) || attrib.IsNull) continue;
// Recursive search
foreach (DicomSequenceItem item in (DicomSequenceItem[]) attrib.Values)
{
SearchAttributeSet(item, filename, searchType);
}
}
}
else if (searchType == SearchTypes.Overlay)
{
foreach (DicomAttribute attrib in set)
{
if ((attrib.Tag.TagValue & 0xFF000000) == 0x60000000)
{
Platform.Log(LogLevel.Info, "Found embedded overlay in file: {0}", filename);
return true;
}
if (attrib.Tag.TagValue > 0x70000000)
return false;
}
}
else if (searchType == SearchTypes.PaletteColor)
{
if (set.Contains(DicomTags.PhotometricInterpretation))
{
if (set[DicomTags.PhotometricInterpretation].ToString().Equals("PALETTE COLOR"))
return true;
}
return false;
}
return false;
}
public static Match LastMatchNonLiteralSequence(string line, string pattern, int start, SearchTypes search, string seqdelim = STRINGQUOTE)
{
return(NextMatchNonLiteralSequence(line, pattern, start, search, -1, StopDecrementingAt, SubstringBackward, RegexOptions.RightToLeft, seqdelim));
}
public static Match LastMatchNonGroup(string line, string pattern, int start, SearchTypes search)
{
return(NextMatchNonGroup(line, pattern, start, search, -1, StopDecrementingAt, SubstringBackward, closer, opener, RegexOptions.RightToLeft));
}
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <PagedResultOutput <ArInvoiceEntryDocumentUnitDto> > GetArInvoiceEntryDocumentUnits(SearchInputDto input)
{
bool unPosted = false;
var query = from invoices in _arInvoiceEntryDocumentUnitRepository.GetAll()
join customer in _customerUnitRepository.GetAll() on invoices.CustomerId equals customer.Id
into customers
from customer in customers.DefaultIfEmpty()
join currency in _currencyUnitRepository.GetAll() on invoices.TypeOfCurrencyId equals currency.Id into
currencys
from currency in currencys.DefaultIfEmpty()
join paymentTerm in _customerPaymentTermUnitRepository.GetAll() on invoices.ArPaymentTermId equals paymentTerm.Id into
paymentTerms
from paymentTerm in paymentTerms.DefaultIfEmpty()
join salesRep in _salesRepUnitRepository.GetAll() on invoices.SalesRepId equals salesRep.Id into
salesReps
from salesRep in salesReps.DefaultIfEmpty()
select new
{
invoices,
TypeOfCurrency = currency.Description,
SalesRepName = salesRep.LastName,
ArPaymentTerm = paymentTerm.Description,
CustomerName = customer.LastName
};
if (!ReferenceEquals(input.Filters, null))
{
SearchTypes mapSearchFilters = Helper.MappingFilters(input.Filters);
if (!ReferenceEquals(mapSearchFilters, null))
{
query = query.CreateFilters(mapSearchFilters);
}
}
query = query.Where(u =>
u.invoices.TypeOfAccountingDocumentId == TypeOfAccountingDocument.AccountsReceivable &&
u.invoices.IsPosted == unPosted);
var resultCount = await query.CountAsync();
var results = await query
.AsNoTracking()
.OrderBy(Helper.GetSort("invoices.DocumentReference DESC", input.Sorting))
.PageBy(input)
.ToListAsync();
var arIdList = string.Join(",", results.Select(x => x.invoices.Id).ToArray());
var arDetailsList = from arDetail in _arInvoiceEntryDocumentDetailUnitRepository.GetAll()
join account in _accountUnitRepository.GetAll() on arDetail.AccountId equals account.Id
join job in _jobUnitRepository.GetAll() on arDetail.JobId equals job.Id
select new
{
AccountingDocumentId = arDetail.AccountingDocumentId,
Account = account.AccountNumber,
Job = job.JobNumber,
JobName = job.Caption,
Amount = arDetail.Amount
};
var arDetails = await arDetailsList.Where(u => arIdList.Contains(u.AccountingDocumentId.ToString())).ToListAsync();
var arDetailGroup = (arDetails.GroupBy(i => i.AccountingDocumentId)
.Select(g => new
{
g.Key,
Jobs = string.Join(",", g.Select(u => u.Job)),
JobName = string.Join(",", g.Select(u => u.JobName)),
Account = string.Join(",", g.Select(u => u.Account)),
Amount = g.Sum(u => u.Amount)
})).ToList();
var arList = from ar in results
join details in arDetailGroup on ar.invoices.Id equals details.Key
select new { arData = ar, arDetailGroup = details };
return(new PagedResultOutput <ArInvoiceEntryDocumentUnitDto>(resultCount, arList.Select(item =>
{
var dto = item.arData.invoices.MapTo <ArInvoiceEntryDocumentUnitDto>();
dto.JobNumber = item.arDetailGroup.Jobs;
dto.JobName = item.arDetailGroup.JobName;
dto.AccountNumber = item.arDetailGroup.Account;
dto.TypeOfCurrency = item.arData.TypeOfCurrency;
dto.SalesRepName = item.arData.SalesRepName;
dto.ArPaymentTerm = item.arData.ArPaymentTerm;
dto.AccountingDocumentId = item.arData.invoices.Id;
dto.CustomerName = item.arData.CustomerName;
return dto;
}).ToList()));
}
