private void BindData()
{
lvEmailList.Items.Clear();
SortByDocument sort = new SortByDocument {
{ "AddDateTime", -1 }
};
List <Entity.EmailQueue> lst = BLL.EmailQueue.Instance.GetList().Where(rd => rd.MsgType == 0).OrderBy(rd => rd.AddDateTime).ToList();
foreach (EmailQueue queue in lst)
{
ListViewItem lvi = new ListViewItem();
lvi.SubItems[0].Text = queue.ToEmail;
string status = "已发送";
if (queue.IsSend == 0)
{
status = "未发送";
}
else if (queue.IsSend == 2)
{
status = "发送中";
}
lvi.SubItems.Add(status);
lvi.SubItems.Add(queue.AddDateTime.ToLocalTime().ToString());
lvi.SubItems.Add(queue.EmailTilte);
lvi.SubItems.Add(queue.EmailBody);
lvEmailList.Items.Add(lvi);
}
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="serviceId"></param>
/// <param name="page"></param>
/// <param name="rows"></param>
/// <param name="sidx"></param>
/// <param name="sord"></param>
/// <returns></returns>
public ActionResult GetPageDataListForContacts(string serviceId, int page = 1, int rows = 50, string sidx = "", string sord = "")
{
//分页
var pager = new PageInfo
{
CurrentPageIndex = page,
PageSize = rows,
Sidx = sidx,
Sord = sord
};
long total = 0;
var query = new QueryDocument();
var sortBy = new SortByDocument();
sortBy.Set("LatestTime", -1);
var list = new List <ServiceAlertContactsInfo>();
int id;
if (!string.IsNullOrWhiteSpace(serviceId) && int.TryParse(serviceId, out id))
{
query.Set("ServiceId", id);
list = AppService.GetPageListServiceAlertContactsInfos(query, sortBy, pager.CurrentPageIndex, pager.PageSize, out total);
}
#region 分页处理
//翻页处理
SubPageResult <ServiceAlertContactsInfo> result = new SubPageResult <ServiceAlertContactsInfo>();
result.rows = list;
result.page = page;
result.records = (int)total;
result.total = (result.records + pager.PageSize - 1) / pager.PageSize;
#endregion
return(Json(result, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 返回mongo查询数据
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="query">查询条件</param>
/// <param name="collectionName">表名</param>
/// <param name="filter">过滤条件</param>
/// <returns>mongo数据</returns>
public MongoCursor <T> QueryCursor <T>(IMongoQuery query, string collectionName, BaseFilter filter)
{
MongoCollection collection = GetMongoCollection(collectionName);
filter.RecordCount = Convert.ToInt32(collection.Count(query));
SortByDocument sortByDocument = GetSortFromStr(filter.OrderbyStr);
MongoCursor <T> mongoCursor = collection.FindAs <T>(query);
//查询性能分析
//BsonDocument document = collection.FindAs<T>(query).Explain();
if (sortByDocument != null)
{
mongoCursor = mongoCursor.SetSortOrder(sortByDocument);
}
if (filter.PageSize == 0)
{
filter.PageSize = DefaultPageSize;
}
if (filter.PageNo == 0)
{
filter.PageNo = DefaultPageNo;
}
return(mongoCursor.SetSkip(filter.PageSize * (filter.PageNo - 1)).SetLimit(filter.PageSize));
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="page"></param>
/// <param name="rows"></param>
/// <param name="sidx"></param>
/// <param name="sord"></param>
/// <returns></returns>
public ActionResult GetPageDataListForContacts(int page = 1, int rows = 50, string sidx = "", string sord = "")
{
string Manager = Request["Manager"];
//分页
PageInfo pager = new PageInfo();
pager.CurrentPageIndex = page;
pager.PageSize = rows;
pager.Sidx = sidx;
pager.Sord = sord;
long total = 0;
QueryDocument query = new QueryDocument();
if (!string.IsNullOrWhiteSpace(Manager))
{
query.Set("_id", new MongoDB.Bson.BsonRegularExpression(Manager));
}
SortByDocument sortBy = new SortByDocument();
sortBy.Set("LatestTime", -1);
var list = appService.GetPageListAppContacts(query, sortBy, pager.CurrentPageIndex, pager.PageSize, out total);
#region 分页处理
//翻页处理
SubPageResult <AppContactsInfo> result = new SubPageResult <AppContactsInfo>();
result.rows = list;
result.page = page;
result.records = (int)total;
result.total = (result.records + pager.PageSize - 1) / pager.PageSize;
#endregion
return(Json(result, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 获取列表top几
/// </summary>
/// <param name="sortByMap"> var sort = new SortByDocument { { "_id", -1 } }; ->这里1为ASC, -1为DESC</param>
/// <returns></returns>
public List <T> List(Expression <Func <T, bool> > filter, Dictionary <string, sbyte> sortByMap = null, int?top = null)
{
MongoCursor <T> cursor = null;
if (null != filter)
{
var findQuery = Query <T> .Where(filter);
cursor = this._mongoCollection.Find(findQuery);
}
else
{
cursor = this._mongoCollection.FindAll();
}
if (null != sortByMap)
{
var orderByQuery = new SortByDocument(sortByMap);
cursor = cursor.SetSortOrder(orderByQuery);
}
if (top.HasValue)
{
List <T> list = cursor.SetLimit(top.Value).ToList();
return(list);
}
return(cursor.ToList());
}
public List <string> Getimg(string user_id, string kid, string projectId)
{
MongoDBClass <FreeBotItem> helper = new MongoDBClass <FreeBotItem>();
var queryTask = new QueryDocument {
{ "UId", new ObjectId(user_id) }, { "taskId", new ObjectId(kid) }, { "ProjectId", new ObjectId(projectId) }
};
FieldsDocument fd = new FieldsDocument();
fd.Add("pic_url", 1);
List <FreeBotItem> list = new List <FreeBotItem>();
MongoCollection <FreeBotItem> col = new MongoDBClass <FreeBotItem>().GetMongoDB().GetCollection <FreeBotItem>("FreeBotItem");
SortByDocument s = new SortByDocument();
s.Add("Recent30DaysSoldNum", -1);//获取数据时进行排序，-1为降序
var TaskList = col.Find(queryTask).SetSortOrder(s).SetLimit(10).SetFields(fd);
List <string> str = new List <string>();
foreach (var item in TaskList)
{
string v;
v = "http:" + item.pic_url;
str.Add(v);
}
return(str);
}
/// <summary>
/// Mq消费者client status
/// </summary>
/// <param name="limit"></param>
/// <param name="offset"></param>
/// <param name="search"></param>
/// <returns></returns>
public ActionResult ConsumerInfo(int limit, int offset, string search = null)
{
var query = Query.Null;
if (!string.IsNullOrEmpty(search))
{
query = Query.Matches("ip", BsonRegularExpression.Create($"/{search}/"));
}
var total = dataOp.FindCount(MQConsumerInfo, query);
var rows = new List <dynamic>();
if (total > 0)
{
var sortBy = new SortByDocument {
{ "isStart", -1 }, { "lastStartTime", -1 }, { "lastEndTime", -1 }, { "ip", 1 }
};
var docs = dataOp.FindLimitByQuery(MQConsumerInfo, query, sortBy, offset, limit);
foreach (var doc in docs)
{
var consumerId = doc.Int("consumerId");
var ip = doc.String("ip");
var queueType = doc.String("queueType");
var isStart = doc.Int("isStart");
if (isStart > 0)
{
SystemMonitorBll._().SetIp(ip);
}
var lastStartTime = doc.String("lastStartTime");
var lastEndTime = doc.String("lastEndTime");
var lastExecTime = doc.String("lastExecTime");
rows.Add(new { consumerId, ip, queueType, isStart, lastStartTime, lastEndTime, lastExecTime });
}
}
return(Json(new { total, rows }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 初始化排序条件 主要当条件为空时 会默认以ObjectId递增的一个排序
/// </summary>
/// <param name="sortBy"></param>
/// <returns></returns>
private SortByDocument InitSortBy(SortByDocument sortBy)
{
if (sortBy == null)
{
sortBy = new SortByDocument(OBJECTID_KEY, 1); //默认ObjectId 递增
}
return(sortBy);
}
public static MongoCursor GetEnteringTempRecords(int limit)
{
QueryDocument query = new QueryDocument(new BsonElement("$where", "this.QValueIn>this.QValueOut"));
SortByDocument s = new SortByDocument();
s.Add("QValueIn", -1); //-1=DESC
return(collection1.Find(query).SetSortOrder(s).SetLimit(limit).SetFields(new string[] { "Symbol", "QValueIn", "QValueOut" }));;
}
/// <summary>
/// 初始化排序条件 主要当条件为空时 会默认以ObjectId递增的一个排序
/// </summary>
/// <param name="sortBy"></param>
/// <param name="sortByName"></param>
/// <returns></returns>
private SortByDocument InitSortBy(SortByDocument sortBy, string sortByName)
{
if (sortBy == null)
{
//默认ObjectId 递增
sortBy = new SortByDocument(sortByName, -1);
}
return(sortBy);
}
/// <summary>
/// 查询后的数据排序返回list
/// </summary>
/// <typeparam name="Z">类型</typeparam>
/// <param name="mongoCursor">查询出的数据</param>
/// <param name="orderStr">排序字符</param>
/// <returns>数据排序返回list</returns>
public List <Z> ReturnList <Z>(MongoCursor <Z> mongoCursor, string orderStr)
{
if (!string.IsNullOrEmpty(orderStr))
{
SortByDocument sortByDocument = GetSortFromStr(orderStr);
mongoCursor = mongoCursor.SetSortOrder();
}
return(mongoCursor.ToListEntity <Z>());
}
/// <summary>
/// Check & set default sorting
/// </summary>
/// <param name="sortBy">-1 -- decsending, 1 -- ascending</param>
/// <returns></returns>
private static SortByDocument InitSortBy(SortByDocument sortBy)
{
if (sortBy == null)
{
sortBy = new SortByDocument(ObjectIdKey, 1);
}
return(sortBy);
}
public void TestSortByDocumentConstructor()
{
var document1 = new SortByDocument(_dictionary);
var document2 = new SortByDocument(_hashtable);
var document3 = new SortByDocument(_idictionaryNonGeneric);
var document4 = new SortByDocument(_idictionary);
Assert.AreEqual("Dictionary<string, object>", document1["type"].AsString);
Assert.AreEqual("Hashtable", document2["type"].AsString);
Assert.AreEqual("IDictionary", document3["type"].AsString);
Assert.AreEqual("IDictionary<string, object>", document4["type"].AsString);
}
protected override void OK()
{
BsonDocument d = string.IsNullOrEmpty(FindCriteria) ? new BsonDocument() : BsonDocument.Parse(FindCriteria);
var sbd = new SortByDocument();
foreach (SortParameterViewModel sort in FieldsToSort)
{
sbd.Add(sort.FieldName, sort.CurrentDirection == OrderByDirection.Ascending ? 1 : -1);
}
var doc = new QueryDocument(d);
QueryResults = _coll.Find(doc).SetSortOrder(sbd).SetFields(FieldsToView.SelectedItems.ToArray()).ToList();
}
/// <summary>
/// 显示全部，支持排序
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sortBy"></param>
/// <param name="fields">显示出了ID之外的另外一些列的值</param>
/// <returns></returns>
public static List <T> SelectSortR <T>(string sortByJson, params string[] fields)
{
string collectionName = typeof(T).Name;
IMongoFields field = Fields.Include(fields);
Array.Clear(fields, 0, fields.Length);
fields = null;
MongoCollection collection = MongoCollection(collectionName);
BsonDocument bsonSortByDocument = BsonSerializer.Deserialize(sortByJson, typeof(BsonDocument)) as BsonDocument;
SortByDocument sortByDocument = new SortByDocument(bsonSortByDocument);
return(collection.FindAllAs <T>().SetFields(field).SetSortOrder(sortByDocument).ToList <T>());
}
/// <summary>
/// 分页查询 PageIndex和PageSize模式 在页数PageIndex大的情况下 效率明显变低
/// </summary>
/// <typeparam name="T">所需查询的数据的实体类型</typeparam>
/// <param name="query">查询的条件</param>
/// <param name="pageIndex">当前的页数</param>
/// <param name="pageSize">当前的尺寸</param>
/// <param name="sortBy">排序方式</param>
/// <param name="collectionName">集合名称</param>
/// <returns>返回List列表</returns>
public List <T> Find <T>(IMongoQuery query, int pageIndex, int pageSize, SortByDocument sortBy, string collectionName)
{
MongoCollection <T> mc = this._db.GetCollection <T>(collectionName);
MongoCursor <T> mongoCursor = null;
query = this.InitQuery(query);
sortBy = this.InitSortBy(sortBy);
//如页序号为0时初始化为1
pageIndex = pageIndex == 0 ? 1 : pageIndex;
//按条件查询 排序 跳数 取数
mongoCursor = mc.Find(query).SetSortOrder(sortBy).SetSkip((pageIndex - 1) * pageSize).SetLimit(pageSize);
return(mongoCursor.ToList <T>());
}
public SortByDocument GetSortOrders(List <SortOrder> sortOrders)
{
var result = new SortByDocument();
foreach (var order in sortOrders)
{
var propExpr = (MemberExpression)order.KeySelector;
var propInfo = (PropertyInfo)propExpr.Member;
this.m_allProperties[propInfo].PutSortOrder(result, order.Descending);
}
return(result);
}
public static List <T> SelectR <T>(int pageSize, int pageIndex, string queryJson, string sortByJson, params string[] fields)
{
string collectionName = typeof(T).Name;
IMongoFields field = Fields.Include(fields);
Array.Clear(fields, 0, fields.Length);
fields = null;
MongoCollection collection = MongoCollection(collectionName);
BsonDocument bsonQueryDocument = BsonSerializer.Deserialize(queryJson, typeof(BsonDocument)) as BsonDocument;
QueryDocument queryDocument = new QueryDocument(bsonQueryDocument);
BsonDocument bsonSortDocument = BsonSerializer.Deserialize(sortByJson, typeof(BsonDocument)) as BsonDocument;
SortByDocument sortByDocument = new SortByDocument(bsonSortDocument);
return(collection.FindAs <T>(queryDocument).SetFields(field).SetSortOrder(sortByDocument).SetSkip((pageIndex - 1) * pageSize).SetLimit(pageSize).ToList <T>());;
}
public static List <T> FindMany <T>(this MongoCollection <T> collection, IMongoQuery query, SortByDocument sortby, int pageIndex, int pageSize) where T : BaseEntity
{
if (query == null)
{
query = Query.Exists(OBJECTID_KEY);
}
if (sortby == null)
{
sortby = new SortByDocument(OBJECTID_KEY, -1);
}
MongoCursor <T> cursor = collection.FindAs <T>(query).SetSortOrder(sortby).SetSkip(Math.Max(1, pageIndex)).SetLimit(pageSize);
return(cursor.ToList());
}
public List <T> FindDataByTop(string tbName, IMongoQuery query, string orderby)
{
MongoServer server = new MongoClient(conn).GetServer();
var db = server.GetDatabase(dbName); // WriteConcern defaulted to Acknowledged
SortByDocument s = new SortByDocument();
s.Add(orderby, -1); //-1=DESC
MongoCollection <T> col = db.GetCollection <T>(tbName);
var resultcur = col.Find(query).SetSortOrder(s);
List <T> results = new List <T>();
foreach (var result in resultcur)
{
results.Add(result);
}
return(results);
}
/// <summary>
/// 获取小孩一个月轨迹日期列表
/// </summary>
/// <param name="childId">小孩Id</param>
/// <param name="beginTime">一个月的第一天</param>
/// <param name="beginTime">一个月的最后一天</param>
/// <returns></returns>
public List <StepRankingModel> GetChildOneMonthTraceListImpl(int childId, DateTime begin, DateTime end)
{
MongoClient client = new MongoClient(connection);
var db = client.GetDatabase(this.dbName);
var collection = db.GetCollection <StepRankingModel>(this.collection);
string beginTime = begin.ToString("yyyyMMdd");
string endTime = end.ToString("yyyyMMdd");
QueryDocument query = new QueryDocument();
BsonDocument timeBson = new BsonDocument();
timeBson.Add("$gt", beginTime); //>beginTime
timeBson.Add("$lt", endTime); //<endTime
query.Add("Date", timeBson);
query.Add(new BsonElement("ChildId", childId));
SortByDocument s = new SortByDocument();
s.Add("Date", 1);//order by asc
return(collection.Find(query).Sort(s).ToList());
}
public T GetNextSequence <T>(IMongoQuery query, SortByDocument sortBy, UpdateDocument update, string collectionName, string indexName)
{
if (this._db == null)
{
return(default(T));
}
try
{
MongoCollection <T> mc = this._db.GetCollection <T>(collectionName);
query = this.InitQuery(query);
sortBy = this.InitSortBy(sortBy, OBJECTID_KEY);
update = this.InitUpdateDocument(update, indexName);
var ido = mc.FindAndModify(query, sortBy, update, true, false);
return(ido.GetModifiedDocumentAs <T>());
}
catch (Exception ex)
{
return(default(T));
}
}
public List <FreeBotItemDto> GetBotResultList(string user_id, string kid, string projectId)
{
try
{
MongoDBClass <FreeBotItem> helper = new MongoDBClass <FreeBotItem>();
var queryTask = new QueryDocument {
{ "UId", new ObjectId(user_id) }, { "taskId", new ObjectId(kid) }, { "ProjectId", new ObjectId(projectId) }
};
List <FreeBotItemDto> list = new List <FreeBotItemDto>();
FieldsDocument fd = new FieldsDocument();
fd.Add("_id", 1);
fd.Add("ShopName", 1);
fd.Add("Location", 1);
fd.Add("Recent30DaysSoldNum", 1);
fd.Add("ItemName", 1);
fd.Add("Price", 1);
fd.Add("CreatedAt", 1);
MongoCollection <FreeBotItem> col = new MongoDBClass <FreeBotItem>().GetMongoDB().GetCollection <FreeBotItem>("FreeBotItem");
SortByDocument so = new SortByDocument();
so.Add("CreatedAt", -1);
var TaskList = col.Find(queryTask).SetSortOrder(so).SetFields(fd);
foreach (var item in TaskList)
{
FreeBotItemDto v = new FreeBotItemDto();
v._id = item._id.ToString();
v.ShopName = item.ShopName;
v.Location = item.Location;
v.ItemName = item.ItemName;
v.Price = item.Price;
v.Recent30DaysSoldNum = item.Recent30DaysSoldNum;
list.Add(v);
}
return(list);
}
catch (Exception)
{
return(null);
}
}
public T Get(Expression <Func <T, bool> > filter, Dictionary <string, sbyte> sortByMap)
{
MongoCursor <T> cursor = null;
if (null != filter)
{
var findQuery = Query <T> .Where(filter);
cursor = this._mongoCollection.FindAs <T>(findQuery);
}
else
{
cursor = this._mongoCollection.FindAllAs <T>();
}
if (null != sortByMap)
{
var orderByQuery = new SortByDocument(sortByMap);
cursor = cursor.SetSortOrder(orderByQuery);
}
return(cursor.FirstOrDefault());
}
/// <summary>
/// Mq consume failed log
/// </summary>
/// <param name="limit"></param>
/// <param name="offset"></param>
/// <param name="search"></param>
/// <returns></returns>
public ActionResult ConsumerLogInfo(int limit, int offset, string search = null)
{
var query = Query.Null;
if (!string.IsNullOrEmpty(search))
{
}
var total = dataOp.FindCount(MQConsumerLog, query);
var rows = new List <dynamic>();
if (total > 0)
{
var sortBy = new SortByDocument {
{ "time", -1 }
};
var docs = dataOp.FindLimitByQuery(MQConsumerLog, query, sortBy, offset, limit);
foreach (var doc in docs)
{
var logId = doc.Int("logId");
var consumerId = doc.String("consumerId");
var info = SystemMonitorBll._().GetConsumerInfo(consumerId);
var ip = info?.ip;
var queueType = info?.queueType;
var type = doc.Int("type");
var msg = doc.String("msg");
var sourceData = doc.String("sourceData");
if (sourceData.Length > 2500)
{
sourceData = RemoveRunLog(sourceData);
}
var time = doc.String("time");
var customer = SystemMonitorBll._().GetCustomerNameByJobId(GetJobId(sourceData));
rows.Add(new { logId, ip, queueType, type, msg, sourceData, time, customer });
}
}
return(Json(new { total, rows }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="filterList"></param>
/// <param name="sortByMap"> var sort = new SortByDocument { { "_id", -1 } }; ->这里1为ASC, -1为DESC</param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List <T> PageList(List <Expression <Func <T, bool> > > filterList, Dictionary <string, sbyte> sortByMap = null, int?pageIndex = null, int?pageSize = null, string[] fields = null)
{
MongoCursor <T> cursor = null;
if (null != filterList && filterList.Count > 0)
{
var findQueryList = (from expression in filterList where null != expression select Query <T> .Where(expression)).ToList();
var findQuery = Query.And(findQueryList);
cursor = this._mongoCollection.FindAs <T>(findQuery);
}
else
{
cursor = this._mongoCollection.FindAllAs <T>();
}
if (null != sortByMap)
{
var orderByQuery = new SortByDocument(sortByMap);
cursor = cursor.SetSortOrder(orderByQuery);
}
if (fields != null && fields.Any())
{
cursor = cursor.SetFields(fields);
}
if (pageIndex.HasValue)
{
if (!pageSize.HasValue)
{
pageSize = 30;
}
List <T> list = cursor.SetSkip((pageIndex.Value - 1) * pageSize.Value).SetLimit(pageSize.Value).ToList();
return(list);
}
return(cursor.ToList());
}
public virtual IEnumerable <ImportedHouse> GetImportHouseList(ImportedHouseListReq parames, ref int totalSize)
{
MongoServer houseCaijiMongoDbServer = GetMongoClient(connectionName);
MongoDatabase houseDb = houseCaijiMongoDbServer.GetDatabase(databaseName);
string dbCollection = "ImportHouse";
MongoCollection <BsonDocument> houseCollection = houseDb.GetCollection(dbCollection);
IMongoQuery query = new QueryDocument();
IMongoQuery userQuery = Query.And(Query.EQ("UserID", parames.UserId));
if (parames.status >= 0)
{
userQuery = Query.And(userQuery, Query.EQ("MoveStatus", parames.status));
}
query = Query.And(query, Query.EQ("SiteId", parames.SiteId));
query = Query.And(query, Query.ElemMatch("RefUser", userQuery));
query = Query.And(query, Query.EQ("SiteUserName", parames.SiteUserName));
if (parames.CommunityId > 0)
{
query = Query.And(query, Query.EQ("CommunityID", parames.CommunityId));
}
if (parames.BuildingType > 0)
{
query = Query.And(query, Query.EQ("BuildType", parames.BuildingType));
}
if (parames.TradeType > 0)
{
query = Query.And(query, Query.EQ("TradeType", parames.TradeType));
}
IMongoSortBy sort = new SortByDocument();
sort = SortBy.Descending("PostTime");
MongoCursor <ImportedHouse> dataList = houseCollection.FindAs <ImportedHouse>(query).SetSkip((parames.PageIndex - 1) * parames.PageSize).SetSortOrder(sort).SetLimit(parames.PageSize);
totalSize = (int)dataList.Count();
return(dataList);
}
/// <summary>
/// Get a non running message from queue
/// </summary>
/// <param name="query">query where top level fields do not contain operators. Lower level fields can however. eg: valid {a: {$gt: 1}, "b.c": 3}, invalid {$and: [{...}, {...}]}</param>
/// <param name="resetRunning">duration before this message is considered abandoned and will be given with another call to Get()</param>
/// <param name="wait">duration to keep polling before returning null</param>
/// <param name="poll">duration between poll attempts</param>
/// <param name="approximateWait">whether to fluctuate the wait time randomly by +-10 percent. This ensures Get() calls seperate in time when multiple Queues are used in loops started at the same time</param>
/// <returns>message or null</returns>
/// <exception cref="ArgumentNullException">query is null</exception>
public Message Get(QueryDocument query, TimeSpan resetRunning, TimeSpan wait, TimeSpan poll, bool approximateWait)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
//reset stuck messages
collection.Update(
new QueryDocument {
{ "running", true }, { "resetTimestamp", new BsonDocument("$lte", DateTime.UtcNow) }
},
new UpdateDocument("$set", new BsonDocument("running", false)),
UpdateFlags.Multi
);
var builtQuery = new QueryDocument("running", false);
foreach (var field in query)
{
builtQuery.Add("payload." + field.Name, field.Value);
}
builtQuery.Add("earliestGet", new BsonDocument("$lte", DateTime.UtcNow));
var resetTimestamp = DateTime.UtcNow;
try
{
resetTimestamp += resetRunning;
}
catch (ArgumentOutOfRangeException)
{
resetTimestamp = resetRunning > TimeSpan.Zero ? DateTime.MaxValue : DateTime.MinValue;
}
var sort = new SortByDocument {
{ "priority", 1 }, { "created", 1 }
};
var update = new UpdateDocument("$set", new BsonDocument {
{ "running", true }, { "resetTimestamp", resetTimestamp }
});
var fields = new FieldsDocument {
{ "payload", 1 }, { "streams", 1 }
};
var end = DateTime.UtcNow;
try
{
if (approximateWait)
{
//fluctuate randomly by 10 percent
wait += TimeSpan.FromMilliseconds(wait.TotalMilliseconds * GetRandomDouble(-0.1, 0.1));
}
end += wait;
}
catch (Exception e)
{
if (!(e is OverflowException) && !(e is ArgumentOutOfRangeException))
{
throw e;//cant cover
}
end = wait > TimeSpan.Zero ? DateTime.MaxValue : DateTime.MinValue;
}
while (true)
{
var message = collection.FindAndModify(builtQuery, sort, update, fields, false, false).ModifiedDocument;
if (message != null)
{
var handleStreams = new List <KeyValuePair <BsonValue, Stream> >();
var messageStreams = new Dictionary <string, Stream>();
foreach (var streamId in message["streams"].AsBsonArray)
{
var fileInfo = gridfs.FindOneById(streamId);
var stream = fileInfo.OpenRead();
handleStreams.Add(new KeyValuePair <BsonValue, Stream>(streamId, stream));
messageStreams.Add(fileInfo.Name, stream);
}
var handle = new Handle(message["_id"].AsObjectId, handleStreams);
return(new Message(handle, message["payload"].AsBsonDocument, messageStreams));
}
if (DateTime.UtcNow >= end)
{
return(null);
}
try
{
Thread.Sleep(poll);
}
catch (ArgumentOutOfRangeException)
{
if (poll < TimeSpan.Zero)
{
poll = TimeSpan.Zero;
}
else
{
poll = TimeSpan.FromMilliseconds(int.MaxValue);
}
Thread.Sleep(poll);
}
if (DateTime.UtcNow >= end)
{
return(null);
}
}
}
/// <summary>
/// Executes the translated Find query.
/// </summary>
/// <returns>The result of executing the translated Find query.</returns>
public override object Execute()
{
var query = BuildQuery();
var cursor = Collection.FindAs(DocumentType, query);
if (_orderBy != null)
{
var sortBy = new SortByDocument();
foreach (var clause in _orderBy)
{
var memberExpression = (MemberExpression)clause.Key.Body;
var dottedElementName = GetDottedElementName(memberExpression);
var direction = (clause.Direction == OrderByDirection.Descending) ? -1 : 1;
sortBy.Add(dottedElementName, direction);
}
cursor.SetSortOrder(sortBy);
}
if (_skip != null)
{
cursor.SetSkip(ToInt32(_skip));
}
if (_take != null)
{
cursor.SetLimit(ToInt32(_take));
}
IEnumerable enumerable;
if (_projection == null)
{
enumerable = cursor;
}
else
{
var lambdaType = _projection.GetType();
var delegateType = lambdaType.GetGenericArguments()[0];
var sourceType = delegateType.GetGenericArguments()[0];
var resultType = delegateType.GetGenericArguments()[1];
var projectorType = typeof(Projector<,>).MakeGenericType(sourceType, resultType);
var projection = _projection.Compile();
var projector = Activator.CreateInstance(projectorType, cursor, projection);
enumerable = (IEnumerable)projector;
}
if (_elementSelector != null)
{
return _elementSelector(enumerable);
}
else
{
return enumerable;
}
}
/// <summary>
/// Executes the translated Find query.
/// </summary>
/// <returns>The result of executing the translated Find query.</returns>
public override object Execute()
{
if (_take.HasValue && _take.Value == 0)
{
var type = _ofType ?? DocumentType;
return typeof(Enumerable).GetMethod("Empty").MakeGenericMethod(type).Invoke(null, null);
}
var query = BuildQuery();
if (_distinct != null)
{
return ExecuteDistinct(query);
}
var cursor = Collection.FindAs(DocumentType, query);
if (_orderBy != null)
{
var sortBy = new SortByDocument();
foreach (var clause in _orderBy)
{
var keyExpression = clause.Key.Body;
var serializationInfo = _serializationInfoHelper.GetSerializationInfo(keyExpression);
var direction = (clause.Direction == OrderByDirection.Descending) ? -1 : 1;
sortBy.Add(serializationInfo.ElementName, direction);
}
cursor.SetSortOrder(sortBy);
}
if (_skip != null)
{
cursor.SetSkip(_skip.Value);
}
if (_take != null)
{
cursor.SetLimit(_take.Value);
}
var projection = _projection;
if (_ofType != null)
{
if (projection == null)
{
var paramExpression = Expression.Parameter(DocumentType, "x");
var convertExpression = Expression.Convert(paramExpression, _ofType);
projection = Expression.Lambda(convertExpression, paramExpression);
}
else
{
var paramExpression = Expression.Parameter(DocumentType, "x");
var convertExpression = Expression.Convert(paramExpression, _ofType);
var body = ExpressionParameterReplacer.ReplaceParameter(projection.Body, projection.Parameters[0], convertExpression);
projection = Expression.Lambda(body, paramExpression);
}
}
IProjector projector;
if (projection == null)
{
var projectorType = typeof(IdentityProjector<>).MakeGenericType(DocumentType);
projector = (IProjector)Activator.CreateInstance(projectorType, cursor);
}
else
{
var lambdaType = projection.GetType();
var delegateType = lambdaType.GetGenericArguments()[0];
var sourceType = delegateType.GetGenericArguments()[0];
var resultType = delegateType.GetGenericArguments()[1];
var projectorType = typeof(Projector<,>).MakeGenericType(sourceType, resultType);
var compiledProjection = projection.Compile();
projector = (IProjector)Activator.CreateInstance(projectorType, cursor, compiledProjection);
}
if (_elementSelector != null)
{
return _elementSelector(projector);
}
else
{
return projector;
}
}
/// <summary>
/// Executes the translated Find query.
/// </summary>
/// <returns>The result of executing the translated Find query.</returns>
public override object Execute()
{
var query = BuildQuery();
if (_distinct)
{
return(ExecuteDistinct(query));
}
var cursor = Collection.FindAs(DocumentType, query);
if (_orderBy != null)
{
var sortBy = new SortByDocument();
foreach (var clause in _orderBy)
{
var keyExpression = clause.Key.Body;
var serializationInfo = _serializationInfoHelper.GetSerializationInfo(keyExpression);
var direction = (clause.Direction == OrderByDirection.Descending) ? -1 : 1;
sortBy.Add(serializationInfo.ElementName, direction);
}
cursor.SetSortOrder(sortBy);
}
if (_skip != null)
{
cursor.SetSkip(ToInt32(_skip));
}
if (_take != null)
{
cursor.SetLimit(ToInt32(_take));
}
var projection = _projection;
if (_ofType != null)
{
if (projection == null)
{
var paramExpression = Expression.Parameter(DocumentType, "x");
var convertExpression = Expression.Convert(paramExpression, _ofType);
projection = Expression.Lambda(convertExpression, paramExpression);
}
else
{
var paramExpression = Expression.Parameter(DocumentType, "x");
var convertExpression = Expression.Convert(paramExpression, _ofType);
var body = ExpressionParameterReplacer.ReplaceParameter(projection.Body, projection.Parameters[0], convertExpression);
projection = Expression.Lambda(body, paramExpression);
}
}
IEnumerable enumerable;
if (projection == null)
{
enumerable = cursor;
}
else
{
var lambdaType = projection.GetType();
var delegateType = lambdaType.GetGenericArguments()[0];
var sourceType = delegateType.GetGenericArguments()[0];
var resultType = delegateType.GetGenericArguments()[1];
var projectorType = typeof(Projector <,>).MakeGenericType(sourceType, resultType);
var compiledProjection = projection.Compile();
var projector = Activator.CreateInstance(projectorType, cursor, compiledProjection);
enumerable = (IEnumerable)projector;
}
if (_elementSelector != null)
{
return(_elementSelector(enumerable));
}
else
{
return(enumerable);
}
}
/// <summary>
/// Executes the translated Find query.
/// </summary>
/// <returns>The result of executing the translated Find query.</returns>
public override object Execute()
{
if (_take.HasValue && _take.Value == 0)
{
var type = _ofType ?? DocumentType;
return typeof(Enumerable).GetMethod("Empty").MakeGenericMethod(type).Invoke(null, null);
}
var query = BuildQuery();
//if (_distinct != null)
//{
// return ExecuteDistinct(query);
//}
//var cursor = Collection.FindAs(DocumentType, query);
DBQuery dbQuery = new DBQuery();
dbQuery.Matcher = query as BsonDocument;
if (_orderBy != null)
{
var sortBy = new SortByDocument();
foreach (var clause in _orderBy)
{
var keyExpression = clause.Key.Body;
var serializationInfo = _serializationInfoHelper.GetSerializationInfo(keyExpression);
var direction = (clause.Direction == OrderByDirection.Descending) ? -1 : 1;
sortBy.Add(serializationInfo.ElementName, direction);
}
//cursor.SetSortOrder(sortBy);
dbQuery.OrderBy = sortBy;
}
if (_skip != null)
{
//cursor.SetSkip(_skip.Value);
dbQuery.SkipRowsCount = _skip.Value;
}
if (_take != null)
{
//cursor.SetLimit(_take.Value);
dbQuery.ReturnRowsCount = _take.Value;
}
if (_indexHint != null)
{
if (_indexHint.IsString)
{
//cursor.SetHint(_indexHint.AsString);
}
else if (_indexHint.IsBsonDocument)
{
//cursor.SetHint(_indexHint.AsBsonDocument);
dbQuery.Hint = _indexHint.AsBsonDocument;
}
else
{
throw new NotSupportedException("Index hints must be strings or documents");
}
}
var cursor = Collection.Query(dbQuery);
cursor.DBQuery = dbQuery;
var projection = _projection;
if (_ofType != null)
{
if (projection == null)
{
var paramExpression = Expression.Parameter(DocumentType, "x");
var convertExpression = Expression.Convert(paramExpression, _ofType);
projection = Expression.Lambda(convertExpression, paramExpression);
}
else
{
var paramExpression = Expression.Parameter(DocumentType, "x");
var convertExpression = Expression.Convert(paramExpression, _ofType);
var body = ExpressionParameterReplacer.ReplaceParameter(projection.Body, projection.Parameters[0], convertExpression);
projection = Expression.Lambda(body, paramExpression);
}
}
IProjector projector;
if (projection == null)
{
var projectorType = typeof(IdentityProjector<>).MakeGenericType(DocumentType);
projector = (IProjector)Activator.CreateInstance(projectorType, cursor);
}
else
{
var lambdaType = projection.GetType();
var delegateType = lambdaType.GetGenericArguments()[0];
var sourceType = delegateType.GetGenericArguments()[0];
var resultType = delegateType.GetGenericArguments()[1];
var projectorType = typeof(Projector<,>).MakeGenericType(sourceType, resultType);
var compiledProjection = projection.Compile();
projector = (IProjector)Activator.CreateInstance(projectorType, cursor, compiledProjection);
}
if (_elementSelector != null)
{
return _elementSelector(projector);
}
else
{
return projector;
}
}
/// <summary>
/// Executes the translated Find query.
/// </summary>
/// <returns>The result of executing the translated Find query.</returns>
public override object Execute()
{
var query = BuildQuery();
if (_distinct)
{
return ExecuteDistinct(query);
}
var cursor = Collection.FindAs(DocumentType, query);
if (_orderBy != null)
{
var sortBy = new SortByDocument();
foreach (var clause in _orderBy)
{
var keyExpression = clause.Key.Body;
var serializationInfo = GetSerializationInfo(keyExpression);
if (serializationInfo == null)
{
var message = string.Format("Invalid OrderBy expression: {0}.", ExpressionFormatter.ToString(keyExpression));
throw new NotSupportedException(message);
}
var direction = (clause.Direction == OrderByDirection.Descending) ? -1 : 1;
sortBy.Add(serializationInfo.ElementName, direction);
}
cursor.SetSortOrder(sortBy);
}
if (_skip != null)
{
cursor.SetSkip(ToInt32(_skip));
}
if (_take != null)
{
cursor.SetLimit(ToInt32(_take));
}
IEnumerable enumerable;
if (_projection == null)
{
enumerable = cursor;
}
else
{
var lambdaType = _projection.GetType();
var delegateType = lambdaType.GetGenericArguments()[0];
var sourceType = delegateType.GetGenericArguments()[0];
var resultType = delegateType.GetGenericArguments()[1];
var projectorType = typeof(Projector<,>).MakeGenericType(sourceType, resultType);
var projection = _projection.Compile();
var projector = Activator.CreateInstance(projectorType, cursor, projection);
enumerable = (IEnumerable)projector;
}
if (_elementSelector != null)
{
return _elementSelector(enumerable);
}
else
{
return enumerable;
}
}
/// <summary>
/// Executes the translated Find query.
/// </summary>
/// <returns>The result of executing the translated Find query.</returns>
public override object Execute()
{
if (_take.HasValue && _take.Value == 0)
{
var type = _ofType ?? DocumentType;
return(typeof(Enumerable).GetMethod("Empty").MakeGenericMethod(type).Invoke(null, null));
}
var query = BuildQuery();
if (_distinct != null)
{
return(ExecuteDistinct(query));
}
var cursor = Collection.FindAs(DocumentType, query);
if (_orderBy != null)
{
var sortBy = new SortByDocument();
foreach (var clause in _orderBy)
{
var keyExpression = clause.Key.Body;
var serializationInfo = _serializationInfoHelper.GetSerializationInfo(keyExpression);
var direction = (clause.Direction == OrderByDirection.Descending) ? -1 : 1;
sortBy.Add(serializationInfo.ElementName, direction);
}
cursor.SetSortOrder(sortBy);
}
if (_skip != null)
{
cursor.SetSkip(_skip.Value);
}
if (_take != null)
{
cursor.SetLimit(_take.Value);
}
if (_indexHint != null)
{
if (_indexHint.IsString)
{
cursor.SetHint(_indexHint.AsString);
}
else if (_indexHint.IsBsonDocument)
{
cursor.SetHint(_indexHint.AsBsonDocument);
}
else
{
throw new NotSupportedException("Index hints must be strings or documents");
}
}
var projection = _projection;
if (_ofType != null)
{
if (projection == null)
{
var paramExpression = Expression.Parameter(DocumentType, "x");
var convertExpression = Expression.Convert(paramExpression, _ofType);
projection = Expression.Lambda(convertExpression, paramExpression);
}
else
{
var paramExpression = Expression.Parameter(DocumentType, "x");
var convertExpression = Expression.Convert(paramExpression, _ofType);
var body = ExpressionParameterReplacer.ReplaceParameter(projection.Body, projection.Parameters[0], convertExpression);
projection = Expression.Lambda(body, paramExpression);
}
}
IProjector projector;
if (projection == null)
{
var projectorType = typeof(IdentityProjector <>).MakeGenericType(DocumentType);
projector = (IProjector)Activator.CreateInstance(projectorType, cursor);
}
else
{
var lambdaType = projection.GetType();
var delegateType = lambdaType.GetGenericArguments()[0];
var sourceType = delegateType.GetGenericArguments()[0];
var resultType = delegateType.GetGenericArguments()[1];
var projectorType = typeof(Projector <,>).MakeGenericType(sourceType, resultType);
var compiledProjection = projection.Compile();
projector = (IProjector)Activator.CreateInstance(projectorType, cursor, compiledProjection);
}
if (_elementSelector != null)
{
return(_elementSelector(projector));
}
else
{
return(projector);
}
}
