protected override void VisitOrElse(Content.Query.Expressions.OrElseExpression expression)
{
QueryComplete leftClause = null;
if (!(expression.Left is TrueExpression))
{
leftClause = VisitInner(expression.Left);
}
QueryComplete rightClause = null;
if (!(expression.Right is TrueExpression))
{
rightClause = VisitInner(expression.Right);
}
if (leftClause != null && rightClause != null)
{
var queryComplete = QueryBuilder.Query.Or(leftClause, rightClause);
SetQuery(queryComplete);
}
else if (leftClause != null)
{
SetQuery(leftClause);
}
else if (rightClause != null)
{
SetQuery(rightClause);
}
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
SecUtility.CheckParameter(ref roleName, true, true, null, MAX_ROLE_LENGTH, "roleName");
if (String.IsNullOrWhiteSpace(usernameToMatch))
{
return(new string[0]);
}
var username = ElementNames.LowercaseUsername;
QueryComplete userQuery = Helper.FindQuery(usernameToMatch.ToLowerInvariant(), username);
var query = Query.And(
Query.EQ(ElementNames.Roles, roleName.ToLowerInvariant()),
userQuery
);
var cursor = UserCollection.FindAs <BsonDocument>(query);
// only want the usernames
cursor.SetFields(Fields.Include(username).Exclude("_id"));
var names = new List <string>();
foreach (var doc in cursor)
{
var str = doc[username].AsString;
names.Add(str);
}
return(names.ToArray());
}
protected override void VisitAndAlso(Content.Query.Expressions.AndAlsoExpression expression)
{
var andAlso = (AndAlsoExpression)expression;
QueryComplete leftClause = null;
if (!(andAlso.Left is TrueExpression))
{
leftClause = VisitInner(andAlso.Left);
}
QueryComplete rightClause = null;
if (!(andAlso.Right is TrueExpression))
{
rightClause = VisitInner(andAlso.Right);
}
if (leftClause != null && rightClause != null)
{
var queryComplete = QueryBuilder.Query.And(leftClause, rightClause);
SetQuery(queryComplete);
}
else if (leftClause != null)
{
SetQuery(leftClause);
}
else if (rightClause != null)
{
SetQuery(rightClause);
}
}
/// <summary>
/// Executes the query synchronously
/// </summary>
/// <returns>The response from HOBO</returns>
public string ExecuteQuery()
{
var response = getWebRequest().GetResponse();
var data = new StreamReader(response.GetResponseStream() ?? throw new InvalidOperationException()).ReadToEnd();
response.Close();
QueryComplete?.Invoke(this, new QueryResponseArgs(data));
return(data);
}
public IEnumerable <string> GetCounterCategories(DateTime beginDate, DateTime endDate)
{
MongoCollection <BsonDocument> items = Database.GetCollection("countersData");
QueryComplete qb = Query.GTE("date", beginDate).LTE(endDate);
var cursor = items.Find(qb);
cursor.SetFields(Fields.Include("counterCategory"));
return(cursor.Select(d => d["counterCategory"].AsString).Distinct());
}
/// <summary>
/// 获取主键的询问
/// </summary>
/// <typeparam name="T">类名</typeparam>
/// <param name="item">对象</param>
/// <param name="idNames">主键集合</param>
/// <returns></returns>
private static IMongoQuery GetIDQuery <T>(T item, string[] idNames)
{
QueryComplete[] param = new QueryComplete[idNames.Length];
for (int i = 0; i < idNames.Length; ++i)
{
param[i] = Query.EQ(idNames[i], MongoDB.Bson.BsonValue.Create(typeof(T).GetProperty(idNames[i]).GetValue(item, null)));
}
return(Query.And(param));
}
/// <summary>
/// Determines what items are children of the item and returns a list of their IDs.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="context"></param>
/// <returns></returns>
public override IDList GetChildIDs(ItemDefinition itemDefinition, CallContext context)
{
QueryComplete query = Query.EQ("ParentID",
itemDefinition.ID == JoinParentId
? Guid.Empty
: itemDefinition.ID.ToGuid());
return(IDList.Build(Items.FindAs <ItemBase>(query)
.Select(it => new ID(it._id)).ToArray()));
}
public void SetQuery(QueryComplete queryComplete)
{
if (this.QueryComplete != null)
{
this.QueryComplete = QueryBuilder.Query.And(this.QueryComplete, queryComplete);
}
else
{
this.QueryComplete = queryComplete;
}
}
public override IdCollection GetTemplateItemIds(CallContext context)
{
QueryComplete query = Query.EQ("TemplateID", TemplateIDs.Template.ToGuid());
IdCollection ids = new IdCollection();
foreach (var id in Items.FindAs <ItemBase>(query).Select(it => new ID(it._id)))
{
ids.Add(id);
}
return(ids);
}
public CounterCategoryInfo GetCounterCategory2(string categoryName)
{
MongoCollection <BsonDocument> items = Database.GetCollection("countersInfo");
QueryComplete q = Query.EQ("category", categoryName);
var cursor = items.FindAll();
cursor.SetFields(Fields.Include("category", "id"));
var res = cursor.FirstOrDefault();
return(res == null ? null : new CounterCategoryInfo(res["category"].AsString, res["id"].AsInt32));
}
private QueryComplete getQuery(string[] keywords)
{
QueryComplete[] qries = new QueryComplete[keywords.Length];
int index = 0;
foreach (string keyword in keywords)
{
qries[index] = Query.EQ("Keywords", new Regex(keyword, RegexOptions.IgnoreCase));
index++;
}
return(Query.Or(qries));
}
/// <summary>
/// 更新事例实例
/// </summary>
/// <returns></returns>
public InvokeResult Update(QueryComplete query, BsonDocument updateDoc)
{
if (updateDoc == null)
{
throw new ArgumentNullException();
}
var storageData = new StorageData()
{
Name = tableName, Document = updateDoc, Type = StorageType.Update, Query = query
};
var result = CommonDbChangeHelper.CommonSubmitChange(storageData);
return(result);
}
public IEnumerable <CounterDetail> GetCounterDetails(DateTime beginDate, DateTime endDate, string counterCategory,
string counterName)
{
MongoCollection <BsonDocument> items = Database.GetCollection("countersData");
QueryComplete qb = Query.GTE("date", beginDate).LTE(endDate);
QueryComplete qb2 = Query.EQ("counterCategory", counterCategory);
QueryComplete qb3 = Query.EQ("counterName", counterName);
var cursor = items.Find(Query.And(qb, qb2, qb3));
cursor.SetFields(Fields.Include("source", "instance", "extendedData"));
return(cursor.Select(d =>
new CounterDetail(d["source"].AsString, d["instance"].AsString,
d.Contains("extendedData") ? d["extendedData"].AsString : null)
));
}
public IEnumerable <CounterExtDataInfo> GetCounterExtDatas(int categoryId, int counterId)
{
MongoCollection <BsonDocument> items = Database.GetCollection("countersInfo");
QueryComplete q = Query.EQ("id", categoryId);
var cursor = items.Find(q);
cursor.SetFields(Fields.Include("c" + counterId + ".extDatas"));
var counter = cursor.FirstOrDefault();
if (counter == null || !counter.Contains("c" + counterId) || !counter["c" + counterId].AsBsonDocument.Contains("extDatas"))
{
return(Enumerable.Empty <CounterExtDataInfo>());
}
return
(counter["c" + counterId].AsBsonDocument["extDatas"].AsBsonArray.Select(d => new CounterExtDataInfo(d.AsBsonDocument["name"].AsString, d.AsBsonDocument["id"].AsInt32)));
}
private static void mongoCountVerb(string verbStringRepresentation, long article, int sentence_index, int verb_index)
{
string connectionString = "mongodb://localhost";
string databaseName = "crawler";
string collectionName = "verbs";
MongoServer server = MongoServer.Create(connectionString);
MongoDatabase database = server.GetDatabase(databaseName);
MongoCollection <BsonDocument> collection = database.GetCollection <BsonDocument>(collectionName);
BsonDocument seenOn = new BsonDocument().Add("article", article).Add("sentence_index", sentence_index).Add("verb_index", verb_index);
QueryComplete whereQuery = Query.EQ("verb", verbStringRepresentation);
UpdateBuilder updateQuery = Update.Inc("count", 1).Push("seen_on_sentence", seenOn);
collection.Update(whereQuery, updateQuery, UpdateFlags.Upsert);
server.Disconnect();
}
public async void Query(string bucket, string org)
{
string flux = $"from(bucket:\"{bucket}\") |> range(start: 0)";
var queryApi = client.GetQueryApi();
await queryApi.QueryAsync(flux, org, (cancellable, record) =>
{
QueryComplete?.Invoke(this, new QueryCompleteEventArgs(record));
},
exception =>
{
QueryException?.Invoke(this, new QueryExceptionEventArgs(exception));
},
() =>
{
QuerySuccess?.Invoke(this, new QuerySuccessEventArgs());
});
}
public virtual IList <TEntity> GetList(IEnumerable <int> ids)
{
QueryComplete query = Query.In("_id", BsonArray.Create(ids));
return(MongoAccessor.GetCollection <TEntity>().FindAs <TEntity>(query).ToList());
}
/// <summary> /// This method raises the QueryComplete event /// </summary> /// <param name="resultDataSet">DataSet returned by the query</param> /// <param name="executedCommand">This command lead to the provided result data set</param> /// <param name="entityName">Name of the last queried entity</param> protected virtual void RaiseOnQueryCompleteEvent(DataSet resultDataSet, IDbCommand executedCommand, string entityName) => QueryComplete?.Invoke(this, new QueryEventArgs(resultDataSet, executedCommand, entityName));
public List <CounterSeriesData> GetCounterData(DateTime beginDate, DateTime endDate, int counterCategoryId,
int counterNameId, int counterSourceId, int counterInstanceId,
int counterExtDataId, List <string> seriesFilter)
{
List <CounterSeriesData> resultData = new List <CounterSeriesData>();
if (seriesFilter.Count == 0)
{
return(resultData);
}
bool getAllSeries = seriesFilter.Contains("*");
List <string> seriesNames = new List <string>();
MongoCollection <BsonDocument> items = Database.GetCollection("countersData");
string mappedCategoryName = CountersMapper.GetMappedCategoryName(counterCategoryId);
string mappedCounterName = CountersMapper.GetMappedCounterName(counterCategoryId, counterNameId);
string mappedCounterInstance = CountersMapper.GetMappedCounterInstanceName(counterCategoryId, counterNameId,
counterInstanceId);
string mappedCounterSource = CountersMapper.GetMappedCounterSourceName(counterCategoryId, counterNameId,
counterSourceId);
string mappedCounterExtData = CountersMapper.GetMappedCounterExtDataName(counterCategoryId, counterNameId,
counterExtDataId);
QueryComplete qb = beginDate == endDate
? Query.EQ("date", beginDate)
: Query.GT("date", beginDate).LTE(endDate);
QueryComplete qb2 = Query.EQ("counterCategory", mappedCategoryName);
QueryComplete qb3 = Query.EQ("counterName", mappedCounterName);
SortByBuilder sortOrder = new SortByBuilder().Ascending("date");
var cursor = items.Find(Query.And(qb, qb2, qb3));
cursor.SetSortOrder(sortOrder);
string counterDescription = counterSourceId + "/" + counterInstanceId + "/" + counterExtDataId;
cursor.SetFields(Fields.Include("type", "date", "data." + counterDescription));
foreach (BsonDocument cnt in cursor)
{
var dateTime = cnt["date"].AsDateTime;
var countersData = cnt["data"].AsBsonDocument;
if (!countersData.Contains(counterDescription))
{
foreach (string seriesName in seriesNames)
{
if (getAllSeries || seriesFilter.Contains(seriesName))
{
resultData.Find(f => f.SeriesName == seriesName).AddSeriesPoint(new SeriesPoint(dateTime, null));
}
}
continue;
}
var seriesPoints = countersData[counterDescription].AsBsonDocument;
foreach (BsonElement seriesPoint in seriesPoints)
{
string seriesName = seriesPoint.Name;
if (!seriesNames.Contains(seriesName))
{
seriesNames.Add(seriesName);
}
if (!getAllSeries && !seriesFilter.Contains(seriesName))
{
continue;
}
var value = seriesPoint.Value.IsString
? new UniversalValue(
TimeSpan.Parse(seriesPoint.Value.AsString))
: new UniversalValue(
seriesPoint.Value.ToDouble());
var a = resultData.Find(f => f.SeriesName == seriesName);
if (a == null)
{
a = new CounterSeriesData(seriesName, value.Type, mappedCategoryName, mappedCounterName,
mappedCounterSource, mappedCounterInstance, mappedCounterExtData);
resultData.Add(a);
}
a.AddSeriesPoint(new SeriesPoint(dateTime, value));
}
}
return(resultData);
}
/// <summary>
/// Generates a $match pipeline command based upon the given query
/// </summary>
/// <param name="query">The query used to filter the pipeline document</param>
public static BsonDocument Match(QueryComplete query)
{
return(new BsonDocument("$match", query.ToBsonDocument()));
}
/// <summary> /// Static event sink that can be bound to data services and hand the /// event on to other potential subscribers /// </summary> /// <param name="sender">Sender (data service)</param> /// <param name="e">Query Event Arguments</param> private static void OnQueryComplete(object sender, QueryEventArgs e) => QueryComplete?.Invoke(sender, e);
/// <summary>
/// 通过Ids字段查找
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public MongoCursor <BsonDocument> FindByQuery(QueryComplete query)
{
var obj = dataOp.FindAllByQuery(tableName, query);
return(obj);
}
