public static string GetParametersString(int page, SortBy sort, OrderBy direction)
{
return string.Format("page={0}&sort={1}&direction={2}",
page,
sort.GetText(),
direction.GetText());
}
/// <summary>
/// Default constructor
/// </summary>
public QueryData()
{
fields = new List<string>();
conditions = new List<string>();
groupBy = new GroupBy();
orderBy = new OrderBy();
}
public OrderByService RegisterButton(LinkButton button, OrderBy orderBy)
{
button.Click += delegate { ButtonClicked(orderBy); };
SetCssClass(button, orderBy);
Changed += delegate { SetCssClass(button, orderBy); };
return this;
}
public ActionResult ClassAdvanced(string searchString, int page, SearchBy searchBy, OrderBy orderBy, string universityId)
{
UserInformationModel<User> myUserInformation = GetUserInformatonModel();
searchString = MassageSearchString(searchString);
SearchResultsModel mySearchResults = theSearchService.GetClassSearchResults(myUserInformation, searchString, page, searchBy, orderBy, universityId);
return View("Results", mySearchResults);
}
public SearchPage(List<LaunchData> launchList, OrderBy order)
{
Title = "Launch list";
Context = new SearchViewModel(launchList, order);
Context.SearchResult.ItemTapped += SearchResult_ItemTapped;
BackgroundColor = Theme.BackgroundColor;
Content = GenerateView();
}
public static XContainer ReorderElements(this XContainer root, OrderBy reorderElementsBy)
{
if (reorderElementsBy.HasFlag(OrderBy.MinX)) OrderByMinX(root);
if (reorderElementsBy.HasFlag(OrderBy.MinY)) OrderByMinY(root);
if (reorderElementsBy.HasFlag(OrderBy.ChildMinY)) OrderByChildMinY(root);
if (reorderElementsBy.HasFlag(OrderBy.Id)) OrderById(root);
else if (reorderElementsBy.HasFlag(OrderBy.IdDesc)) OrderByIdDesc(root);
return root;
}
public MessageOrderBy()
{
Id = new OrderBy("Id", this);
From = new OrderBy("FromType", this);
To = new OrderBy("ToType", this);
Type = new OrderBy("Type", this);
Status = new OrderBy("Status", this);
DateCreated = new OrderBy("DateCreated", this);
}
private static string OrderByToString(OrderBy orderBy)
{
switch (orderBy)
{
case OrderBy.CreateDate:
return "create_date";
case OrderBy.RuReleaseDate:
return "ru_releae_date";
default:
return "release_date";
}
}
public virtual SqlStatement GetGroupBySumStatement(Condition iwc, OrderBy order, string groupbyColumnName, string sumColumnName)
{
var builder = new SelectStatementBuilder(Context.Info.From, order, null);
builder.Where.Conditions = iwc;
var list = groupbyColumnName.Split(',');
foreach (string s in list)
{
builder.Keys.Add(new KeyValuePair<string, string>(s, null));
builder.SetAsGroupBySum(groupbyColumnName, sumColumnName);
}
return builder.ToSqlStatement(Context);
}
public RestAPIResponse Get(string id = null, string hash = null, string historicsId = null, int? page = null, int? perPage = null, OrderBy? orderBy = null, OrderDirection? orderDirection = null, bool? includeFinished = null)
{
//Contract.Requires<ArgumentException>((id != null) ? id.Trim().Length > 0 : true);
//Contract.Requires<ArgumentException>((id != null) ? Constants.SUBSCRIPTION_ID_FORMAT.IsMatch(id) : true, Messages.INVALID_SUBSCRIPTION_ID);
//Contract.Requires<ArgumentException>((hash != null) ? hash.Trim().Length > 0 : true);
//Contract.Requires<ArgumentException>((hash != null) ? Constants.STREAM_HASH_FORMAT.IsMatch(hash) : true, Messages.INVALID_STREAM_HASH);
//Contract.Requires<ArgumentException>((historicsId != null) ? historicsId.Trim().Length > 0 : true);
//Contract.Requires<ArgumentException>((historicsId != null) ? Constants.HISTORICS_ID_FORMAT.IsMatch(historicsId) : true, Messages.INVALID_HISTORICS_ID);
//Contract.Requires<ArgumentException>((page.HasValue) ? page.Value > 0 : true);
//Contract.Requires<ArgumentException>((perPage.HasValue) ? perPage.Value > 0 : true);
return _client.GetRequest().Request("push/get", new { id = id, hash = hash, historics_id = historicsId, page = page, per_page = perPage, order_by = orderBy, order_dir = orderDirection, include_finished = includeFinished });
}
public static string GetMovieListUrl(DateTime fromDate, DateTime toDate, OrderBy orderBy, bool ascOrder, int pageNumber, int itemsPerPage, string genre, string country)
{
var sb = new StringBuilder(string.Format("&from={0}&to={1}&order_by={2}&order={3}&page={4}&per_page={5}", fromDate, toDate, OrderByToString(orderBy), ascOrder ? "asc" : "desc", pageNumber, itemsPerPage));
if (!string.IsNullOrEmpty(genre))
{
sb.Append(string.Format("&genre={0}", genre));
}
if (!string.IsNullOrEmpty(country))
{
sb.Append(string.Format("&country={0}", country));
}
return ConcatBase(Settings.Default.MovieListUrlPart, sb);
}
//Возвращает текущий список
//Задаем сортировку/порядок/отмену
public List<Item> Down(string iD, OrderBy op)
{
switch (op)
{
case OrderBy.None:
CurrentNode.Push(_treeMenu.Find(z => z.Id == iD).Children
.Select(p => new Item { ItemLine = p.Value.ItemLine, Id = p.Value.Id }).ToList());
break;
case OrderBy.Orderby:
CurrentNode.Push(_treeMenu.Find(z => z.Id == iD).Children.OrderBy(z => z.Value.ItemLine.ElementAt(2))
.Select(p => new Item { ItemLine = p.Value.ItemLine, Id = p.Value.Id }).ToList());
break;
case OrderBy.Descending:
CurrentNode.Push(_treeMenu.Find(z => z.Id == iD).Children.OrderByDescending(z => z.Value.ItemLine.ElementAt(2))
.Select(p => new Item { ItemLine = p.Value.ItemLine, Id = p.Value.Id }).ToList());
break;
}
var c = CurrentNode.Count;
return CurrentNode.Peek();
}
//--------------------
public bool CreateDimensionAttributeForLevel(Dimension dimension, DataSourceView dataSourceView,
String levelId, String levelName, String tableName, String keyColumn, String nameColumn,
AttributeUsage attributeUsage, OrderBy orderBy, AttributeType attribType, bool visible)
{
if (dimension.Attributes == null)
{
return false;
}
DimensionAttribute dimAttrib;
if (!dimension.Attributes.Contains(levelId))
{
dimAttrib = dimension.Attributes.Add(levelName, levelId);
dimAttrib.Usage = attributeUsage;
dimAttrib.OrderBy = orderBy;
dimAttrib.Type = attribType;
dimAttrib.AttributeHierarchyVisible = true;// visible;
dimAttrib.AttributeHierarchyOptimizedState = OptimizationType.NotOptimized;
dimAttrib.AttributeHierarchyOrdered = true;
dimAttrib.IsAggregatable = true;
//设置MembersWithDataCaption会导致当前粒度在子粒度中存在，形如"XXXX(All)"，因此注释掉
//if (attributeUsage == AttributeUsage.Parent)
//{
// dimAttrib.MembersWithDataCaption = "*(All)";
//}
dimAttrib.MembersWithData = MembersWithData.NonLeafDataHidden;
DataItem diKey = CreateDataItem(dataSourceView, tableName, keyColumn);
dimAttrib.KeyColumns.Add(diKey);
if (!String.IsNullOrEmpty(nameColumn))
{
DataItem diName = CreateDataItem(dataSourceView, tableName, nameColumn);
dimAttrib.NameColumn = diName;
DataItem diValue = CreateDataItem(dataSourceView, tableName, nameColumn);
dimAttrib.ValueColumn = diValue;
}
return true;
}
return true;
}
public List<Folder> GetFolders(object parentId, OrderBy orderBy, FilterType filterType, Guid subjectID, string searchText)
{
var folders = GetFolders(parentId).AsEnumerable(); //TODO:!!!
//Filter
switch (filterType)
{
case FilterType.ByUser:
folders = folders.Where(x => x.CreateBy == subjectID);
break;
case FilterType.ByDepartment:
folders = folders.Where(x => CoreContext.UserManager.IsUserInGroup(x.CreateBy, subjectID));
break;
}
if (!string.IsNullOrEmpty(searchText))
folders = folders.Where(x => x.Title.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) != -1);
if (orderBy == null) orderBy = new OrderBy(SortedByType.DateAndTime, false);
switch (orderBy.SortedBy)
{
case SortedByType.Author:
folders = orderBy.IsAsc ? folders.OrderBy(x => x.CreateBy) : folders.OrderByDescending(x => x.CreateBy);
break;
case SortedByType.AZ:
folders = orderBy.IsAsc ? folders.OrderBy(x => x.Title) : folders.OrderByDescending(x => x.Title);
break;
case SortedByType.DateAndTime:
folders = orderBy.IsAsc ? folders.OrderBy(x => x.CreateOn) : folders.OrderByDescending(x => x.CreateOn);
break;
default:
folders = orderBy.IsAsc ? folders.OrderBy(x => x.Title) : folders.OrderByDescending(x => x.Title);
break;
}
return folders.ToList();
}
public override SelectStatementBuilder GetSelectStatementBuilder(FromClause from, Condition iwc, OrderBy oc, Range lc, bool isDistinct, bool noLazy, Type returnType, string colName)
{
return base.GetSelectStatementBuilder(from, iwc && _colExp, oc, lc, isDistinct, noLazy, returnType, colName);
}
/// <summary>
/// Gets the Review Forum Thread List
/// </summary>
/// <param name="numThreads"></param>
/// <param name="numSkipped"></param>
/// <param name="orderBy"></param>
/// <param name="ascending"></param>
public void GetReviewForumThreadList(int numThreads, int numSkipped, OrderBy orderBy, bool ascending)
{
if (!_initialised)
{
throw new DnaException("NOT INITIALISED - Tried to use review forum without initialising");
}
if (numThreads == 0)
{
throw new DnaException("ZERO THREADS - Stupid to not fetch any threads from forum");
}
string cachename = "RFT";
cachename += _reviewForumID.ToString() + "-" + orderBy.ToString() + "-" + ascending.ToString() + "-" + numSkipped.ToString() + "-" + (numSkipped + numThreads - 1).ToString() + ".txt";
string reviewForumXml = String.Empty;
DateTime lastDate;
//find out the cache dirty date
lastDate = CacheGetMostRecentReviewForumThreadDate(_reviewForumID);
//get it from the cache if you can
if (InputContext.FileCacheGetItem("reviewforums", cachename, ref lastDate, ref reviewForumXml))
{
// Create the review forums thread list from the cache
CreateAndInsertCachedXMLToANode(reviewForumXml, "REVIEWFORUMTHREADS", true, "REVIEWFORUM");
// Finally update the relative dates and return
UpdateRelativeDates();
return;
}
using (IDnaDataReader dataReader = InputContext.CreateDnaDataReader(GetReviewForumThreadsStoredProcedure(orderBy)))
{
dataReader.AddParameter("reviewforumid", _reviewForumID);
dataReader.AddParameter("ascending", ascending);
dataReader.Execute();
// Check to see if we found anything
if (dataReader.HasRows && dataReader.Read())
{
// Got a list, so let's skip the first NumSkipped threads
if (numSkipped > 0)
{
//Read/skip over the skip number of rows so that the row that the first row that in the do below is
//the one required
for (int i = 0; i < numSkipped; i++)
{
dataReader.Read();
}
}
int index = 0;
int forumID = dataReader.GetInt32NullAsZero("forumid");
//now lets build up the review forums threads xml
XmlElement reviewForumThreads = AddElementTag(_reviewForum, "REVIEWFORUMTHREADS");
AddAttribute(reviewForumThreads, "FORUMID", forumID);
AddAttribute(reviewForumThreads, "SKIPTO", numSkipped);
AddAttribute(reviewForumThreads, "COUNT", numThreads);
int totalThreads = dataReader.GetInt32NullAsZero("ThreadCount");
AddAttribute(reviewForumThreads, "TOTALTHREADS", totalThreads);
AddAttribute(reviewForumThreads, "ORDERBY", (int) orderBy);
AddAttribute(reviewForumThreads, "DIR", ascending);
do
{
int threadID = dataReader.GetInt32NullAsZero("ThreadID");
string subject = dataReader.GetStringNullAsEmpty("Subject");
DateTime datePosted = dataReader.GetDateTime("LastPosted");
DateTime dateEntered = dataReader.GetDateTime("DateEntered");
int H2G2ID = dataReader.GetInt32NullAsZero("h2g2id");
int authorID = dataReader.GetInt32NullAsZero("authorid");
int submitterID = dataReader.GetInt32NullAsZero("submitterid");
string userName = dataReader.GetStringNullAsEmpty("username");
XmlElement thread = AddElementTag(reviewForumThreads, "THREAD");
AddAttribute(thread, "INDEX", index);
AddIntElement(thread, "THREADID", threadID);
AddIntElement(thread, "H2G2ID", H2G2ID);
AddTextTag(thread, "SUBJECT", subject);
AddDateXml(datePosted, thread, "DATEPOSTED");
AddDateXml(dateEntered, thread, "DATEENTERED");
XmlElement authorElement = AddElementTag(thread, "AUTHOR");
XmlElement submitterElement = AddElementTag(thread, "SUBMITTER");
XmlElement user = AddElementTag(authorElement, "USER");
AddIntElement(user, "USERID", authorID);
AddTextTag(user, "USERNAME", userName);
XmlElement subuser = AddElementTag(submitterElement, "USER");
AddIntElement(subuser, "USERID", submitterID);
/*
User author = new User(InputContext);
author.AddUserXMLBlock(dataReader, authorID, authorElement);
User submitter = new User(InputContext);
submitter.AddPrefixedUserXMLBlock(dataReader, submitterID, submitterElement);
*/
numThreads--;
index++;
} while (numThreads > 0 && dataReader.Read());
// See if there's an extra row waiting
if (numThreads == 0 && dataReader.Read())
{
AddAttribute(reviewForumThreads, "MORE", 1);
}
InputContext.FileCachePutItem("reviewforums", cachename, reviewForumThreads.OuterXml);
UpdateRelativeDates();
}
}
}
// Get the filters' data for UOMNameFilter.
protected virtual void PopulateUOMNameFilter(string selectedValue, int maxItems)
{
this.UOMNameFilter.Items.Clear();
// Set up the WHERE and the ORDER BY clause by calling the CreateWhereClause_UOMNameFilter function.
// It is better to customize the where clause there.
// Setup the WHERE clause,
WhereClause wc = this.CreateWhereClause_UOMNameFilter();
// Setup the static list items
// Add the All item.
this.UOMNameFilter.Items.Insert(0, new ListItem(this.Page.GetResourceValue("Txt:All", "FPCEstimate"), "--ANY--"));
OrderBy orderBy = new OrderBy(false, false);
orderBy.Add(UOMTable.UOMName, OrderByItem.OrderDir.Asc);
string[] values = UOMTable.GetValues(UOMTable.UOMName, wc, orderBy, maxItems);
foreach (string itemValue in values)
{
// Create the item and add to the list.
string fvalue;
if ( UOMTable.UOMName.IsColumnValueTypeBoolean()) {
fvalue = itemValue;
}else {
fvalue = UOMTable.UOMName.Format(itemValue);
}
ListItem item = new ListItem(fvalue, itemValue);
this.UOMNameFilter.Items.Add(item);
}
// Set the selected value.
MiscUtils.SetSelectedValue(this.UOMNameFilter, selectedValue);
}
public static UserCollection Where(Func <UserColumns, QueryFilter <UserColumns> > where, OrderBy <UserColumns> orderBy = null, Database database = null)
{
database = database ?? Db.For <User>();
return(new UserCollection(database.GetQuery <UserColumns, User>(where, orderBy), true));
}
public string GetPagingSQL(string SQL, string OrderBy, int StartIndex, int EndIndex, OrderBy orderby = OrderBy.ASC)
{
StringBuilder sql = new StringBuilder();
sql.AppendFormat("{0} LIMIT {1}, {2}", sql, StartIndex, EndIndex - StartIndex);
return(sql.ToString());
}
public IEnumerable <Schedule> GetCollection(int top = -1, IFilter filter = null, string select = null, string expand = null, OrderBy orderby = null, int skip = -1, Folder folder = null)
{
return(GetCollection(new QueryParameters(top, filter, select, expand, orderby, skip), folder));
}
public Task <PaginatedList <TEntity> > GetAllAsync(int pageIndex, int pageSize, Expression <Func <TEntity, int> > keySelector, OrderBy orderBy = OrderBy.Ascending)
{
return(_repository.GetAllAsync(pageIndex, pageSize, keySelector, orderBy));
}
/// <summary>
/// Write out a SQL select statement as a string.
/// We have to
/// <list type="number">
/// <item>Check whether the aliases extents we use in this statement have
/// to be renamed.
/// We first create a list of all the aliases used by the outer extents.
/// For each of the FromExtents( or AllJoinExtents if it is non-null),
/// rename it if it collides with the previous list.
/// </item>
/// <item>Write each of the clauses (if it exists) as a string</item>
/// </list>
/// </summary>
/// <param name="writer"></param>
/// <param name="sqlGenerator"></param>
public void WriteSql(SqlWriter writer, SqlGenerator sqlGenerator)
{
#region Check if FROM aliases need to be renamed
// Create a list of the aliases used by the outer extents
// JoinSymbols have to be treated specially.
List <string> outerExtentAliases = null;
if ((null != _outerExtents) && (0 < _outerExtents.Count))
{
foreach (var outerExtent in _outerExtents.Keys)
{
if (outerExtent is JoinSymbol joinSymbol)
{
foreach (var symbol in joinSymbol.FlattenedExtentList)
{
if (null == outerExtentAliases)
{
outerExtentAliases = new List <string>();
}
outerExtentAliases.Add(symbol.NewName);
}
}
else
{
if (null == outerExtentAliases)
{
outerExtentAliases = new List <string>();
}
outerExtentAliases.Add(outerExtent.NewName);
}
}
}
// An then rename each of the FromExtents we have
// If AllJoinExtents is non-null - it has precedence.
// The new name is derived from the old name - we append an increasing int.
var extentList = AllJoinExtents ?? _fromExtents;
if (null != extentList)
{
foreach (var fromAlias in extentList)
{
if ((null != outerExtentAliases) && outerExtentAliases.Contains(fromAlias.Name))
{
var i = sqlGenerator.AllExtentNames[fromAlias.Name];
string newName;
do
{
++i;
newName = fromAlias.Name + i.ToString(System.Globalization.CultureInfo.InvariantCulture);
}while (sqlGenerator.AllExtentNames.ContainsKey(newName));
sqlGenerator.AllExtentNames[fromAlias.Name] = i;
fromAlias.NewName = newName;
// Add extent to list of known names (although i is always incrementing, "prefix11" can
// eventually collide with "prefix1" when it is extended)
sqlGenerator.AllExtentNames[newName] = 0;
}
// Add the current alias to the list, so that the extents
// that follow do not collide with me.
if (null == outerExtentAliases)
{
outerExtentAliases = new List <string>();
}
outerExtentAliases.Add(fromAlias.NewName);
}
}
#endregion
// Increase the indent, so that the Sql statement is nested by one tab.
writer.Indent += 1; // ++ can be confusing in this context
writer.Write("SELECT ");
if (IsDistinct)
{
writer.Write("DISTINCT ");
}
if (First != null)
{
First.WriteSql(writer, sqlGenerator);
}
if (Skip != null)
{
Skip.WriteSql(writer, sqlGenerator);
}
if ((_select == null) || Select.IsEmpty)
{
Debug.Assert(false); // we have removed all possibilities of SELECT *.
writer.Write("*");
}
else
{
Select.WriteSql(writer, sqlGenerator);
}
writer.WriteLine();
writer.Write("FROM ");
From.WriteSql(writer, sqlGenerator);
if ((_where != null) && !Where.IsEmpty)
{
writer.WriteLine();
writer.Write("WHERE ");
Where.WriteSql(writer, sqlGenerator);
}
if ((_groupBy != null) && !GroupBy.IsEmpty)
{
writer.WriteLine();
writer.Write("GROUP BY ");
GroupBy.WriteSql(writer, sqlGenerator);
}
if ((_orderBy != null) && !OrderBy.IsEmpty && (IsTopMost || First != null || Skip != null))
{
writer.WriteLine();
writer.Write("ORDER BY ");
OrderBy.WriteSql(writer, sqlGenerator);
}
--writer.Indent;
}
/// <summary>
/// gets a list of pages from the WordPress site. results can be controlled with the parameters.
/// </summary>
/// <param name="baseUrl">
/// the web site's address
/// </param>
/// <param name="perPage">
/// how many items per page should be fetched
/// </param>
/// <param name="count">
/// max items to be fetched
/// </param>
/// <param name="pageNr">
/// used for paged requests
/// </param>
/// <param name="order">
/// option to sort the result
/// </param>
public async Task <WordPressEntitySet <Page> > GetPagesAysnc(string baseUrl, int perPage = 10, int count = 10, int pageNr = 1, OrderBy order = OrderBy.Title)
{
if (string.IsNullOrWhiteSpace(baseUrl))
{
throw new NullReferenceException($"parameter {nameof(baseUrl)} MUST not be null or empty");
}
var response = await HttpClientInstance.GetAsync(baseUrl.GetEntitySetApiUrl(Resource.Pages, perPage, count, pageNr, OrderBy.Title));
WordPressEntitySet <Page> result;
if (response.IsSuccessStatusCode)
{
result = new WordPressEntitySet <Page>(response.Content, false, this.ThrowSerializationExceptions);
}
else
{
result = new WordPressEntitySet <Page>(response.Content, true, this.ThrowSerializationExceptions);
}
return(result);
}
public static AsyncExecutionResponseDataCollection Where(Func <AsyncExecutionResponseDataColumns, QueryFilter <AsyncExecutionResponseDataColumns> > where, OrderBy <AsyncExecutionResponseDataColumns> orderBy = null, Database database = null)
{
database = database ?? Db.For <AsyncExecutionResponseData>();
return(new AsyncExecutionResponseDataCollection(database.GetQuery <AsyncExecutionResponseDataColumns, AsyncExecutionResponseData>(where, orderBy), true));
}
public void InitView(RepositoryIdentifier identifier, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, List <ItemType> typesToLoad, ItemAvailability availability, List <StatisticType> displayStatistics, List <long> idRemovedItems, List <long> idSelectedItems = null, OrderBy orderBy = OrderBy.name, Boolean ascending = true)
{
if (SessionTimeout())
{
return;
}
View.IdUserLoader = UserContext.CurrentUserID;
View.AvailableTypes = typesToLoad;
View.CurrentAvailability = availability;
View.IdRemovedItems = idRemovedItems;
View.LoadForModule = false;
View.ModuleCode = ModuleRepository.UniqueCode;
View.RepositoryIdentifier = identifier;
View.isInitialized = true;
View.CurrentAdminMode = adminMode;
View.CurrentShowHiddenItems = showHiddenItems;
View.CurrentDisableNotAvailableItems = disableNotAvailableItems;
if (!typesToLoad.Any(t => t == ItemType.Multimedia || t == ItemType.ScormPackage || t == ItemType.VideoStreaming))
{
displayStatistics.Remove(StatisticType.plays);
displayStatistics.Remove(StatisticType.myplays);
}
if (!typesToLoad.Any(t => t != ItemType.Folder && t != ItemType.Link))
{
displayStatistics.Remove(StatisticType.downloads);
displayStatistics.Remove(StatisticType.mydownloads);
}
View.DisplayStatistics = displayStatistics;
LoadItems(Service.GetPermissions(identifier, UserContext.CurrentUserID), UserContext.CurrentUserID, identifier, adminMode, showHiddenItems, disableNotAvailableItems, typesToLoad, availability, displayStatistics, idRemovedItems, idSelectedItems);
}
public OrderFieldOption(bool orderWith, OrderBy orderInfo)
{
OrderWith = orderWith;
OrderInfo = orderInfo;
}
// Urm... this should be a property surely!! :)
protected void SetSortColumn(WBColumn column)
{
ViewState["SortExpression"] = column.InternalName;
sortColumn = column;
OrderBy.WBxSafeSetSelectedValue(column.InternalName);
}
private void RefreshBoundData()
{
if (IsPostBack)
{
ScriptManager.RegisterStartupScript(this.Page, this.GetType(), "TriggerUpdateFunction", "aspPanelHasUpdated();", true);
}
WBTaxonomy recordsTypes = WBTaxonomy.GetRecordsTypes(SPContext.Current.Site);
WBTaxonomy teams = WBTaxonomy.GetTeams(recordsTypes);
WBQuery query = new WBQuery();
query.AddViewColumn(WBColumn.Title);
query.AddViewColumn(WBColumn.WorkBoxURL);
// query.AddViewColumn(WBColumn.FunctionalArea);
//query.AddViewColumn(WBColumn.ReferenceDate);
//query.AddViewColumn(WBColumn.ReferenceID);
//query.AddViewColumn(WBColumn.SeriesTag);
// query.AddViewColumn(WBColumn.InvolvedTeams);
//List<String> orderByColumnOptions = new List<String>();
//orderByColumnOptions.Add("Title");
checkSortState();
if (sortColumn != null)
{
query.OrderBy(sortColumn, ascending);
}
SelectedWorkBoxes.Columns.Clear();
SelectedWorkBoxes.Columns.Add(WBUtils.StatusIconTemplateField("24"));
SelectedWorkBoxes.Columns.Add(WBUtils.HyperLinkField(WBColumn.Title, WBColumn.WorkBoxURL, sortColumn, ascending, ""));
OrderBy.Items.Clear();
addColumnAsOption(OrderBy, WBColumn.Title);
// ShowResults.Columns.Add(WBUtils.BoundField(WBColumn.FunctionalArea, sortColumn, ascending));
// SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceDate, HorizontalAlign.Center, sortColumn, ascending));
// SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceID, sortColumn, ascending));
// SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.SeriesTag, sortColumn, ascending));
query.AddViewColumn(WBColumn.WorkBoxStatus);
if (StatusCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxStatus, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.WorkBoxStatus);
}
string statusFilter = SelectedWorkBoxStatusFilter;
if (statusFilter != "Any")
{
query.AddEqualsFilter(WBColumn.WorkBoxStatus, statusFilter);
}
query.AddViewColumn(WBColumn.RecordsType);
if (RecordsTypeCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.RecordsType, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.RecordsType);
}
if (LastModifiedCheckBox.Checked)
{
query.AddViewColumn(WBColumn.WorkBoxDateLastModified);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxDateLastModified, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.WorkBoxDateLastModified);
}
if (LastVisitedCheckBox.Checked)
{
query.AddViewColumn(WBColumn.WorkBoxDateLastVisited);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxDateLastVisited, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.WorkBoxDateLastVisited);
}
if (DateCreatedCheckBox.Checked)
{
query.AddViewColumn(WBColumn.WorkBoxDateCreated);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.WorkBoxDateCreated, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.WorkBoxDateCreated);
}
if (ReferenceDateCheckBox.Checked)
{
query.AddViewColumn(WBColumn.ReferenceDate);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceDate, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.ReferenceDate);
}
if (ReferenceIDCheckBox.Checked)
{
query.AddViewColumn(WBColumn.ReferenceID);
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.ReferenceID, HorizontalAlign.Center, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.ReferenceID);
}
query.AddViewColumn(WBColumn.OwningTeam);
if (OwningTeamCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.OwningTeam, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.OwningTeam);
}
query.AddViewColumn(WBColumn.InvolvedTeams);
if (InvolvedTeamsCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.InvolvedTeams, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.InvolvedTeams);
}
query.AddViewColumn(WBColumn.VisitingTeams);
if (VisitingTeamsCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.VisitingTeams, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.VisitingTeams);
}
query.AddViewColumn(WBColumn.InvolvedIndividuals);
if (InvolvedIndividualsCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.InvolvedIndividuals, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.InvolvedIndividuals);
}
query.AddViewColumn(WBColumn.VisitingIndividuals);
if (VisitingIndividualsCheckBox.Checked)
{
SelectedWorkBoxes.Columns.Add(WBUtils.BoundField(WBColumn.VisitingIndividuals, sortColumn, ascending));
addColumnAsOption(OrderBy, WBColumn.VisitingIndividuals);
}
//OrderBy.DataSource = orderByColumnOptions;
//OrderBy.DataBind();
OrderBy.WBxSafeSetSelectedValue(ViewState["SortExpression"] as String);
WBRecordsType recordsType = null;
WBTeam team = WBTeam.GetFromTeamSite(teams, SPContext.Current.Web);
WBLogging.Generic.Unexpected("SelectedInvolvementFilter = " + SelectedInvolvementFilter);
if (team != null)
{
switch (SelectedInvolvementFilter)
{
case FILTER_INVOLVEMENT__OWNS:
{
WBLogging.Debug("Adding a filter for OwningTeam");
query.AddEqualsFilter(WBColumn.OwningTeam, team);
break;
}
case FILTER_INVOLVEMENT__INVOLVED:
{
WBLogging.Debug("Adding a filter for InvolvedTeams");
query.AddEqualsFilter(WBColumn.InvolvedTeams, team);
break;
}
case FILTER_INVOLVEMENT__VISITING:
{
WBLogging.Debug("Adding a filter for VisitingTeams");
query.AddEqualsFilter(WBColumn.VisitingTeams, team);
break;
}
}
}
if (SelectedRecordsTypeGUID != "")
{
recordsType = recordsTypes.GetRecordsType(new Guid(SelectedRecordsTypeGUID));
}
if (recordsType != null)
{
String recordsTypePath = recordsType.FullPath;
//recordsTypePath = recordsTypePath.Substring(1, recordsTypePath.Length - 1);
recordsTypePath = recordsTypePath.Replace("/", " / ");
RecordsTypeSelected.Text = recordsTypePath;
RecordsTypeDescription.Text = recordsType.Description;
WBQueryClause recordsTypeClause = new WBQueryClause(WBColumn.RecordsType, WBQueryClause.Comparators.Equals, recordsType);
recordsTypeClause.UseDescendants = false;
query.AddClause(recordsTypeClause);
}
else
{
RecordsTypeSelected.Text = "No records type selected";
RecordsTypeDescription.Text = "";
}
String cachedDetailsListUrl = WBFarm.Local.OpenWorkBoxesCachedDetailsListUrl;
// OK so this is a general 'recent' query
using (SPWeb cacheWeb = SPContext.Current.Site.OpenWeb(cachedDetailsListUrl))
{
SPList cacheList = cacheWeb.GetList(cachedDetailsListUrl);
SPListItemCollection items = cacheList.WBxGetItems(SPContext.Current.Site, query);
StringBuilder html = new StringBuilder();
foreach (SPListItem item in items)
{
String status = item.WBxGetAsString(WBColumn.WorkBoxStatus);
html.Append("<div class='wbf-icons-view-icon-panel'><div class='wbf-icons-view-icon'><a href='");
html.Append(item.WBxGetAsString(WBColumn.WorkBoxURL)).Append("'>").Append("<img src='").Append(WBUtils.StatusIconImageURL(status, "64")).Append("' alt='Work box icon for: ").Append(item.WBxGetAsString(WBColumn.Title).Replace('\'', ' ')).Append("' />").Append("</a></div><div class='wbf-icons-view-label'><a href='");
html.Append(item.WBxGetAsString(WBColumn.WorkBoxURL)).Append("'>").Append(item.WBxGetAsString(WBColumn.Title)).Append("</a></div></div>\n\n");
}
IconViewLiteral.Text = html.ToString();
DataTable dataTable = cacheList.WBxGetDataTable(SPContext.Current.Site, query);
SelectedWorkBoxes.DataSource = dataTable;
SelectedWorkBoxes.DataBind();
}
}
public static IEnumerable <FileEntry> SortEntries(IEnumerable <FileEntry> entries, OrderBy orderBy)
{
Comparison <FileEntry> sorter;
if (orderBy == null)
{
orderBy = new OrderBy(SortedByType.DateAndTime, false);
}
var c = orderBy.IsAsc ? 1 : -1;
switch (orderBy.SortedBy)
{
case SortedByType.Type:
sorter = (x, y) =>
{
var cmp = 0;
if (x is File && y is File)
{
cmp = c * (FileUtility.GetFileExtension((x.Title)).CompareTo(FileUtility.GetFileExtension(y.Title)));
}
return(cmp == 0 ? x.Title.CompareTo(y.Title) : cmp);
};
break;
case SortedByType.Author:
sorter = (x, y) =>
{
var cmp = c * string.Compare(x.ModifiedByString, y.ModifiedByString);
return(cmp == 0 ? x.Title.CompareTo(y.Title) : cmp);
};
break;
case SortedByType.Size:
sorter = (x, y) =>
{
var cmp = 0;
if (x is File && y is File)
{
cmp = c * ((File)x).ContentLength.CompareTo(((File)y).ContentLength);
}
return(cmp == 0 ? x.Title.CompareTo(y.Title) : cmp);
};
break;
case SortedByType.AZ:
sorter = (x, y) => c *x.Title.CompareTo(y.Title);
break;
case SortedByType.DateAndTime:
sorter = (x, y) =>
{
var cmp = c * DateTime.Compare(x.ModifiedOn, y.ModifiedOn);
return(cmp == 0 ? x.Title.CompareTo(y.Title) : cmp);
};
break;
case SortedByType.New:
sorter = (x, y) =>
{
var isNew = new Func <FileEntry, int>(
val => val is File
? ((((File)val).FileStatus & FileStatus.IsNew) == FileStatus.IsNew ? 1 : 0)
: ((Folder)val).NewForMe);
var isNewSortResult = c * isNew(x).CompareTo(isNew(y));
if (isNewSortResult == 0)
{
var dataTimeSortResult = (-1) * DateTime.Compare(x.ModifiedOn, y.ModifiedOn);
return(dataTimeSortResult == 0
? x.Title.CompareTo(y.Title)
: dataTimeSortResult);
}
return(isNewSortResult);
};
break;
default:
sorter = (x, y) => c *x.Title.CompareTo(y.Title);
break;
}
if (orderBy.SortedBy != SortedByType.New)
{
// folders on top
var folders = entries.OfType <Folder>().Cast <FileEntry>().ToList();
var files = entries.OfType <File>().Cast <FileEntry>().ToList();
folders.Sort(sorter);
files.Sort(sorter);
return(folders.Concat(files));
}
var result = entries.ToList();
result.Sort(sorter);
return(result);
}
public override void Load(int skip, int take, string search = null, object advancedSearch = null, OrderBy orderBy = null)
{
try
{
var wcf = new WcfService.Service();
var objs = wcf.LoadPagamentiUnificatiFatturaAcquisto(skip, take, search, advancedSearch, pagamentoUnificato, orderBy);
Load(objs);
}
catch (Exception ex)
{
UtilityError.Write(ex);
}
}
public static AsyncExecutionResponseDataCollection Where(WhereDelegate <AsyncExecutionResponseDataColumns> where, OrderBy <AsyncExecutionResponseDataColumns> orderBy = null, Database database = null)
{
database = database ?? Db.For <AsyncExecutionResponseData>();
var results = new AsyncExecutionResponseDataCollection(database, database.GetQuery <AsyncExecutionResponseDataColumns, AsyncExecutionResponseData>(where, orderBy), true);
return(results);
}
public IEnumerable <ValidationResult> Validate(
ValidationContext context)
{
if (this.AccountId < 1)
{
yield return(new ValidationResult(
"Invalid account id.",
new[] { "AccountId" }));
}
if (Top < 0)
{
yield return(new ValidationResult(
"Top cannot be negative.",
new[] { "Top" }));
}
if (Skip < 0)
{
yield return(new ValidationResult(
"Skip cannot be negative.",
new[] { "Skip" }));
}
if (string.IsNullOrWhiteSpace(OrderBy))
{
yield break;
}
var orderByPairs = OrderBy.Split(
new[] { ' ' },
StringSplitOptions.RemoveEmptyEntries);
if (!SortProperties.ContainsKey(orderByPairs[0]))
{
var sortPropertyErrorMessage = string.Format(
CultureInfo.CurrentCulture,
"Invalid sort property, only supports \"{0}\".",
string.Join(", ", SortProperties.Keys));
yield return(new ValidationResult(
sortPropertyErrorMessage,
new[] { "OrderBy" }));
}
if (orderByPairs.Length < 2 ||
SortOrders.Contains(
orderByPairs[1],
StringComparer.OrdinalIgnoreCase))
{
yield break;
}
var sortOrderErrorMessage = string.Format(
CultureInfo.CurrentCulture,
"Invalid sort order, only supports \"{0}\".",
string.Join(", ", SortOrders));
yield return(new ValidationResult(
sortOrderErrorMessage,
new[] { "OrderBy" }));
}
public async Task <DataPage <TEntity> > QueryAsync(int pageNumber, int pageLength, Filter <TEntity> filter, OrderBy <TEntity> orderby = null, Func <IQueryable <TEntity>, IQueryable <TEntity> > includes = null)
{
using (var uow = _uowProvider.CreateUnitOfWork(false))
{
var repository = uow.GetRepository <TEntity>();
var startRow = (pageNumber - 1) * pageLength;
var data = await repository.QueryPageAsync(startRow, pageLength, filter.Expression, includes : includes, orderBy : orderby?.Expression);
var totalCount = await repository.CountAsync(filter.Expression);
return(CreateDataPage(pageNumber, pageLength, data, totalCount));
}
}
public static AsyncExecutionResponseData FirstOneWhere(WhereDelegate <AsyncExecutionResponseDataColumns> where, OrderBy <AsyncExecutionResponseDataColumns> orderBy, Database database = null)
{
var results = Top(1, where, orderBy, database);
if (results.Count > 0)
{
return(results[0]);
}
else
{
return(null);
}
}
public ActionResult GetPageData([Range(1, int.MaxValue, ErrorMessage = "页数必须大于0")] int page = 1, [Range(1, int.MaxValue, ErrorMessage = "页大小必须大于0")] int size = 10, OrderBy orderby = OrderBy.ModifyDate, string kw = "", int?cid = null)
{
Expression <Func <Post, bool> > where = p => true;
if (cid.HasValue)
{
where = where.And(p => p.CategoryId == cid.Value);
}
if (!string.IsNullOrEmpty(kw))
{
where = where.And(p => p.Title.Contains(kw) || p.Author.Contains(kw) || p.Email.Contains(kw) || p.Label.Contains(kw) || p.Content.Contains(kw));
}
var list = PostService.GetQuery(where).OrderBy($"{nameof(Post.Status)} desc,{nameof(Post.IsFixedTop)} desc,{orderby.GetDisplay()} desc").ToPagedList <Post, PostDataModel>(page, size, MapperConfig);
foreach (var item in list.Data)
{
item.ModifyDate = item.ModifyDate.ToTimeZone(HttpContext.Session.Get <string>(SessionKey.TimeZone));
item.PostDate = item.PostDate.ToTimeZone(HttpContext.Session.Get <string>(SessionKey.TimeZone));
}
return(Ok(list));
}
/// <summary>
/// This is a shared function that can be used to get a DataTable to bound with a data bound control using a where and order by clause with pagination.
/// </summary>
public static System.Data.DataTable GetDataTable(BaseFilter join, string where, OrderBy orderBy, int pageIndex, int pageSize)
{
UsersRecord[] recs = GetRecords(join, where, orderBy, pageIndex, pageSize);
return UsersTable.Instance.CreateDataTable(recs, null);
}
/// <summary>
/// This is a shared function that can be used to get an array of UsersRecord records using a where and order by clause.
/// </summary>
public static UsersRecord[] GetRecords(BaseFilter join, string where, OrderBy orderBy)
{
return GetRecords(join, where, orderBy, BaseTable.MIN_PAGE_NUMBER, BaseTable.MAX_BATCH_SIZE);
}
public static UsersRecord[] GetRecords(
WhereClause where,
OrderBy orderBy,
int pageIndex,
int pageSize)
{
BaseClasses.Data.BaseFilter join = null;
ArrayList recList = UsersTable.Instance.GetRecordList(join, where.GetFilter(), null, orderBy, pageIndex, pageSize);
return (UsersRecord[])recList.ToArray(Type.GetType("FPCEstimate.Business.UsersRecord"));
}
public Task <PaginatedList <TEntity> > GetAllAsync(int pageIndex, int pageSize, Expression <Func <TEntity, int> > keySelector, Expression <Func <TEntity, bool> > predicate, OrderBy orderBy, params Expression <Func <TEntity, object> >[] includeProperties)
{
return(_repository.GetAllAsync(pageIndex, pageSize, keySelector, predicate, orderBy, includeProperties));
}
public static string GetSum(
BaseColumn col,
BaseFilter join,
WhereClause where,
OrderBy orderBy,
int pageIndex,
int pageSize)
{
SqlBuilderColumnSelection colSel = new SqlBuilderColumnSelection(false, false);
colSel.AddColumn(col, SqlBuilderColumnOperation.OperationType.Sum);
return UsersTable.Instance.GetColumnStatistics(colSel, join, where.GetFilter(), null, orderBy, pageIndex, pageSize);
}
public static IEnumerable <FileEntry> GetEntries(IFolderDao folderDao, Folder parent, FilterType filter, Guid subjectId, OrderBy orderBy, String searchText, int from, int count, out int total)
{
total = 0;
if (parent == null)
{
throw new ArgumentNullException(FilesCommonResource.ErrorMassage_FolderNotFound);
}
var fileSecurity = Global.GetFilesSecurity();
var entries = Enumerable.Empty <FileEntry>();
if (parent.FolderType == FolderType.Projects && parent.ID.Equals(Global.FolderProjects))
{
var apiServer = new ASC.Api.ApiServer();
var apiUrl = String.Format("{0}project/maxlastmodified.json", SetupInfo.WebApiBaseUrl);
var responseApi = JObject.Parse(Encoding.UTF8.GetString(Convert.FromBase64String(apiServer.GetApiResponse(apiUrl, "GET"))));
var projectLastModified = responseApi["response"].Value <String>();
const string projectLastModifiedCacheKey = "documents/projectFolders/projectLastModified";
if (HttpRuntime.Cache.Get(projectLastModifiedCacheKey) == null || !HttpRuntime.Cache.Get(projectLastModifiedCacheKey).Equals(projectLastModified))
{
HttpRuntime.Cache.Insert(projectLastModifiedCacheKey, projectLastModified);
}
var projectListCacheKey = String.Format("documents/projectFolders/{0}", SecurityContext.CurrentAccount.ID);
var fromCache = HttpRuntime.Cache.Get(projectListCacheKey);
if (fromCache == null)
{
apiUrl = String.Format("{0}project/filter.json?sortBy=title&sortOrder=ascending", SetupInfo.WebApiBaseUrl);
responseApi = JObject.Parse(Encoding.UTF8.GetString(Convert.FromBase64String(apiServer.GetApiResponse(apiUrl, "GET"))));
var responseData = responseApi["response"];
if (!(responseData is JArray))
{
return(entries.ToList());
}
var folderIDProjectTitle = new Dictionary <object, String>();
foreach (JObject projectInfo in responseData.Children())
{
var projectID = projectInfo["id"].Value <String>();
var projectTitle = Global.ReplaceInvalidCharsAndTruncate(projectInfo["title"].Value <String>());
int projectFolderID;
JToken projectSecurityJToken;
if (projectInfo.TryGetValue("security", out projectSecurityJToken))
{
var projectSecurity = projectInfo["security"].Value <JObject>();
JToken projectCanFileReadJToken;
if (projectSecurity.TryGetValue("canReadFiles", out projectCanFileReadJToken))
{
if (!projectSecurity["canReadFiles"].Value <bool>())
{
continue;
}
}
}
JToken projectFolderIDJToken;
if (projectInfo.TryGetValue("projectFolder", out projectFolderIDJToken))
{
projectFolderID = projectInfo["projectFolder"].Value <int>();
}
else
{
projectFolderID = (int)FilesIntegration.RegisterBunch("projects", "project", projectID);
}
if (!folderIDProjectTitle.ContainsKey(projectFolderID))
{
folderIDProjectTitle.Add(projectFolderID, projectTitle);
}
HttpRuntime.Cache.Insert("documents/folders/" + projectFolderID.ToString(), projectTitle, null, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(30));
}
var folders = folderDao.GetFolders(folderIDProjectTitle.Keys.ToArray());
folders.ForEach(x =>
{
x.Title = folderIDProjectTitle[x.ID];
x.Access = FileShare.Read;
x.FolderUrl = PathProvider.GetFolderUrl(x);
});
entries = entries.Concat(folders);
if (entries.Any())
{
HttpRuntime.Cache.Insert(projectListCacheKey, entries, new CacheDependency(null, new[] { projectLastModifiedCacheKey }), Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(15));
}
}
else
{
entries = entries.Concat((IEnumerable <FileEntry>)fromCache);
}
entries = FilterEntries(entries, filter, subjectId, searchText);
parent.TotalFiles = entries.Aggregate(0, (a, f) => a + (f is Folder ? ((Folder)f).TotalFiles : 1));
parent.TotalSubFolders = entries.Aggregate(0, (a, f) => a + (f is Folder ? ((Folder)f).TotalSubFolders + 1 : 0));
}
else if (parent.FolderType == FolderType.SHARE)
{
//share
var shared = (IEnumerable <FileEntry>)fileSecurity.GetSharesForMe();
shared = FilterEntries(shared, filter, subjectId, searchText)
.Where(f => f.CreateBy != SecurityContext.CurrentAccount.ID && // don't show my files
f.RootFolderType == FolderType.USER); // don't show common files (common files can read)
entries = entries.Concat(shared);
parent.TotalFiles = entries.Aggregate(0, (a, f) => a + (f is Folder ? ((Folder)f).TotalFiles : 1));
parent.TotalSubFolders = entries.Aggregate(0, (a, f) => a + (f is Folder ? ((Folder)f).TotalSubFolders + 1 : 0));
}
else
{
var folders = folderDao.GetFolders(parent.ID, orderBy, filter, subjectId, searchText).Cast <FileEntry>();
folders = fileSecurity.FilterRead(folders);
entries = entries.Concat(folders);
var files = folderDao.GetFiles(parent.ID, orderBy, filter, subjectId, searchText).Cast <FileEntry>();
files = fileSecurity.FilterRead(files);
entries = entries.Concat(files);
if (ImportConfiguration.SupportInclusion && (parent.ID.Equals(Global.FolderMy) || parent.ID.Equals(Global.FolderCommon)))
{
using (var securityDao = Global.DaoFactory.GetSecurityDao())
using (var providerDao = Global.DaoFactory.GetProviderDao())
{
var providers = providerDao.GetProvidersInfo(parent.RootFolderType);
var folderList = providers
.Select(providerInfo =>
//Fake folder. Don't send request to third party
new Folder
{
ID = providerInfo.RootFolderId,
ParentFolderID = parent.ID,
CreateBy = providerInfo.Owner,
CreateOn = providerInfo.CreateOn,
FolderType = FolderType.DEFAULT,
ModifiedBy = providerInfo.Owner,
ModifiedOn = providerInfo.CreateOn,
ProviderId = providerInfo.ID,
ProviderKey = providerInfo.ProviderKey,
RootFolderCreator = providerInfo.Owner,
RootFolderId = providerInfo.RootFolderId,
RootFolderType = providerInfo.RootFolderType,
Shareable = false,
Title = providerInfo.CustomerTitle,
TotalFiles = 0,
TotalSubFolders = 0
}
)
.Where(fileSecurity.CanRead).ToList();
if (folderList.Any())
{
securityDao.GetPureShareRecords(folderList.Cast <FileEntry>().ToArray())
.Where(x => x.Owner == SecurityContext.CurrentAccount.ID)
.Select(x => x.EntryId).Distinct().ToList()
.ForEach(id =>
{
folderList.First(y => y.ID.Equals(id)).SharedByMe = true;
});
}
var thirdPartyFolder = FilterEntries(folderList, filter, subjectId, searchText);
entries = entries.Concat(thirdPartyFolder);
}
}
}
if (orderBy.SortedBy != SortedByType.New)
{
entries = SortEntries(entries, orderBy);
total = entries.Count();
if (0 < from)
{
entries = entries.Skip(from);
}
if (0 < count)
{
entries = entries.Take(count);
}
}
entries = FileMarker.SetTagsNew(folderDao, parent, entries);
//sorting after marking
if (orderBy.SortedBy == SortedByType.New)
{
entries = SortEntries(entries, orderBy);
total = entries.Count();
if (0 < from)
{
entries = entries.Skip(from);
}
if (0 < count)
{
entries = entries.Take(count);
}
}
return(entries);
}
public BetfairServerResponse<CurrentOrderSummaryReport> ListCurrentOrders(
ISet<string> betIds = null,
ISet<string> marketIds = null,
OrderProjection? orderProjection = null,
TimeRange placedDateRange = null,
TimeRange dateRange = null,
OrderBy? orderBy = null,
SortDir? sortDir = null,
int? fromRecord = null,
int? recordCount = null)
{
return client.ListCurrentOrders(
betIds,
marketIds,
orderProjection,
placedDateRange,
dateRange,
orderBy,
sortDir,
fromRecord,
recordCount).Result;
}
public static ReplicationOperationCollection Where(Func <ReplicationOperationColumns, QueryFilter <ReplicationOperationColumns> > where, OrderBy <ReplicationOperationColumns> orderBy = null, Database database = null)
{
database = database ?? Db.For <ReplicationOperation>();
return(new ReplicationOperationCollection(database.GetQuery <ReplicationOperationColumns, ReplicationOperation>(where, orderBy), true));
}
public string BuildOrderBy(string sql, string orderByColumn, OrderBy orderby = OrderBy.ASC)
{
throw new NotImplementedException();
}
/// <summary>
/// This is a shared function that can be used to get a UsersRecord record using a where and order by clause.
/// </summary>
public static UsersRecord GetRecord(BaseFilter join, string where, OrderBy orderBy)
{
SqlFilter whereFilter = null;
if (where != null && where.Trim() != "")
{
whereFilter = new SqlFilter(where);
}
ArrayList recList = UsersTable.Instance.GetRecordList(join, whereFilter, null, orderBy, BaseTable.MIN_PAGE_NUMBER, BaseTable.MIN_BATCH_SIZE);
UsersRecord rec = null;
if (recList.Count > 0)
{
rec = (UsersRecord)recList[0];
}
return rec;
}
public static ReplicationOperationCollection Where(WhereDelegate <ReplicationOperationColumns> where, OrderBy <ReplicationOperationColumns> orderBy = null, Database database = null)
{
database = database ?? Db.For <ReplicationOperation>();
var results = new ReplicationOperationCollection(database, database.GetQuery <ReplicationOperationColumns, ReplicationOperation>(where, orderBy), true);
return(results);
}
/// <summary>
/// This is a shared function that can be used to get an array of UsersRecord records using a where and order by clause clause with pagination.
/// </summary>
public static UsersRecord[] GetRecords(BaseFilter join, string where, OrderBy orderBy, int pageIndex, int pageSize)
{
SqlFilter whereFilter = null;
if (where != null && where.Trim() != "")
{
whereFilter = new SqlFilter(where);
}
ArrayList recList = UsersTable.Instance.GetRecordList(join, whereFilter, null, orderBy, pageIndex, pageSize);
return (UsersRecord[])recList.ToArray(Type.GetType("FPCEstimate.Business.UsersRecord"));
}
public static ReplicationOperation FirstOneWhere(WhereDelegate <ReplicationOperationColumns> where, OrderBy <ReplicationOperationColumns> orderBy, Database database = null)
{
var results = Top(1, where, orderBy, database);
if (results.Count > 0)
{
return(results[0]);
}
else
{
return(null);
}
}
public static UsersRecord[] GetRecords(
BaseFilter join,
WhereClause where,
OrderBy orderBy,
int pageIndex,
int pageSize,
ref int totalRecords)
{
ArrayList recList = UsersTable.Instance.GetRecordList(join, where.GetFilter(), null, orderBy, pageIndex, pageSize, ref totalRecords);
return (UsersRecord[])recList.ToArray(Type.GetType("FPCEstimate.Business.UsersRecord"));
}
public static ReplicationOperationCollection Top(int count, WhereDelegate <ReplicationOperationColumns> where, OrderBy <ReplicationOperationColumns> orderBy, Database database = null)
{
ReplicationOperationColumns c = new ReplicationOperationColumns();
IQueryFilter filter = where (c);
Database db = database ?? Db.For <ReplicationOperation>();
QuerySet query = GetQuerySet(db);
query.Top <ReplicationOperation>(count);
query.Where(filter);
if (orderBy != null)
{
query.OrderBy <ReplicationOperationColumns>(orderBy);
}
query.Execute(db);
var results = query.Results.As <ReplicationOperationCollection>(0);
results.Database = db;
return(results);
}
public static String[] GetValues(
BaseColumn col,
BaseFilter join,
WhereClause where,
OrderBy orderBy,
int maxItems)
{
// Create the filter list.
SqlBuilderColumnSelection retCol = new SqlBuilderColumnSelection(false, true);
retCol.AddColumn(col);
return UsersTable.Instance.GetColumnValues(retCol, join, where.GetFilter(), null, orderBy, BaseTable.MIN_PAGE_NUMBER, maxItems);
}
public static ReplicationOperationCollection Top(int count, QueryFilter where, OrderBy <ReplicationOperationColumns> orderBy = null, Database database = null)
{
Database db = database ?? Db.For <ReplicationOperation>();
QuerySet query = GetQuerySet(db);
query.Top <ReplicationOperation>(count);
query.Where(where);
if (orderBy != null)
{
query.OrderBy <ReplicationOperationColumns>(orderBy);
}
query.Execute(db);
var results = query.Results.As <ReplicationOperationCollection>(0);
results.Database = db;
return(results);
}
// Fill the UOMID list.
protected virtual void PopulateUOMIDDropDownList(string selectedValue, int maxItems)
{
this.UOMID.Items.Clear();
// 1. Setup the static list items
// Add the Please Select item.
this.UOMID.Items.Insert(0, new ListItem(this.Page.GetResourceValue("Txt:PleaseSelect", "FPCEstimate"), "--PLEASE_SELECT--"));
// 2. Set up the WHERE and the ORDER BY clause by calling the CreateWhereClause_UOMIDDropDownList function.
// It is better to customize the where clause there.
WhereClause wc = CreateWhereClause_UOMIDDropDownList();
// Create the ORDER BY clause to sort based on the displayed value.
OrderBy orderBy = new OrderBy(false, false);
orderBy.Add(UOMTable.UOMName, OrderByItem.OrderDir.Asc);
System.Collections.Generic.IDictionary<string, object> variables = new System.Collections.Generic.Dictionary<string, object> ();
// 3. Read a total of maxItems from the database and insert them into the UOMIDDropDownList.
UOMRecord[] itemValues = null;
if (wc.RunQuery)
{
int counter = 0;
int pageNum = 0;
FormulaEvaluator evaluator = new FormulaEvaluator();
do
{
itemValues = UOMTable.GetRecords(wc, orderBy, pageNum, maxItems);
foreach (UOMRecord itemValue in itemValues)
{
// Create the item and add to the list.
string cvalue = null;
string fvalue = null;
if (itemValue.UOMIDSpecified)
{
cvalue = itemValue.UOMID.ToString().ToString();
if (counter < maxItems && this.UOMID.Items.FindByValue(cvalue) == null)
{
Boolean _isExpandableNonCompositeForeignKey = ScopeTable.Instance.TableDefinition.IsExpandableNonCompositeForeignKey(ScopeTable.UOMID);
if(_isExpandableNonCompositeForeignKey && ScopeTable.UOMID.IsApplyDisplayAs)
fvalue = ScopeTable.GetDFKA(itemValue, ScopeTable.UOMID);
if ((!_isExpandableNonCompositeForeignKey) || (String.IsNullOrEmpty(fvalue)))
fvalue = itemValue.Format(UOMTable.UOMName);
if (fvalue == null || fvalue.Trim() == "")
fvalue = cvalue;
ListItem newItem = new ListItem(fvalue, cvalue);
this.UOMID.Items.Add(newItem);
counter += 1;
}
}
}
pageNum++;
}
while (itemValues.Length == maxItems && counter < maxItems);
}
// 4. Set the selected value (insert if not already present).
if (selectedValue != null &&
selectedValue.Trim() != "" &&
!MiscUtils.SetSelectedValue(this.UOMID, selectedValue) &&
!MiscUtils.SetSelectedDisplayText(this.UOMID, selectedValue))
{
// construct a whereclause to query a record with UOM.UOMID = selectedValue
CompoundFilter filter2 = new CompoundFilter(CompoundFilter.CompoundingOperators.And_Operator, null);
WhereClause whereClause2 = new WhereClause();
filter2.AddFilter(new BaseClasses.Data.ColumnValueFilter(UOMTable.UOMID, selectedValue, BaseClasses.Data.BaseFilter.ComparisonOperator.EqualsTo, false));
whereClause2.AddFilter(filter2, CompoundFilter.CompoundingOperators.And_Operator);
// Execute the query
try
{
UOMRecord[] rc = UOMTable.GetRecords(whereClause2, new OrderBy(false, false), 0, 1);
System.Collections.Generic.IDictionary<string, object> vars = new System.Collections.Generic.Dictionary<string, object> ();
// if find a record, add it to the dropdown and set it as selected item
if (rc != null && rc.Length == 1)
{
string fvalue = ScopeTable.UOMID.Format(selectedValue);
ListItem item = new ListItem(fvalue, selectedValue);
item.Selected = true;
this.UOMID.Items.Add(item);
}
}
catch
{
}
}
}
public List <File> GetFiles(object parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent, bool withSubfolders = false)
{
if (filterType == FilterType.FoldersOnly)
{
return(new List <File>());
}
//Get only files
var files = GetDropboxItems(parentId, false).Select(item => ToFile(item.AsFile));
//Filter
if (subjectID != Guid.Empty)
{
files = files.Where(x => subjectGroup
? CoreContext.UserManager.IsUserInGroup(x.CreateBy, subjectID)
: x.CreateBy == subjectID);
}
switch (filterType)
{
case FilterType.FoldersOnly:
return(new List <File>());
case FilterType.DocumentsOnly:
files = files.Where(x => FileUtility.GetFileTypeByFileName(x.Title) == FileType.Document);
break;
case FilterType.PresentationsOnly:
files = files.Where(x => FileUtility.GetFileTypeByFileName(x.Title) == FileType.Presentation);
break;
case FilterType.SpreadsheetsOnly:
files = files.Where(x => FileUtility.GetFileTypeByFileName(x.Title) == FileType.Spreadsheet);
break;
case FilterType.ImagesOnly:
files = files.Where(x => FileUtility.GetFileTypeByFileName(x.Title) == FileType.Image);
break;
case FilterType.ArchiveOnly:
files = files.Where(x => FileUtility.GetFileTypeByFileName(x.Title) == FileType.Archive);
break;
case FilterType.MediaOnly:
files = files.Where(x =>
{
FileType fileType;
return((fileType = FileUtility.GetFileTypeByFileName(x.Title)) == FileType.Audio || fileType == FileType.Video);
});
break;
case FilterType.ByExtension:
if (!string.IsNullOrEmpty(searchText))
{
searchText = searchText.Trim().ToLower();
files = files.Where(x => FileUtility.GetFileExtension(x.Title).Equals(searchText));
}
break;
}
if (!string.IsNullOrEmpty(searchText))
{
files = files.Where(x => x.Title.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) != -1);
}
if (orderBy == null)
{
orderBy = new OrderBy(SortedByType.DateAndTime, false);
}
switch (orderBy.SortedBy)
{
case SortedByType.Author:
files = orderBy.IsAsc ? files.OrderBy(x => x.CreateBy) : files.OrderByDescending(x => x.CreateBy);
break;
case SortedByType.AZ:
files = orderBy.IsAsc ? files.OrderBy(x => x.Title) : files.OrderByDescending(x => x.Title);
break;
case SortedByType.DateAndTime:
files = orderBy.IsAsc ? files.OrderBy(x => x.ModifiedOn) : files.OrderByDescending(x => x.ModifiedOn);
break;
case SortedByType.DateAndTimeCreation:
files = orderBy.IsAsc ? files.OrderBy(x => x.CreateOn) : files.OrderByDescending(x => x.CreateOn);
break;
default:
files = orderBy.IsAsc ? files.OrderBy(x => x.Title) : files.OrderByDescending(x => x.Title);
break;
}
return(files.ToList());
}
/// <summary>
/// Gets the stored procedure to be called dependant on order by
/// </summary>
/// <param name="orderBy">what order by</param>
/// <returns>Stored procedure name</returns>
string GetReviewForumThreadsStoredProcedure(OrderBy orderBy)
{
string storedProcedure = String.Empty;
switch (orderBy)
{
case OrderBy.DATEENTERED:
{
storedProcedure = "fetchreviewforumthreadsbydateentered";
break;
}
case OrderBy.LASTPOSTED:
{
storedProcedure = "fetchreviewforumthreadsbylastposted";
break;
}
case OrderBy.AUTHORID:
{
storedProcedure = "fetchreviewforumthreadsbyuserid";
break;
}
case OrderBy.AUTHORNAME:
{
storedProcedure = "fetchreviewforumthreadsbyusername";
break;
}
case OrderBy.H2G2ID:
{
storedProcedure = "fetchreviewforumthreadsbyh2g2id";
break;
}
case OrderBy.SUBJECT:
{
storedProcedure = "fetchreviewforumthreadsbysubject";
break;
}
default:
{
throw new DnaException("NO ORDER BY - Order by clause not specified or unknown.");
}
}
return storedProcedure;
}
public IZendeskQuery <T> WithOrdering(OrderBy orderBy, Order order)
{
_orderBy = orderBy;
_order = order;
return(this);
}
public override SqlStatement GetGroupByStatement(Condition iwc, OrderBy order, string columnName)
{
return base.GetGroupByStatement(iwc && _colExp, order, columnName);
}
public async Task <PagedResult <Core.Domain.Task> > GetTasks(int start, int count, string sortField, OrderBy sortType)
{
return(await PagedResult <Core.Domain.Task> .CreateAsync(_context.Tasks.AsQueryable(), start, count, sortField, sortType));
}
public IEnumerable<Thread> GetPagedThreads(int forumID, int pageNumber, int pageSize, OrderBy orderBy = OrderBy.Date, Direction direction = Direction.Descending)
{
IEnumerable<Thread> forumThreads = _threadRepository.Where(item => item.ForumID.Equals(forumID));
forumThreads = forumThreads.OrderByDescending(item => item.Type).ThenByDescending(x => x.LastPost.Date);
if (direction == Direction.Ascending)
forumThreads.Reverse();
forumThreads = forumThreads.TakePage(pageNumber, pageSize);
return forumThreads.ToList();
}
/// <summary>
/// This is a shared function that can be used to get a DataTable to bound with a data bound control using a where and order by clause with pagination.
/// </summary>
public static System.Data.DataTable GetDataTable(BaseFilter join, string where, OrderBy orderBy, int pageIndex, int pageSize)
{
UsersRecord[] recs = GetRecords(join, where, orderBy, pageIndex, pageSize);
return(UsersTable.Instance.CreateDataTable(recs, null));
}
