public object FindAndRemoveAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy)
{
foreach (var document in QueryCompiler.Query(Documents, Documents2, query, sortBy, 0, 0))
{
RemoveDocument(document);
return(BsonSerializer.Deserialize(document, documentType));
}
return(null);
}
private List <BsonValue> CollectSelfLinks(string resourceType, IEnumerable <Criterium> criteria, SearchResults results, int level, IList <Tuple <string, SortOrder> > sortItems)
{
Dictionary <Criterium, Criterium> closedCriteria = CloseChainedCriteria(resourceType, criteria, results, level);
//All chained criteria are 'closed' or 'rolled up' to something like subject IN (id1, id2, id3), so now we AND them with the rest of the criteria.
IMongoQuery resultQuery = CreateMongoQuery(resourceType, results, level, closedCriteria);
IMongoSortBy sortBy = CreateSortBy(sortItems);
return(CollectSelfLinks(resultQuery, sortBy));
}
/// <summary>
/// Sets the sort order for the server to sort the documents by before returning them.
/// </summary>
/// <param name="sortBy">The sort order.</param>
/// <returns>The cursor (so you can chain method calls to it).</returns>
public virtual MongoCursor SetSortOrder(IMongoSortBy sortBy)
{
if (sortBy == null)
{
throw new ArgumentNullException("sortBy");
}
if (_isFrozen) { ThrowFrozen(); }
SetOption("$orderby", BsonDocumentWrapper.Create(sortBy));
return this;
}
/// <summary>
/// Sets the sort order for the server to sort the documents by before returning them.
/// </summary>
/// <param name="sortBy">The sort order.</param>
/// <returns>The cursor (so you can chain method calls to it).</returns>
public virtual MongoCursor SetSortOrder(
IMongoSortBy sortBy
)
{
if (isFrozen)
{
ThrowFrozen();
}
SetOption("$orderby", BsonDocumentWrapper.Create(sortBy));
return(this);
}
public override FindAndModifyResult FindAndRemove(IMongoQuery query, IMongoSortBy sortBy)
{
if (writer != null)
{
this.writer.WriteLine("FindAndRemove Query:");
this.writer.WriteLine(query == null ? "No Query" : query.ToString());
this.writer.WriteLine("SortBy: " + (sortBy == null ? "Nothing" : sortBy.ToString()));
this.writer.WriteLine();
this.writer.Flush();
}
return(mCollection.FindAndRemove(query, sortBy));
}
/// <summary>
/// Find and modify
/// </summary>
/// <typeparam name="T">Data Type</typeparam>
/// <param name="query">Query</param>
/// <param name="sortBy">Sort by</param>
/// <param name="update">update</param>
/// <returns></returns>
public T FindAndModify <T>(IMongoQuery query, IMongoSortBy sortyBy, IMongoUpdate update) where T : class, new()
{
T obj = null;
var result = this.GetCollection <T>().FindAndModify(query, sortyBy, update, true);
if (result.Ok && result.ModifiedDocument != null)
{
obj = result.GetModifiedDocumentAs <T>();
}
return(obj);
}
//
// GET: /Cars/
public ActionResult Index()
{
MongoCursor <Car> carsInDbCursor = CarRentalContext.Cars.FindAll();
/* LINQ example
* IEnumerable<Car> cars = carsInDbCursor.AsQueryable().Where(c => c.NumberOfDoors > 3); */
IMongoSortBy sortByCars = SortBy <Car> .Descending(c => c.Make);
carsInDbCursor.SetSortOrder(sortByCars);
AggregateExamples();
return(View(carsInDbCursor.ConvertAllToViewModels()));
}
private List <BsonValue> CollectSelfLinks(IMongoQuery query, IMongoSortBy sortBy)
{
MongoCursor <BsonDocument> cursor = _collection.Find(query);
if (sortBy != null)
{
cursor.SetSortOrder(sortBy);
}
cursor = cursor.SetFields(InternalField.SELFLINK);
return(cursor.Select(doc => doc.GetValue(InternalField.SELFLINK)).ToList());
}
/// <summary>
/// 通过Json查询数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jsonWhere"></param>
/// <param name="num">返回的数量</param>
/// <param name="orderby">排序</param>
/// <returns></returns>
public T[] QueryEntitys <T>(string jsonWhere, int num = 50, IMongoSortBy orderby = null)
{
var c = GetCollection <T>();
var q = c.FindAs <T>(new QueryDocument(BsonDocument.Parse(jsonWhere)));
if (orderby != null)
{
return(q.SetSortOrder(orderby).Take(num).ToArray());
}
return(q.Take(num).ToArray());
}
public object FindAndModifyAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, IMongoFields fields, bool returnNew, bool upsert, out UpdateResult result)
{
foreach (var document in QueryCompiler.Query(Documents, Documents2, query, sortBy, 0, 0))
{
// if old is needed then deep(!) clone before update //_131103_185751
BsonDocument output = null;
if (!returnNew)
{
output = document.DeepClone().AsBsonDocument;
}
UpdateDocument(document, UpdateCompiler.GetFunction((IConvertibleToBsonDocument)update, null, false));
if (returnNew)
{
output = document;
}
// project
if (fields != null)
{
var project = FieldCompiler.GetFunction(fields);
output = project(output);
}
// if old is needed then return it as already deep cloned
result = new SimpleUpdateResult(1, true);
if (!returnNew && documentType == typeof(Dictionary))
{
return(new Dictionary(output));
}
else
{
// deserialize to required type
return(BsonSerializer.Deserialize(output, documentType));
}
}
// not found, insert
if (upsert)
{
var document = InsertNewDocument(query, update);
result = new SimpleUpdateResult(1, false);
return(returnNew ? BsonSerializer.Deserialize(document, documentType) : null);
}
result = new SimpleUpdateResult(0, false);
return(null);
}
protected virtual IMongoSortBy BuildSortExpression(TFilter filter)
{
IMongoSortBy sort = SortBy.Null;
if (filter.Ordering.Any())
{
var builder = new SortByBuilder();
foreach (var order in filter.Ordering)
{
builder = order.Desc ? builder.Descending(order.Key) : builder.Ascending(order.Key);
}
sort = builder;
}
return(sort);
}
/// <summary>
/// Query data
/// <remarks>if pageSize == 0, return all of the data contains of this query</remarks>
/// </summary>
/// <typeparam name="T">data type</typeparam>
/// <param name="query">query</param>
/// <param name="sortBy">sort by fields</param>
/// <param name="pageIndex">current page index. start with zero</param>
/// <param name="pageSize">size of page</param>
/// <returns>Cursor</returns>
public MongoCursor <T> Query <T>(IMongoQuery query, IMongoSortBy sortBy, int pageIndex, int pageSize) where T : class, new()
{
var cursor = this.GetCollection <T>().Find(query);
if (sortBy != null)
{
cursor = cursor.SetSortOrder(sortBy);
}
if (pageSize != 0)
{
cursor.SetSkip(pageIndex * pageSize).SetLimit(pageSize);
}
return(cursor);
}
/// <summary>
/// [MongoDB] 通用根据查询条件删除首个匹配的文档对象
/// </summary>
/// <typeparam name="TDocument">泛型类型</typeparam>
/// <param name="queryList">查询实体集合</param>
/// <param name="sortBy">排序实体 创建示例：SortBy.Descending("Title") OR SortBy.Descending("Title").Ascending("Author")</param>
/// <returns></returns>
public static bool FindAndRemove <TDocument>(IList <IMongoQuery> queryList, IMongoSortBy sortBy)
{
try
{
var findAndRemoveArgs = new FindAndRemoveArgs {
Query = GetIMongoQueryBy(queryList), SortBy = sortBy
};
var result = GetCollection <TDocument>(typeof(TDocument).Name).FindAndRemove(findAndRemoveArgs);
}
catch (Exception)
{
return(false);
}
return(true);
}
public object FindAndModifyAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, IMongoFields fields, bool returnNew, bool upsert, out UpdateResult result)
{
var args = new FindAndModifyArgs();
args.Query = query;
args.SortBy = sortBy;
args.Update = update;
args.Fields = fields;
args.Upsert = upsert;
args.VersionReturned = returnNew ? FindAndModifyDocumentVersion.Modified : FindAndModifyDocumentVersion.Original;
var r = _this.FindAndModify(args);
result = new FindAndModifyUpdateResult(r);
return(r.GetModifiedDocumentAs(documentType));
}
public T FindAndRemove(IMongoQuery query, IMongoSortBy sortBy)
{
Exception a;
object b;
if (FaultDispatcher.Trap(out a, out b))
{
if (a != null)
{
throw a;
}
return((T)b);
}
return(this.repository.FindAndRemove(query, sortBy));
}
public T FindAndModify(IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, bool returnNew, bool upsert)
{
Exception a;
object b;
if (FaultDispatcher.Trap(out a, out b))
{
if (a != null)
{
throw a;
}
return((T)b);
}
return(this.repository.FindAndModify(query, sortBy, update, returnNew, upsert));
}
/// <summary>
/// 分页查询App联系人信息
/// </summary>
/// <returns></returns>
public List <AppContactsInfo> GetPageListAppContacts(IMongoQuery query, IMongoSortBy sortBy, int pageNo, int pageSize, out long total)
{
total = 0;
List <AppContactsInfo> list = new List <AppContactsInfo>();
try
{
total = DBContext.Mongo.Count(DBName_BSTAM, TableName_AppContacts, query);
list = DBContext.Mongo.GetPageList <AppContactsInfo>(DBName_BSTAM, TableName_AppContacts, query, pageNo, pageSize, sortBy);
}
catch (Exception ex)
{
LogManager.Error(ex);
}
return(list);
}
/// <summary>
/// 分页获取数据
/// </summary>
/// <param name="query"></param>
/// <param name="sortBy"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="fields"></param>
/// <returns></returns>
public List <T> Find(IMongoQuery query, IMongoSortBy sortBy, int pageIndex,
int pageSize, params string[] fields)
{
var doc = _collection.FindAs <T>(query);
if (fields != null)
{
doc.SetFields(fields);
}
if (sortBy != null)
{
doc.SetSortOrder(sortBy);
}
doc.Skip = pageIndex * pageSize - pageSize;
doc.Limit = pageSize;
return(doc.ToList());
}
/// <summary>
/// [MongoDB] 通用查询方法
/// </summary>
/// <typeparam name="T">泛型实体类</typeparam>
/// <param name="queries">MongoDB 查询条件对象集合</param>
/// <param name="sortBy">MongoDB 排序对象</param>
/// <returns></returns>
public static T FindOneAs <T>(List <IMongoQuery> queries, IMongoSortBy sortBy)
{
var result = default(T);
try
{
result = GetCollection <T>().FindOneAs <T>(new FindOneArgs()
{
Query = GetIMongoQueryBy(queries), SortBy = sortBy
});
}
catch (Exception)
{
//todo:
}
return(result);
}
/// <summary>
/// Find all documents in this collection as TDefaultDocuments.
/// </summary>
/// <typeparam name="T">The default document type for this collection.</typeparam>
/// <param name="collection">An instance of MongoCollection.</param>
/// <param name="sort">The sort by clause</param>
/// <param name="limit">The number of items to return.</param>
/// <param name="skip">The number of items to skip.</param>
/// <returns>The collection of documents.</returns>
public virtual IEnumerable <T> FindAll <T>(MongoCollection <T> collection, IMongoSortBy sort = null, int limit = -1, int skip = 0)
{
lock (_lockObject)
{
// If no sort has been specified.
if (sort == null)
{
if (limit > -1 && skip > 0)
{
return(collection.FindAll().SetSkip(skip).SetLimit(limit));
}
else if (skip > 0)
{
return(collection.FindAll().SetSkip(skip));
}
else if (limit > -1)
{
return(collection.FindAll().SetLimit(limit));
}
else
{
return(collection.FindAll());
}
}
else
{
if (limit > -1 && skip > 0)
{
return(collection.FindAll().SetSortOrder(sort).SetSkip(skip).SetLimit(limit));
}
else if (skip > 0)
{
return(collection.FindAll().SetSortOrder(sort).SetSkip(skip));
}
else if (limit > -1)
{
return(collection.FindAll().SetSortOrder(sort).SetLimit(limit));
}
else
{
return(collection.FindAll().SetSortOrder(sort));
}
}
}
}
public override FindAndModifyResult FindAndModify(
IMongoQuery query,
IMongoSortBy sortBy,
IMongoUpdate update,
bool returnNew,
bool upsert)
{
if (writer != null)
{
this.writer.WriteLine("FindAndModify Query:");
this.writer.WriteLine(query == null ? "No Query" : query.ToString());
this.writer.WriteLine("SortBy: " + (sortBy == null ? "Nothing" : sortBy.ToString()));
this.writer.WriteLine("Update: " + (update == null ? "Nothing" : update.ToString()));
this.writer.WriteLine();
this.writer.Flush();
}
return(mCollection.FindAndModify(query, sortBy, update, returnNew, upsert));
}
public MongoCursor FindAll(string collectionName, IMongoFields fields, IMongoSortBy sortBy)
{
var c = GetExistingCollection(collectionName);
var q = c.FindAll();
if (fields != null)
{
q.SetFields(fields);
}
if (sortBy != null)
{
q.SetSortOrder(sortBy);
}
return(q);
}
public static void Test_telechargement_plus_loadPostFromWeb_05(string minTime = null, bool reload = false, bool loadImage = false)
{
TelechargementPlusInit();
MongoCollection<BsonDocument> collection = TelechargementPlus_GetMongoCollection();
IMongoQuery query = null;
if (minTime != null)
// minTime "2013-11-07 14:00"
query = Query.GTE("creationDate", new BsonDateTime(DateTime.ParseExact(minTime, "yyyy-MM-dd HH:mm", CultureInfo.CurrentCulture)));
IMongoSortBy sort = SortBy.Descending("creationDate");
MongoCursor<BsonDocument> cursor;
if (query != null)
cursor = collection.Find(query);
else
cursor = collection.FindAll();
var q = from doc in cursor.SetSortOrder(sort) select from print in TelechargementPlus_LoadPost_v1.GetPrints(doc.zGetString("url"), reload: reload, loadImage: loadImage) select print;
//RunSource.CurrentRunSource.View(q);
q.zView();
}
/// <summary>
/// Gets list of documents related to specified query parameters
/// </summary>
/// <param name="sortBy">The sort by.</param>
/// <param name="skip">The skip.</param>
/// <param name="limit">The limit.</param>
/// <returns></returns>
public IList <TDocument> Get(IMongoSortBy sortBy = null, int?skip = null, int?limit = null)
{
var cursor = Collection.FindAllAs <TDocument>();
if (skip.HasValue)
{
cursor.SetSkip(skip.Value);
}
if (limit.HasValue)
{
cursor.SetLimit(limit.Value);
}
if (sortBy != null)
{
cursor.SetSortOrder(sortBy);
}
return(cursor.ToList());
}
public static void Test_telechargement_plus_loadPostFromWeb_04(string minTime = null)
{
MongoCollection<BsonDocument> collection = TelechargementPlus_GetMongoCollection();
//IMongoQuery query = new QueryDocument { { "_id", 91230 } };
IMongoQuery query = null;
if (minTime != null)
// minTime "2013-11-07 14:00"
query = Query.GTE("creationDate", new BsonDateTime(DateTime.ParseExact(minTime, "yyyy-MM-dd HH:mm", CultureInfo.CurrentCulture)));
IMongoSortBy sort = SortBy.Descending("creationDate");
//QueryDocument query = null;
MongoCursor<BsonDocument> cursor;
if (query != null)
cursor = collection.Find(query);
else
cursor = collection.FindAll();
var q = from doc in cursor.SetSortOrder(sort) select new { _id = doc.zGetInt("_id"), creationDate = doc.zGetDateTime("creationDate") };
//RunSource.CurrentRunSource.View(q);
q.zView();
}
public List <UserEntity> GetModelList(Dictionary <string, string> where, string orderBy, string desc, int page, int pageSize)
{
try
{
IMongoQuery query = null;
IMongoSortBy sortBy = SortBy.Ascending(orderBy);
if (desc.Equals("desc", StringComparison.InvariantCultureIgnoreCase))
{
sortBy = SortBy.Descending(orderBy);
}
return(DBContext.Mongo.GetPageList <UserEntity>(DBContext.DbName, COL, query, page, pageSize, sortBy, null));
}
catch (Exception ex)
{
LogManager.Error(ex);
}
return(new List <UserEntity>());
}
/// <summary>
/// Gets list of documents related to specified query parameters
/// </summary>
/// <param name="predicate">The predicate.</param>
/// <param name="sortBy">The sort by.</param>
/// <param name="skip">The skip.</param>
/// <param name="limit">The limit.</param>
/// <returns></returns>
public IList <TDocument> Get(Expression <Func <TDocument, bool> > predicate, IMongoSortBy sortBy = null, int?skip = null, int?limit = null)
{
var cursor = Collection.FindAs <TDocument>(Query <TDocument> .Where(predicate));
if (skip.HasValue)
{
cursor.SetSkip(skip.Value);
}
if (limit.HasValue)
{
cursor.SetLimit(limit.Value);
}
if (sortBy != null)
{
cursor.SetSortOrder(sortBy);
}
return(cursor.ToList());
}
public object FindAndModifyAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, IMongoFields fields, bool returnNew, bool upsert, out UpdateResult result)
{
foreach (var document in QueryCompiler.Query(Documents, Documents2, query, sortBy, 0, 0))
{
// if old is needed then deep(!) clone before update //_131103_185751
BsonDocument output = null;
if (!returnNew)
output = document.DeepClone().AsBsonDocument;
UpdateDocument(document, UpdateCompiler.GetFunction((IConvertibleToBsonDocument)update, null, false));
if (returnNew)
output = document;
// project
if (fields != null)
{
var project = FieldCompiler.GetFunction(fields);
output = project(output);
}
// if old is needed then return it as already deep cloned
result = new SimpleUpdateResult(1, true);
if (!returnNew && documentType == typeof(Dictionary))
return new Dictionary(output);
else
// deserialize to required type
return BsonSerializer.Deserialize(output, documentType);
}
// not found, insert
if (upsert)
{
var document = InsertNewDocument(query, update);
result = new SimpleUpdateResult(1, false);
return returnNew ? BsonSerializer.Deserialize(document, documentType) : null;
}
result = new SimpleUpdateResult(0, false);
return null;
}
/// <summary>
/// Get Entity List(paging、sorting)
/// </summary>
/// <typeparam name="T">Entity</typeparam>
/// <param name="totalCount">data'count</param>
/// <param name="query">QueryConditions</param>
/// <param name="sort">SortConditions</param>
/// <param name="pageIndex">PageIndex</param>
/// <param name="pageSize">PageSize</param>
/// <param name="isContainDeleted"></param>
/// <returns></returns>
public List <T> GetAllList <T>(ref int totalCount, IMongoQuery query = null, IMongoSortBy sort = null,
int pageIndex = 0, int pageSize = 0, bool isContainDeleted = false)
{
MongoCollection <T> collection = MongoPooledConnection.ReadDatabase.GetCollection <T>(typeof(T).Name);
sort = sort ?? new SortByDocument();
pageSize = pageSize == 0 ? 1 : pageSize;
totalCount =
(int)(query == null
? (isContainDeleted
? collection.FindAll()
: collection.Find(Query.EQ("Status", 0)))
: (isContainDeleted
? collection.Find(query)
: collection.Find(Query.And(query, Query.EQ("Status", 0))))).Count();
if (pageIndex < 1)
{
return((query == null
? (isContainDeleted
? collection.FindAll()
: collection.Find(Query.EQ("Status", 0)))
: (isContainDeleted
? collection.Find(query)
: collection.Find(Query.And(query, Query.EQ("Status", 0))))).SetSortOrder(sort)
.ToList());
}
return
((query == null
? (isContainDeleted ? collection.FindAll() : collection.Find(Query.EQ("Status", 0)))
: (isContainDeleted
? collection.Find(query)
: collection.Find(Query.And(query, Query.EQ("Status", 0))))).SetSortOrder(sort)
.SetSkip(
(pageIndex - 1) *
pageSize)
.SetLimit(pageSize)
.ToList());
}
/// <summary>
/// Get Entity List(paging、sorting)
/// </summary>
/// <typeparam name="T">Entity</typeparam>
/// <param name="totalCount">data'count</param>
/// <param name="query">QueryConditions</param>
/// <param name="sort">SortConditions</param>
/// <param name="pageIndex">PageIndex</param>
/// <param name="pageSize">PageSize</param>
/// <returns></returns>
public List <T> GetAllList <T>(ref int totalCount, IMongoQuery query = null, IMongoSortBy sort = null,
int pageIndex = 0, int pageSize = 0)
{
try
{
MongoCollection <T> collection = BaseDB.CreateInstance().GetCollection <T>(typeof(T).Name);
sort = sort ?? new SortByDocument();
pageSize = (pageSize == 0) ? 1 : pageSize;
totalCount =
(int)
(query == null
? collection.Find(Query.EQ("Status", 0)).Count()
: collection.Find(Query.And(query, Query.EQ("Status", 0))).Count());
if (pageIndex < 1)
{
return(((query == null) ? collection.FindAll() : collection.Find(query)).SetSortOrder(sort).ToList());
}
else
{
return
(((query == null)
? collection.Find(Query.EQ("Status", 0))
: collection.Find(Query.And(query, Query.EQ("Status", 0)))).SetSortOrder(sort).SetSkip(
(pageIndex - 1) * pageSize).SetLimit(pageSize).ToList());
}
}
catch
{
return(new List <T>());
}
finally
{
BaseDB.MongoService.Disconnect();
}
}
public void UpdateJobByIDAndRemove()
{
string dt = DateTime.Now.ToString();
ObjectId oid = ObjectId.GenerateNewId();
Job job = new Job
{
_id = oid
,
ScriptFileName = "scriptname.bteq"
,
ProjectName = "TestRun"
,
LastModified = DateTime.Now.AddHours(-1).ToString()
};
MongoDatabase localDB = MongoSrvr.GetDatabase("PMG");
MongoCollection <Job> jobCol = localDB.GetCollection <Job>("Test");
WriteConcernResult res = jobCol.Insert <Job>(job);
Assert.IsTrue(res.Ok);
IMongoQuery query = Query.EQ("_id", oid);
IMongoSortBy sortBy = SortBy.Null;
IMongoUpdate update = Update.Set("LastModified", dt);
MongoCollection jobsColl = localDB.GetCollection("Test");
FindAndModifyResult result = jobsColl.FindAndModify(query, sortBy, update, true);
Job modJob = result.GetModifiedDocumentAs <Job>();
Assert.AreEqual(modJob.LastModified, dt);
//cleanup
res = jobCol.Remove(Query.EQ("_id", oid), RemoveFlags.Single, WriteConcern.Acknowledged);
Assert.IsTrue(res.Ok);
}
public BsonDocument[] ListPaggingBSon(string objectName, IMongoQuery query, IMongoSortBy sort, int pageSize, int pageNum, out long totalSize)
{
int skip = (pageNum - 1) * pageSize;
var list = Database.GetCollection(objectName).Find(query).SetSortOrder(sort).Skip(skip).Take(pageSize);
totalSize = Database.GetCollection(objectName).Find(query).Count();
return list.ToArray();
}
public void SetSelector(TQItemSelector selector)
{
this.selector = selector;
this.QueryFeature = MongoSelector.GetQuery(this.selector);
this.SortFeature = MongoSelector.GetSort(this.selector);
OptimiseForSelector();
}
public IEnumerable<User> Search(IMongoQuery query, IMongoSortBy sort, int pageIndex, int pageSize, out long totalRows)
{
return MainDb.Instant.Find<User>(query, sort, pageIndex, pageSize, out totalRows);
}
/// <summary>
/// Sets the sort order (useful in combination with SetLimit, your map function should not depend on the order the documents are sent to it).
/// </summary>
/// <param name="sortBy">The sort order.</param>
/// <returns>The builder (so method calls can be chained).</returns>
public MapReduceOptionsBuilder SetSortOrder(IMongoSortBy sortBy)
{
_document["sort"] = BsonDocumentWrapper.Create(sortBy);
return this;
}
/// <summary>
/// GEP 상품 조회
/// </summary>
/// <param name="query"></param>
/// <param name="take"></param>
/// <param name="skip"></param>
/// <param name="sort"></param>
/// <returns></returns>
public MongoPagingResult<GepItemsData> List(IMongoQuery query, int take, int skip, IMongoSortBy sort)
{
return new GEPMongoDacHelper("gep", "gep_items").FindByPaging<GepItemsData>(query, take, skip, sort);
}
public object FindAndModifyAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, IMongoFields fields, bool returnNew, bool upsert, out UpdateResult result)
{
var r = _this.FindAndModify(query, sortBy, update, fields, returnNew, upsert);
result = new FindAndModifyUpdateResult(r);
return r.GetModifiedDocumentAs(documentType);
}
/// <summary>
/// Sets the sort order (useful in combination with SetLimit, your map function should not depend on the order the documents are sent to it).
/// </summary>
/// <param name="sortBy">The sort order.</param>
/// <returns>The builder (so method calls can be chained).</returns>
public static MapReduceOptionsBuilder SetSortOrder(IMongoSortBy sortBy)
{
return new MapReduceOptionsBuilder().SetSortOrder(sortBy);
}
public dynamic[] ListPagging(string objectName, IMongoQuery query, IMongoSortBy sort, int pageSize, int pageNum, out long totalSize)
{
BsonDocument[] list = ListPaggingBSon(objectName, query, sort, pageSize, pageNum, out totalSize);
List<DynamicObj> lstObj = new List<DynamicObj>();
foreach (BsonDocument doc in list)
{
lstObj.Add(new DynamicObj(doc));
}
return lstObj.ToArray();
}
private List<BsonDocument> ListDocument(string collectionName, IMongoQuery query, IMongoSortBy sort)
{
var doc = Database.GetCollection(collectionName).Find(query).SetSortOrder(sort).ToList();
return doc;
}
/// <summary>
/// eBay 상품 리스트 조회 (페이징)
/// </summary>
public MongoPagingResult<eBayItemsData> List(IMongoQuery query, int take, int skip, IMongoSortBy sort)
{
return new GEPMongoDacHelper(dataBase, collection).FindByPaging<eBayItemsData>(query, take, skip, sort);
}
public MapReduceOptionsBuilder SetSortOrder(
IMongoSortBy sortBy
)
{
document["sort"] = BsonDocument.Wrap(sortBy);
return this;
}
internal MongoPagingResult<EBayCancelGridT> GetCancelGridData(IMongoQuery query, int take, int skip, IMongoSortBy sort)
{
return new GEPMongoDacHelper(GepMongoEnv.ConfigSection.GEP, GepMongoEnv.Database.GEP_EBAY, GepMongoEnv.Collection.EBAY_CANCEL)
.FindByPaging<EBayCancelGridT>(query, take, skip, sort);
}
/// <summary>
/// 查询指定类型的数据库表，返回结果列表，可以指定查询条件（指定某字段等于什么值）
/// </summary>
/// <param name="skip">略过前面 skip 条记录</param>
/// <param name="limit">返回总数限制为最多 limit 条</param>
/// <param name="conditions">查询条件：Query.EQ("登录信息.密码", "abc")搜寻所有密码设置为"abc"的用户</param>
/// <param name="modifiedDescending">默认按照修改时间倒序排序，为 true 时忽略 sorting 参数</param>
/// <param name="sorting">指定排序规则 new IMongoSortBy(){ { "登录信息.显示名", true }, { "登录信息.密码", false } }
/// 按照【登录信息.显示名】升序排列为主排序规则，按照【登录信息.密码】降序为次要排序规则</param>
/// <param name="includeDeleted">查找范围包括标记为【已删除】的记录。默认不包括。</param>
/// <returns>特定类型的可枚举对象，用 foreach 遍历</returns>
public static IEnumerable<ApiControllers.ExpertController.Api登录信息> 查询Api登录信息(int skip, int limit, IMongoQuery conditions = null, bool modifiedDescending = true, IMongoSortBy sorting = null, bool includeDisabled = true, bool includeDeleted = false)
{
return Mongo.查询<ApiControllers.ExpertController.Api登录信息>(skip, limit, conditions, modifiedDescending, sorting, includeDisabled, includeDeleted);
}
/// <summary>
/// An generalized version of the <see cref="FindUsersByName"/> and <see cref="FindUsersByEmail"/> methods that:
/// <list type="bullet">
/// <item><description>allows arbitrary fields to be searched,</description></item>
/// <item><description>allows more granular control over chunk of records is returned,</description></item>
/// <item><description>returns a more LINQ-friendly <see cref="IEnumerable{MembershipUser}"/> object.</description></item>
/// </list>
/// </summary>
/// <param name="query"></param>
/// <param name="sortBy"></param>
/// <param name="skip"></param>
/// <param name="take"></param>
/// <param name="totalRecords"></param>
/// <returns></returns>
public IEnumerable<MembershipUser> FindUsers(IMongoQuery query, IMongoSortBy sortBy, int skip, int take, out int totalRecords)
{
if (skip < 0) {
var message = ProviderResources.SkipMustBeGreaterThanOrEqualToZero;
throw TraceException("FindUsers", new ArgumentException(message, "skip"));
}
if (take < 0) {
var message = ProviderResources.TakeMustBeGreaterThanOrEqualToZero;
throw TraceException("FindUsers", new ArgumentException(message, "take"));
}
var users = GetUserCollection();
var matches = users.Find(query).SetSkip(skip).SetLimit(take);
if (sortBy != null) {
matches.SetSortOrder(sortBy);
}
totalRecords = matches.Count();
return matches.Select(m => m.ToMembershipUser(Name));
}
public static IEnumerable<BsonDocument> 列表供应商服务记录(int skip, int limit, IMongoFields fields, IMongoQuery conditions = null, bool modifiedDescending = true, IMongoSortBy sorting = null, bool includeDisabled = true, bool includeDeleted = false)
{
return Mongo.列表<供应商服务记录>(skip, limit, fields, conditions, modifiedDescending, sorting, includeDisabled, includeDeleted);
}
internal static IEnumerable<BsonDocument> Query(IEnumerable<BsonDocument> documents, IDictionary<BsonValue, BsonDocument> dictionary, IMongoQuery query, IMongoSortBy sortBy, int skip, int first)
{
var queryDocument = (BsonDocument)query;
BsonValue idSelector;
if (dictionary != null && queryDocument != null && queryDocument.TryGetValue(MyValue.Id, out idSelector))
{
documents = OptimisedDocuments(dictionary, idSelector);
if (documents == null)
return new BsonDocument[] { };
}
var queryableData = documents.AsQueryable<BsonDocument>();
var predicateBody = GetExpression(queryDocument);
var expression = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { queryableData.ElementType },
queryableData.Expression,
Expression.Lambda<Func<BsonDocument, bool>>(predicateBody, Data));
var miGetValue = typeof(BsonDocument).GetMethod("GetValue", new Type[] { typeof(string) });
if (sortBy != null)
{
var sortDocument = ((IConvertibleToBsonDocument)sortBy).ToBsonDocument();
for (int i = 0; i < sortDocument.ElementCount; ++i)
{
var element = sortDocument.GetElement(i);
var selector = Expression.Call(Data, miGetValue, Expression.Constant(element.Name, typeof(string)));
string sortMethodName;
if (i == 0)
sortMethodName = element.Value.AsInt32 > 0 ? "OrderBy" : "OrderByDescending";
else
sortMethodName = element.Value.AsInt32 > 0 ? "ThenBy" : "ThenByDescending";
expression = Expression.Call(
typeof(Queryable),
sortMethodName,
new Type[] { queryableData.ElementType, typeof(BsonValue) },
expression,
Expression.Lambda<Func<BsonDocument, BsonValue>>(selector, Data));
}
}
if (skip > 0)
{
expression = Expression.Call(
typeof(Queryable),
"Skip",
new Type[] { queryableData.ElementType },
expression,
Expression.Constant(skip, typeof(int)));
}
if (first > 0)
{
expression = Expression.Call(
typeof(Queryable),
"Take",
new Type[] { queryableData.ElementType },
expression,
Expression.Constant(first, typeof(int)));
}
return queryableData.Provider.CreateQuery<BsonDocument>(expression);
}
public IEnumerable<object> FindAs(Type documentType, IMongoQuery query, QueryFlags modes, IMongoSortBy sortBy, int skip, int first, IMongoFields fields)
{
var cursor = _this.FindAs(documentType, query);
if (modes != QueryFlags.None)
cursor.SetFlags(modes);
if (skip > 0)
cursor.SetSkip(skip);
if (first > 0)
cursor.SetLimit(first);
if (sortBy != null)
cursor.SetSortOrder(sortBy);
if (fields != null)
cursor.SetFields(fields);
foreach (var it in cursor)
yield return it;
}
public static IEnumerable<商品> 查询供应商商品(long catID, int skip = 0, int limit = 0, IMongoQuery conditions = null, bool modifiedDescending = true, IMongoSortBy sorting = null, bool includeDisabled = true, bool includeDeleted = false)
{
var q = Query.EQ("商品信息.所属供应商.用户ID", catID);
if (null != conditions) q = Query.And(conditions, q);
return 商品管理.查询商品(skip, limit, q, modifiedDescending, sorting, includeDisabled, includeDeleted);
}
public MongoCursorSettings SetSortOrder(IMongoSortBy sortBy)
{
this.SortBy = sortBy;
return this;
}
public virtual IEnumerable<ProfileInfo> FindProfiles(ProfileAuthenticationOption authenticationOption, IMongoQuery query, IMongoSortBy sortBy, int skip, int take, out int totalRecords)
{
if (skip < 0) {
var message = ProviderResources.SkipMustBeGreaterThanOrEqualToZero;
throw TraceException("FindProfiles", new ArgumentException(message, "skip"));
}
if (take < 0) {
var message = ProviderResources.TakeMustBeGreaterThanOrEqualToZero;
throw TraceException("FindProfiles", new ArgumentException(message, "take"));
}
var authenticationQuery = ConvertProfileAuthenticationOptionToMongoQuery(authenticationOption);
var modifiedQuery = Query.And(Query.Exists("Profile", true), authenticationQuery, query);
var users = GetUserCollection();
var matches = users.Find(modifiedQuery).SetSkip(skip).SetLimit(take);
if (sortBy != null) {
matches.SetSortOrder(sortBy);
}
totalRecords = matches.Count();
return matches.Select(u => new ProfileInfo(
u.UserName,
u.IsAnonymous,
u.Profile.LastActivityDate,
u.Profile.LastUpdateDate,
u.Profile.ToBson().Length));
}
public object FindAndModifyAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, IMongoFields fields, bool returnNew, bool upsert, out UpdateResult result)
{
var args = new FindAndModifyArgs();
args.Query = query;
args.SortBy = sortBy;
args.Update = update;
args.Fields = fields;
args.Upsert = upsert;
args.VersionReturned = returnNew ? FindAndModifyDocumentVersion.Modified : FindAndModifyDocumentVersion.Original;
var r = _this.FindAndModify(args);
result = new FindAndModifyUpdateResult(r);
return r.GetModifiedDocumentAs(documentType);
}
public object FindAndRemoveAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy)
{
var args = new FindAndRemoveArgs();
args.Query = query;
args.SortBy = sortBy;
return _this.FindAndRemove(args).GetModifiedDocumentAs(documentType);
}
public object FindAndRemoveAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy)
{
return _this.FindAndRemove(query, sortBy).GetModifiedDocumentAs(documentType);
}
public object FindAndRemoveAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy)
{
foreach (var document in QueryCompiler.Query(Documents, Documents2, query, sortBy, 0, 0))
{
RemoveDocument(document);
return BsonSerializer.Deserialize(document, documentType);
}
return null;
}
internal MongoPagingResult<GEPOrderGridT> GetGEPOrderGridData(IMongoQuery query, int take, int skip, IMongoSortBy sort)
{
return new GEPMongoDacHelper(GepMongoEnv.ConfigSection.GEP, GepMongoEnv.Database.GEP, GepMongoEnv.Collection.GEP_ORDER)
.FindByPaging<GEPOrderGridT>(query, take, skip, sort);
}
public IEnumerable<object> FindAs(Type documentType, IMongoQuery query, QueryFlags modes, IMongoSortBy sortBy, int skip, int first, IMongoFields fields)
{
var iter = QueryCompiler.Query(Documents, Documents2, query, sortBy, skip, first);
if (fields == null)
return iter.Select(x => BsonSerializer.Deserialize(x, documentType));
var project = FieldCompiler.GetFunction(fields);
return iter.Select(project).Select(x => BsonSerializer.Deserialize(x, documentType));
}
/// <summary>
/// 查询指定类型的数据库表，返回结果列表，可以指定查询条件（指定某字段等于什么值）
/// </summary>
/// <param name="skip">略过前面 skip 条记录</param>
/// <param name="limit">返回总数限制为最多 limit 条</param>
/// <param name="conditions">查询条件：Query.EQ("登录信息.密码", "abc")搜寻所有密码设置为"abc"的用户</param>
/// <param name="modifiedDescending">默认按照修改时间倒序排序，为 true 时忽略 sorting 参数</param>
/// <param name="sorting">指定排序规则 new IMongoSortBy(){ { "登录信息.显示名", true }, { "登录信息.密码", false } }
/// 按照【登录信息.显示名】升序排列为主排序规则，按照【登录信息.密码】降序为次要排序规则</param>
/// <param name="includeDeleted">查找范围包括标记为【已删除】的记录。默认不包括。</param>
/// <returns>特定类型的可枚举对象，用 foreach 遍历</returns>
public static IEnumerable<政策法规> 查询政策法规(int skip, int limit, IMongoQuery conditions = null, bool modifiedDescending = true, IMongoSortBy sorting = null, bool includeDisabled = true, bool includeDeleted = false)
{
return Mongo.查询<政策法规>(skip, limit, conditions, modifiedDescending, sorting, includeDisabled, includeDeleted);
}
public DynamicObj[] List(string objectName, IMongoQuery query, IMongoSortBy sort)
{
List<BsonDocument> list = ListDocument(objectName, query,sort);
List<DynamicObj> lstObj = new List<DynamicObj>();
foreach (BsonDocument doc in list)
{
lstObj.Add(new DynamicObj(doc));
}
return lstObj.ToArray();
}
