/// <summary>
/// 查询邮件短信模板
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public static QueryResult<EmailAndSMSTemplates> QueryEmailAndSMSTemplates(EmailAndSMSTemplatesQueryFilter filter)
{
QueryResult<EmailAndSMSTemplates> result = new QueryResult<EmailAndSMSTemplates>();
result.ServicePageIndex = filter.ServicePageIndex;
result.PageSize = filter.PageSize;
PagingInfoEntity page = DataAccessUtil.ToPagingInfo(filter);
CustomDataCommand cmd = DataCommandManager.CreateCustomDataCommandFromConfig("QueryEmailAndSMSTemplates");
using (var sqlBuilder = new DynamicQuerySqlBuilder(cmd.CommandText, cmd, page, "SysNo DESC"))
{
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Status", DbType.Int32,
"@Status1", QueryConditionOperatorType.NotEqual, CommonStatus.Deleted);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "SysNo", DbType.Int32,
"@SysNo", QueryConditionOperatorType.Equal, filter.SysNo);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Category", DbType.String,
"@Category", QueryConditionOperatorType.Like, filter.Category);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Templates", DbType.String,
"@Templates", QueryConditionOperatorType.Like, filter.Templates);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Status", DbType.Int32,
"@Status", QueryConditionOperatorType.Equal, filter.Status);
cmd.CommandText = sqlBuilder.BuildQuerySql();
result.ResultList = cmd.ExecuteEntityList<EmailAndSMSTemplates>();
result.TotalCount = Convert.ToInt32(cmd.GetParameterValue("@TotalCount"));
return result;
}
}
/// <summary>
/// 查询日志
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public static QueryResult<Logs> QueryLogs(LogsQueryFilter filter)
{
QueryResult<Logs> result = new QueryResult<Logs>();
result.ServicePageIndex = filter.ServicePageIndex;
result.PageSize = filter.PageSize;
PagingInfoEntity page = DataAccessUtil.ToPagingInfo(filter);
CustomDataCommand cmd = DataCommandManager.CreateCustomDataCommandFromConfig("QueryLogs");
using (var sqlBuilder = new DynamicQuerySqlBuilder(cmd.CommandText, cmd, page, "SysNo DESC"))
{
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Classes", DbType.Int32,
"@Classes", QueryConditionOperatorType.Like, filter.Classes);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Section", DbType.Int32,
"@Section", QueryConditionOperatorType.Like, filter.Section);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Family", DbType.Int32,
"@Family", QueryConditionOperatorType.Like, filter.Family);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "RefenceSysNo", DbType.Int32,
"@RefenceSysNo", QueryConditionOperatorType.Like, filter.RefenceSysNo);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Contents", DbType.String,
"@Contents", QueryConditionOperatorType.Like, filter.Contents);
cmd.CommandText = sqlBuilder.BuildQuerySql();
result.ResultList = cmd.ExecuteEntityList<Logs>();
result.TotalCount = Convert.ToInt32(cmd.GetParameterValue("@TotalCount"));
return result;
}
}
public void TestToString(QueryResult result)
{
string queryResultToString = result.ToString();
if(result.ResultMessage == "Success")
{
if(result.RetrievedData != null)
{
string expectedString = "Success " + result.RetrievedData.ToString();
Assert.AreEqual(expectedString, queryResultToString);
}
}
else
{
if(result.ThrownException != null)
{
string expectedString = "Failed with Exception : " + result.ThrownException.ToString();
Assert.AreEqual(expectedString, queryResultToString);
}
else
{
string expectedString = "Failed ";
Assert.AreEqual(expectedString, queryResultToString);
}
}
}
public void CorrectlyInitialized()
{
var qr = new QueryResult<User>(new User[] {new User() {FirstName = "Arne"}}, 100);
Assert.Equal("Arne", qr.Items.First().FirstName);
Assert.Equal(100, qr.TotalCount);
}
public async Task<QueryResult<FileSystemMetadata>> GetFiles(string[] pathParts, string rootFolderId, GoogleCredentials googleCredentials,
CancellationToken cancellationToken)
{
var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
var driveService = fullDriveService.Item1;
var result = new QueryResult<FileSystemMetadata>();
if (pathParts != null && pathParts.Length > 0)
{
var name = pathParts.Last();
pathParts = pathParts.Take(pathParts.Length - 1).ToArray();
try
{
var parentId = await FindOrCreateParent(driveService, false, pathParts, rootFolderId, cancellationToken)
.ConfigureAwait(false);
var file = await FindFileId(name, parentId, driveService, cancellationToken).ConfigureAwait(false);
result.TotalRecordCount = 1;
result.Items = new[] { file }.Select(GetFileMetadata).ToArray();
}
catch (FileNotFoundException)
{
}
return result;
}
return result;
}
/// <summary>
/// 查询奖品
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
public static QueryResult<Gift> QueryGifts(GiftQueryFilter filter)
{
QueryResult<Gift> result = new QueryResult<Gift>();
result.ServicePageIndex = filter.ServicePageIndex;
result.PageSize = filter.PageSize;
PagingInfoEntity page = DataAccessUtil.ToPagingInfo(filter);
CustomDataCommand cmd = DataCommandManager.CreateCustomDataCommandFromConfig("QueryGifts");
using (var sqlBuilder = new DynamicQuerySqlBuilder(cmd.CommandText, cmd, page, "SysNo DESC"))
{
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Status", DbType.Int32,
"@Status1", QueryConditionOperatorType.NotEqual, CommonStatus.Deleted);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "SysNo", DbType.Int32,
"@SysNo", QueryConditionOperatorType.Equal, filter.SysNo);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "GiftName", DbType.String,
"@GiftName", QueryConditionOperatorType.Like, filter.GiftName);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "GiftID", DbType.String,
"@GiftID", QueryConditionOperatorType.Like, filter.GiftID);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Descriptions", DbType.String,
"@Descriptions", QueryConditionOperatorType.Like, filter.Descriptions);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "MarketPrice", DbType.Decimal,
"@MarketPrice", QueryConditionOperatorType.Like, filter.MarketPrice);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Status", DbType.Int32,
"@Status", QueryConditionOperatorType.Equal, filter.Status);
cmd.CommandText = sqlBuilder.BuildQuerySql();
result.ResultList = cmd.ExecuteEntityList<Gift>();
result.TotalCount = Convert.ToInt32(cmd.GetParameterValue("@TotalCount"));
return result;
}
}
public Task<QueryResult<BaseItemDto>> GetChannels(ChannelQuery query, CancellationToken cancellationToken)
{
var user = string.IsNullOrWhiteSpace(query.UserId)
? null
: _userManager.GetUserById(new Guid(query.UserId));
var channels = _channelEntities.OrderBy(i => i.SortName).ToList();
if (user != null)
{
channels = channels.Where(i => GetChannelProvider(i).IsEnabledFor(user) && i.IsVisible(user))
.ToList();
}
// Get everything
var fields = Enum.GetNames(typeof(ItemFields))
.Select(i => (ItemFields)Enum.Parse(typeof(ItemFields), i, true))
.ToList();
var returnItems = channels.Select(i => _dtoService.GetBaseItemDto(i, fields, user))
.ToArray();
var result = new QueryResult<BaseItemDto>
{
Items = returnItems,
TotalRecordCount = returnItems.Length
};
return Task.FromResult(result);
}
public Add_Investment(ref Portfolio p, QueryResult qr)
{
InitializeComponent();
ThisPortfolio = p;
tbCompanyName.Text = qr.Company;
}
public static void FillSearchResultsDatatable(ref DataGridView dgv, QueryResult qr)
{
foreach(StockDay sd in qr.StockDays)
{
dgv.Rows.Add(sd.Date.ToShortDateString(), sd.OpeningValue, sd.High, sd.Low, sd.ClosingValue, sd.TradeVolume, sd.AdjustedClosingValue);
}
}
public static string AnalyseQueryResults(QueryResult qr)
{
string output = string.Empty;
//Time span
output += string.Format(TimeTemplate, qr.StockDays.Count);
output += Environment.NewLine; output += Environment.NewLine;
//Average volume
output += string.Format(AverageTemplate, Math.Round(qr.AverageTradeVolume, 3));
output += Environment.NewLine; output += Environment.NewLine;
//Value Information
output += string.Format(PeaksTemplate, Math.Round(qr.AverageValue, 3),
Math.Round(qr.HighestValue, 3),
Math.Round(qr.LowestValue, 3),
Math.Round(qr.Divergence, 3),
Math.Round(qr.Divergence/ qr.AverageValue, 3)*100);
output += Environment.NewLine; output += Environment.NewLine;
return output;
}
public override QueryResult Import(IEnumerable<String> myLines, IGraphDBSession myIGraphDBSession, DBContext myDBContext, UInt32 parallelTasks = 1, IEnumerable<String> comments = null, ulong? offset = null, ulong? limit = null, VerbosityTypes verbosityTypes = VerbosityTypes.Errors)
{
var gqlQuery = new GraphQLQuery(myDBContext.DBPluginManager);
#region Evaluate Limit and Offset
if (offset != null)
{
myLines = myLines.SkipULong(offset.Value);
}
if (limit != null)
{
myLines = myLines.TakeULong(limit.Value);
}
#endregion
var queryResult = new QueryResult();
#region Import queries
if (parallelTasks > 1)
{
queryResult = ExecuteAsParallel(myLines, myIGraphDBSession, gqlQuery, verbosityTypes, parallelTasks, comments);
}
else
{
queryResult = ExecuteAsSingleThread(myLines, myIGraphDBSession, gqlQuery, verbosityTypes, comments);
}
#endregion
return queryResult;
}
/// <summary>
/// 查询公告
/// </summary>
/// <param name="filter">查询条件</param>
public static QueryResult<Notices> QueryNotices(NoticesQueryFilter filter)
{
QueryResult<Notices> result = new QueryResult<Notices>();
PagingInfoEntity page = new PagingInfoEntity();
page.SortField = (filter.SortList == null || filter.SortList.Count == 0) ? null : filter.SortListToString();
page.MaximumRows = filter.PageSize;
page.StartRowIndex = (filter.PageIndex - 1) * filter.PageSize;
CustomDataCommand cmd = DataCommandManager.CreateCustomDataCommandFromConfig("QueryNotices");
using (var sqlBuilder = new DynamicQuerySqlBuilder(cmd.CommandText, cmd, page, "SysNo DESC"))
{
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "SysNo", DbType.Int32, "@SysNo",
QueryConditionOperatorType.Equal, filter.SysNo);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Contents", DbType.String, "@Contents",
QueryConditionOperatorType.Like, filter.Contents);
sqlBuilder.ConditionConstructor.AddCondition(QueryConditionRelationType.AND, "Status", DbType.Int32, "@Status",
QueryConditionOperatorType.Equal, filter.Status);
cmd.CommandText = sqlBuilder.BuildQuerySql();
result.ResultList = cmd.ExecuteEntityList<Notices>();
int totalCount = Convert.ToInt32(cmd.GetParameterValue("@TotalCount"));
result.PagingInfo = new PagingInfo() { PageIndex = filter.PageIndex, PageSize = filter.PageSize, TotalCount = totalCount };
return result;
}
}
public void AssignedCorrectly()
{
var items = new FakeAggregate[] {new FakeAggregate(), new FakeAggregate()};
var conditions = new QueryResult<FakeAggregate>(items, 10);
Assert.Same(items, conditions.Items);
Assert.Equal(10, conditions.TotalCount);
}
public async Task<QueryResult<FileMetadata>> GetFiles(FileQuery query, string rootFolderId, GoogleCredentials googleCredentials,
CancellationToken cancellationToken)
{
var fullDriveService = CreateDriveServiceAndCredentials(googleCredentials);
var driveService = fullDriveService.Item1;
var result = new QueryResult<FileMetadata>();
if (!string.IsNullOrWhiteSpace(query.Id))
{
try
{
var file = await GetFile(query.Id, driveService, cancellationToken).ConfigureAwait(false);
result.TotalRecordCount = 1;
result.Items = new[] { file }.Select(GetFileMetadata).ToArray();
}
catch (FileNotFoundException)
{
}
return result;
}
if (query.FullPath != null && query.FullPath.Length > 0)
{
var name = query.FullPath.Last();
var pathParts = query.FullPath.Take(query.FullPath.Length - 1).ToArray();
try
{
var parentId = await FindOrCreateParent(driveService, false, pathParts, rootFolderId, cancellationToken)
.ConfigureAwait(false);
var file = await FindFileId(name, parentId, driveService, cancellationToken).ConfigureAwait(false);
result.TotalRecordCount = 1;
result.Items = new[] { file }.Select(GetFileMetadata).ToArray();
}
catch (FileNotFoundException)
{
}
return result;
}
var queryResult = await GetFiles(null, driveService, cancellationToken).ConfigureAwait(false);
var files = queryResult
.Select(GetFileMetadata)
.ToArray();
result.Items = files;
result.TotalRecordCount = files.Length;
return result;
}
public void QueryResultPropertyTest()
{
List<Int32> list = new List<int>();
int totalCount = 20;
QueryResult<Int32> querResult = new QueryResult<Int32>(list, totalCount);
Assert.AreSame(list, querResult.ResultList);
Assert.AreEqual<int>(totalCount, querResult.Total);
}
public QueryResult<Task> GetTasks(PagedDataRequest requestInfo)
{
var query = _session.QueryOver<Task>();
var totalItemCount = query.ToRowCountQuery().RowCount();
var startIndex = ResultsPagingUtility.CalculateStartIndex(requestInfo.PageNumber,
requestInfo.PageSize);
var tasks = query.Skip(startIndex).Take(requestInfo.PageSize).List();
var queryResult = new QueryResult<Task>(tasks, totalItemCount, requestInfo.PageSize);
return queryResult;
}
public Byte[] ExportQueryResult(QueryResult myQueryResult)
{
return Encoding.UTF8.GetBytes(
GEXF_IO_Extensions.GEXFDocument2String(
GEXF_IO_Extensions.BuildGEXFDocument(
myQueryResult.ToGEXF()
)
)
);
}
public static QueryResult Execute(string query, DbConnectionInfo connectionInfo)
{
var result = new QueryResult();
Stopwatch swatch = new Stopwatch();
swatch.Start();
try
{
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = query;
cmd.CommandType = CommandType.Text;
var reader = cmd.ExecuteReader();
var fieldCount = reader.FieldCount;
var dt = new DataTable();
for (int i = 0; i < fieldCount; i++)
{
var name = reader.GetName(i);
var ft = reader.GetFieldType(i);
dt.Columns.Add(new DataColumn(name, ft));
}
while (reader.Read())
{
var row = dt.NewRow();
for (int i = 0; i < fieldCount; i++)
{
row[i] = reader.GetValue(i);
}
dt.Rows.Add(row);
}
result.DataTable = dt;
//foreach (DataColumn column in dt.Columns)
//{
// Debug.WriteLine(string.Format("var {0}Pos = reader.GetOrdinal(\"{1}\");", Char.ToLowerInvariant(column.ColumnName[0]) + column.ColumnName.Substring(1), column.ColumnName));
//}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
result.QueryTimeSpan = swatch.Elapsed;
swatch.Stop();
return result;
}
public static void Fill(ComboBox combobox, QueryResult queryResult)
{
CellRendererText cellRendererText = new CellRendererText ();
combobox.PackStart (cellRendererText, false);
combobox.SetCellDataFunc (cellRendererText,
delegate(CellLayout cell_layout, CellRenderer cell, TreeModel tree_model, TreeIter iter) {
IList row = (IList)tree_model.GetValue (iter, 0);
cellRendererText.Text = row [1].ToString ();
});
ListStore listStore = new ListStore (typeof(IList));
foreach (IList row in queryResult.Rows)
listStore.AppendValues (row);
combobox.Model = listStore;
}
/// <summary>
/// Renders the graph on the Compare Stocks UI
/// </summary>
/// <param name="c">Reference to the chart to be Rendered</param>
/// <param name="q1">QueryResult Object for the Company 1</param>
/// <param name="q2">QueryResult Object for the Company 2</param>
public static void renderCompareStocksGraph(ref Chart c, QueryResult q1, QueryResult q2)
{
foreach(StockDay s1 in q1.StockDays)
{
c.Series["Company1"].Points.AddXY(s1.Date, (double)s1.High, (double)s1.Low, (double)s1.OpeningValue, (double)s1.ClosingValue);
}
c.Series["Company1"].Name = q1.Company;
foreach (StockDay s2 in q2.StockDays)
{
c.Series["Company2"].Points.AddXY(s2.Date, (double)s2.High, (double)s2.Low, (double)s2.OpeningValue, (double)s2.ClosingValue);
}
c.Series["Company2"].Name = q2.Company;
}
public async Task<QueryResult<ChannelItemInfo>> Browse(ContentDirectoryBrowseRequest request, CancellationToken cancellationToken)
{
var options = new HttpRequestOptions
{
CancellationToken = cancellationToken,
UserAgent = "Emby",
RequestContentType = "text/xml; charset=\"utf-8\"",
LogErrorResponseBody = true,
Url = request.ContentDirectoryUrl,
BufferContent = false
};
options.RequestHeaders["SOAPACTION"] = "urn:schemas-upnp-org:service:ContentDirectory:1#Browse";
options.RequestContent = GetRequestBody(request);
var response = await _httpClient.SendAsync(options, "POST");
using (var reader = new StreamReader(response.Content))
{
var doc = XDocument.Parse(reader.ReadToEnd(), LoadOptions.PreserveWhitespace);
var queryResult = new QueryResult<ChannelItemInfo>();
if (doc.Document == null)
return queryResult;
var responseElement = doc.Document.Descendants(UNamespace + "BrowseResponse").ToList();
var countElement = responseElement.Select(i => i.Element("TotalMatches")).FirstOrDefault(i => i != null);
var countValue = countElement == null ? null : countElement.Value;
int count;
if (!string.IsNullOrWhiteSpace(countValue) && int.TryParse(countValue, NumberStyles.Integer, CultureInfo.InvariantCulture, out count))
{
queryResult.TotalRecordCount = count;
var resultElement = responseElement.Select(i => i.Element("Result")).FirstOrDefault(i => i != null);
var resultString = (string)resultElement;
if (resultElement != null)
{
var xElement = XElement.Parse(resultString);
}
}
return queryResult;
}
}
public ClientQueryResultResource(QueryResult<ClientSummary> result, UrlHelper url, ClientMetaData meta)
{
if (result == null) throw new ArgumentNullException("result");
if (url == null) throw new ArgumentNullException("url");
if (meta == null) throw new ArgumentNullException("meta");
Data = new ClientQueryResultResourceData(result, url, meta);
var links = new Dictionary<string, object>();
if (meta.SupportsCreate)
{
links["create"] = new CreateClientLink(url, meta);
};
Links = links;
}
public static QueryResult Execute(string query, DbConnectionInfo connectionInfo)
{
var result = new QueryResult();
Stopwatch swatch = new Stopwatch();
swatch.Start();
try
{
using (var conn = new MySqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = query;
cmd.CommandType = CommandType.Text;
var reader = cmd.ExecuteReader();
var fieldCount = reader.FieldCount;
DataTable dt = new DataTable();
for (int i = 0; i < fieldCount; i++)
{
var name = reader.GetName(i);
var ft = reader.GetFieldType(i);
Debug.Assert(ft != null, "ft != null");
dt.Columns.Add(new DataColumn(name, ft));
}
while (reader.Read())
{
var row = dt.NewRow();
for (int i = 0; i < fieldCount; i++)
{
row[i] = reader.GetValue(i);
}
dt.Rows.Add(row);
}
result.DataTable = dt;
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
result.QueryTimeSpan = swatch.Elapsed;
swatch.Stop();
return result;
}
/// <summary>
/// Executes the <see cref="QueryExecutionPlan"/> on the database.
/// </summary>
/// <returns>Results from the query execution.</returns>
public QueryResult Execute()
{
var result = new QueryResult();
foreach (var operation in this.Operations)
{
// TODO: Row shouldn't be created here.
var results = operation.Execute(db);
var row = new Row();
foreach (var r in results)
{
row.Columns.Add(r.Key, r.Value);
}
result.Rows.Add(row);
}
return result;
}
public QueryResult<Game> GetGames(PagedDataRequest requestInfo)
{
// IQueryOver instance provides queryable access to the table: haven't fetched any data from database yet.
var query = _session.QueryOver<Game>();
// Queries the database
var totalItemCount = query.ToRowCountQuery().RowCount();
var startIndex = ResultsPagingUtility.CalculateStartIndex(requestInfo.PageNumber, requestInfo.PageSize);
// Only 1 page of data is fetched from the database
var games = query.Skip(startIndex).Take(requestInfo.PageSize).List();
var queryResult = new QueryResult<Game>(games, totalItemCount, requestInfo.PageSize);
return queryResult;
}
public Search_Results(QueryResult qr, ref Portfolio pt)
{
InitializeComponent();
label3.Text = qr.Company;
label4.Text = qr.StockDays[0].Date.ToShortDateString();
label5.Text = qr.StockDays[qr.StockDays.Count - 1].Date.ToShortDateString();
thisPortfolio = pt;
this.queryResult = qr;
RenderGraph.renderSearchResultGraph(ref chart1, qr);
DataDisplay.FillSearchResultsDatatable(ref dataGridView1, qr);
lblAnalysis.Text = DataAnalysis.AnalyseQueryResults(qr);
}
public static void renderCompareAnalysisGraph(ref Chart c, QueryResult qr1, QueryResult qr2)
{
for (int i = 0; i < 2; i++)
{
QueryResult qr = i == 0 ? qr1 : qr2;
c.Series[4* i + 1].Points.AddXY("Average Trade Volume", Math.Round(qr.AverageTradeVolume, 3));
c.Series[4* i].Points.AddXY("Highest Value", Math.Round(qr.HighestValue, 3));
c.Series[4* i].Points.AddXY("Average Value", Math.Round(qr.AverageValue, 3));
c.Series[4* i].Points.AddXY("Lowest Value", Math.Round(qr.LowestValue, 3));
c.Series[4 * i + 2].Points.AddXY("Oscillation", Math.Round(qr1.Divergence, 3));
c.Series[4 * i + 3].Points.AddXY("Oscilation % in average value", Math.Round(qr.Divergence / qr.AverageValue, 3) * 100);
for (int j = 0; j < 4; j++)
c.Series[4 * i + j].Name += i == 0 ? " " + qr1.Company : qr2.Company;
}
}
public void ParseRetrievedData()
{
QueryResult qr = new QueryResult(
DataRetriever.RetrieveData(DataProviders.YahooFinance, DateTime.Parse("2014-03-27"), DateTime.Parse("2015-11-27"), "GOOG"), "GOOG");
Assert.AreEqual<int>(423, qr.StockDays.Count, "Incorrect number of Stock days. FAILED.");
foreach (StockDay sd in qr.StockDays)
{
Assert.IsNotNull(sd.AdjustedClosingValue, "Stock day has a null field. FAILED.");
Assert.IsNotNull(sd.ClosingValue, "Stock day has a null field. FAILED.");
Assert.IsNotNull(sd.Date, "Stock day has a null field. FAILED.");
Assert.IsNotNull(sd.High, "Stock day has a null field. FAILED.");
Assert.IsNotNull(sd.Low, "Stock day has a null field. FAILED.");
Assert.IsNotNull(sd.OpeningValue, "Stock day has a null field. FAILED.");
Assert.IsNotNull(sd.TradeVolume, "Stock day has a null field. FAILED.");
}
}
public QueryResult Import(String location, IGraphDBSession graphDBSession, DBContext myDBContext, UInt32 parallelTasks = 1, IEnumerable<string> comments = null, UInt64? offset = null, UInt64? limit = null, VerbosityTypes verbosityType = VerbosityTypes.Errors)
{
QueryResult result = new QueryResult();
Stream stream = null;
#region Read querie lines from location
try
{
if (location.ToLower().StartsWith(@"file:\\"))
{
//lines = ReadFile(location.Substring(@"file:\\".Length));
stream = GetStreamFromFile(location.Substring(@"file:\\".Length));
}
else if (location.ToLower().StartsWith("http://"))
{
stream = GetStreamFromHttp(location);
}
else
{
return new QueryResult(new Exceptional(new Error_InvalidImportLocation(location, @"file:\\", "http://")));
}
#region Start import using the AGraphDBImport implementation and return the result
return Import(stream, graphDBSession, myDBContext, parallelTasks, comments, offset, limit, verbosityType);
#endregion
}
catch (Exception ex)
{
return new QueryResult(new Exceptional(new Error_ImportFailed(ex)));
}
finally
{
if (stream != null)
{
stream.Dispose();
}
}
#endregion
}
public ResponseWrapper.QueryResult<string> DisplayMessage()
{
QueryResult<string> result = new QueryResult<string>();
try
{
result.IsResult = true;
result.IsOperationSuccessful = true;
result.Result = "Sew Repository Related Webservices!!!";
}
catch (Exception ex)
{
result.IsOperationSuccessful = false;
result.IsResult = false;
var err = new List<Message>();
err.Add(new Message { Code = Convert.ToInt32(Enums.MessageCode.WarningMessage), Text = ex.Message });
result.ErrorMessages = err;
}
return result;
}
protected override void InvokeAfterQueryExecuted(QueryResult result)
{
_source.InvokeAfterQueryExecuted(result);
}
public async Task <SDNetwork> NetworkDiscoveryAsync(TransactionContext ltransactionContext, bool force, CancellationToken token = default(CancellationToken))
{
using (await discoverLock.LockAsync(token).ConfigureAwait(false))
{
logger.Trace($"Network discovery force: {force}");
List <Peer> speers = serviceDiscoveryPeers.Shuffle().ToList();
SDNetwork ret = sdNetwork;
if (!force && null != ret && !ret.TimeElapsed)
{
return(ret);
}
ret = null;
foreach (Peer serviceDiscoveryPeer in speers)
{
try
{
SDNetwork lsdNetwork = new SDNetwork(SERVICE_DISCOVER_FREQ_SECONDS);
byte[] clientTLSCertificateDigest = serviceDiscoveryPeer.GetClientTLSCertificateDigest();
logger.Info($"Channel {channelName} doing discovery with peer: {serviceDiscoveryPeer}");
if (null == clientTLSCertificateDigest)
{
throw new ArgumentException($"Channel {channelName}, peer {serviceDiscoveryPeer} requires mutual tls for service discovery.");
}
ByteString clientIdent = ltransactionContext.Identity.ToByteString();
ByteString tlshash = ByteString.CopyFrom(clientTLSCertificateDigest);
AuthInfo authentication = new AuthInfo();
authentication.ClientIdentity = clientIdent;
authentication.ClientTlsCertHash = tlshash;
List <Query> fq = new List <Query>(2);
Query cq = new Query();
Query pq = new Query();
cq.Channel = channelName;
pq.Channel = channelName;
cq.ConfigQuery = new ConfigQuery();
pq.PeerQuery = new PeerMembershipQuery();
fq.Add(cq);
fq.Add(pq);
Request request = new Request();
request.Queries.AddRange(fq);
request.Authentication = authentication;
ByteString payloadBytes = request.ToByteString();
ByteString signatureBytes = ltransactionContext.SignByteStrings(payloadBytes);
SignedRequest sr = new SignedRequest();
sr.Payload = payloadBytes;
sr.Signature = signatureBytes;
if (IS_TRACE_LEVEL && null != diagnosticFileDumper) // dump protobuf we sent
{
logger.Trace($"Service discovery channel {channelName} {serviceDiscoveryPeer} service chaincode query sent {diagnosticFileDumper.CreateDiagnosticProtobufFile(sr.ToByteArray())}");
}
Response response = await serviceDiscoveryPeer.SendDiscoveryRequestAsync(sr, SERVICE_DISCOVERY_WAITTIME, token).ConfigureAwait(false);
if (IS_TRACE_LEVEL && null != diagnosticFileDumper) // dump protobuf we get
{
logger.Trace($"Service discovery channel {channelName} {serviceDiscoveryPeer} service discovery returned {diagnosticFileDumper.CreateDiagnosticProtobufFile(response.ToByteArray())}");
}
//serviceDiscoveryPeer.HasConnected; ???
List <QueryResult> resultsList = response.Results.ToList();
QueryResult queryResult = resultsList[0]; //configquery
if (queryResult.ResultCase == QueryResult.ResultOneofCase.Error)
{
logger.Warn($"Channel {channelName} peer: {serviceDiscoveryPeer} error during service discovery {queryResult.Error.Content}");
continue;
}
QueryResult queryResult2 = resultsList[1];
if (queryResult2.ResultCase == QueryResult.ResultOneofCase.Error)
{
logger.Warn($"Channel {channelName} peer: {serviceDiscoveryPeer} error during service discovery {queryResult2.Error.Content}");
continue;
}
ConfigResult configResult = queryResult.ConfigResult;
Dictionary <string, FabricMSPConfig> msps = configResult.Msps.ToDictionary(a => a.Key, a => a.Value);
HashSet <ByteString> cbbs = new HashSet <ByteString>();
foreach (string i in msps.Keys)
{
FabricMSPConfig value = msps[i];
string mspid = value.Name;
cbbs.AddRange(value.RootCerts);
cbbs.AddRange(value.IntermediateCerts);
value.RootCerts.ToList().ForEach(a => lsdNetwork.AddTlsCert(mspid, a.ToByteArray()));
value.TlsIntermediateCerts.ToList().ForEach(a => lsdNetwork.AddTlsIntermCert(mspid, a.ToByteArray()));
}
List <byte[]> toaddCerts = new List <byte[]>();
AddCerts(cbbs, toaddCerts);
if (toaddCerts.Count > 0) // add them to crypto store.
{
toaddCerts.ForEach(a => channel.Client.CryptoSuite.Store.AddCertificate(a.ToUTF8String()));
}
Dictionary <string, SDOrderer> ordererEndpoints = new Dictionary <string, SDOrderer>();
Dictionary <string, Endpoints> orderersMap = configResult.Orderers.ToDictionary(a => a.Key, a => a.Value);
foreach (string mspid in orderersMap.Keys)
{
Endpoints value = orderersMap[mspid];
foreach (Protos.Discovery.Endpoint l in value.Endpoint)
{
string endpoint = l.Host + ":" + l.Port.ToString().ToLowerInvariant().Trim();
logger.Trace($"Channel {channelName} discovered orderer MSPID: {mspid}, endpoint: {endpoint}");
SDOrderer sdOrderer = new SDOrderer(channel, mspid, endpoint, lsdNetwork.GetTlsCerts(mspid), lsdNetwork.GetTlsIntermediateCerts(mspid));
ordererEndpoints[sdOrderer.Endpoint] = sdOrderer;
}
}
lsdNetwork.SetOrdererEndpoints(ordererEndpoints);
PeerMembershipResult membership = queryResult2.Members;
Dictionary <string, SDEndorser> endorsers = new Dictionary <string, SDEndorser>();
foreach (string mspId in membership.PeersByOrg.Keys)
{
Peers peer = membership.PeersByOrg[mspId];
foreach (Protos.Discovery.Peer pp in peer.Peers_)
{
SDEndorser ppp = new SDEndorser(channel, pp, lsdNetwork.GetTlsCerts(mspId), lsdNetwork.GetTlsIntermediateCerts(mspId));
logger.Trace($"Channel {channelName} discovered peer MSPID: {mspId}, endpoint: {ppp.Endpoint}");
endorsers[ppp.Endpoint] = ppp;
}
}
lsdNetwork.SetEndorsers(endorsers);
lsdNetwork.End();
sdNetwork = lsdNetwork;
ret = lsdNetwork;
break;
}
catch (Exception e)
{
logger.Warn($"Channel {channelName} peer {serviceDiscoveryPeer} service discovery error {e.Message}");
}
}
logger.Debug($"Channel {channelName} service discovery completed: {ret != null}");
return(ret);
}
}
public override int Export()
{
IAssetType assetType = _metaAPI.GetAssetType("Goal");
Query query = new Query(assetType);
IAttributeDefinition assetStateAttribute = assetType.GetAttributeDefinition("AssetState");
query.Selection.Add(assetStateAttribute);
IAttributeDefinition assetNumberAttribute = assetType.GetAttributeDefinition("Number");
query.Selection.Add(assetNumberAttribute);
IAttributeDefinition targetedByAttribute = assetType.GetAttributeDefinition("TargetedBy.ID");
query.Selection.Add(targetedByAttribute);
IAttributeDefinition scopeAttribute = assetType.GetAttributeDefinition("Scope");
query.Selection.Add(scopeAttribute);
IAttributeDefinition descriptionAttribute = assetType.GetAttributeDefinition("Description");
query.Selection.Add(descriptionAttribute);
IAttributeDefinition nameAttribute = assetType.GetAttributeDefinition("Name");
query.Selection.Add(nameAttribute);
IAttributeDefinition priorityAttribute = assetType.GetAttributeDefinition("Priority");
query.Selection.Add(priorityAttribute);
IAttributeDefinition categoryAttribute = assetType.GetAttributeDefinition("Category");
query.Selection.Add(categoryAttribute);
//Filter on parent scope.
IAttributeDefinition parentScopeAttribute = assetType.GetAttributeDefinition("Scope.ParentMeAndUp");
FilterTerm term = new FilterTerm(parentScopeAttribute);
term.Equal(_config.V1SourceConnection.Project);
query.Filter = term;
string SQL = BuildGoalInsertStatement();
if (_config.V1Configurations.PageSize != 0)
{
query.Paging.Start = 0;
query.Paging.PageSize = _config.V1Configurations.PageSize;
}
int assetCounter = 0;
int assetTotal = 0;
do
{
QueryResult result = _dataAPI.Retrieve(query);
assetTotal = result.TotalAvaliable;
foreach (Asset asset in result.Assets)
{
using (SqlCommand cmd = new SqlCommand())
{
//NAME NPI MASK:
object name = GetScalerValue(asset.GetAttribute(nameAttribute));
if (_config.V1Configurations.UseNPIMasking == true && name != DBNull.Value)
{
name = ExportUtils.RemoveNPI(name.ToString());
}
//DESCRIPTION NPI MASK:
object description = GetScalerValue(asset.GetAttribute(descriptionAttribute));
if (_config.V1Configurations.UseNPIMasking == true && description != DBNull.Value)
{
description = ExportUtils.RemoveNPI(description.ToString());
}
cmd.Connection = _sqlConn;
cmd.CommandText = SQL;
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.AddWithValue("@AssetOID", asset.Oid.ToString());
cmd.Parameters.AddWithValue("@AssetState", GetScalerValue(asset.GetAttribute(assetStateAttribute)));
cmd.Parameters.AddWithValue("@AssetNumber", GetScalerValue(asset.GetAttribute(assetNumberAttribute)));
cmd.Parameters.AddWithValue("@TargetedBy", GetMultiRelationValues(asset.GetAttribute(targetedByAttribute)));
cmd.Parameters.AddWithValue("@Scope", GetSingleRelationValue(asset.GetAttribute(scopeAttribute)));
cmd.Parameters.AddWithValue("@Description", description);
cmd.Parameters.AddWithValue("@Name", name);
cmd.Parameters.AddWithValue("@Priority", GetSingleRelationValue(asset.GetAttribute(priorityAttribute)));
cmd.Parameters.AddWithValue("@Category", GetSingleRelationValue(asset.GetAttribute(categoryAttribute)));
cmd.ExecuteNonQuery();
}
assetCounter++;
}
query.Paging.Start = assetCounter;
} while (assetCounter != assetTotal);
return(assetCounter);
}
/// <summary>
/// 读取部落列表
/// </summary>
private static void LoadClanList()
{
bool l_bIsReturn = false;
Session l_Session = new Session(BaseDatabase.Domain);
l_Session.BeginTransaction();
{
do
{
Query l_QueryListClan = new Query(l_Session, "Select ListClan instances");
QueryResult l_ListClanResult = l_QueryListClan.Execute();
if (l_ListClanResult == null)
{
Debug.WriteLine("Program.LoadClanList(...) - l_ListClanResult == null error!");
l_bIsReturn = true;
break;
}
for (int iIndex = 0; iIndex < l_ListClanResult.Count; iIndex++)
{
ListClan l_ListClan = l_ListClanResult[iIndex] as ListClan;
if (l_ListClan == null)
{
Debug.WriteLine("Program.LoadClanList(...) - l_ListClan == null error!");
l_bIsReturn = true;
break;
}
Clan l_Clan = new Clan();
l_Clan.ClanGuid = l_ListClan.ClanGuid;
l_Clan.ClanName = l_ListClan.ClanName;
l_Clan.Logo = l_ListClan.Logo;
l_Clan.Back = l_ListClan.Back;
l_Clan.Grade = l_ListClan.Grade;
l_Clan.CP = l_ListClan.CP;
l_Clan.Slogan = l_ListClan.Slogan;
l_Clan.News = l_ListClan.News;
//////////////////////////////////////////////////////////////////////////
// 获取部落的成员信息
Query l_QueryCharacters = new Query(l_Session, "Select Characters instances where {ClanGuid}=@ClanGuid");
l_QueryCharacters.Parameters.Add("@ClanGuid", l_ListClan.ClanGuid);
QueryResult l_CharactersResult = l_QueryCharacters.Execute();
if (l_CharactersResult == null)
{
Debug.WriteLine("Program.LoadClanList(...) - l_CharactersResult == null error!");
l_bIsReturn = true;
break;
}
for (int iIndex2 = 0; iIndex2 < l_CharactersResult.Count; iIndex2++)
{
Characters l_Characters = l_CharactersResult[iIndex2] as Characters;
if (l_Characters == null)
{
Debug.WriteLine("Program.LoadClanList(...) - l_Characters == null error!");
l_bIsReturn = true;
break;
}
ClanMember l_ClanMember = new ClanMember();
l_ClanMember.CharacterName = l_Characters.CharacterName;
l_ClanMember.ClanGuid = l_Characters.ClanGuid;
l_ClanMember.ClanRank = l_Characters.ClanRank;
l_Clan.AddClanMemberList(l_ClanMember);
}
if (l_bIsReturn == true)
{
break;
}
Program.AddClanList(l_Clan);
}
} while (false);
}
l_Session.Commit();
if (l_bIsReturn == true)
{
throw new Exception("读取部落列表 错误！");
}
LOGs.WriteLine(LogMessageType.MSG_INFO, "信息: 部落列表读取完成！");
}
public override void OnActionExecuted(ActionExecutedContext context)
{
var qs = QueryFns.ExtractAndDecodeQueryString(context);
if (qs == null)
{
base.OnActionExecuted(context);
return;
}
var queryable = QueryFns.ExtractQueryable(context);
if (queryable == null)
{
base.OnActionExecuted(context);
return;
}
var eq = new EntityQuery(qs);
var eleType = TypeFns.GetElementType(queryable.GetType());
eq.Validate(eleType);
int?inlineCount = null;
queryable = eq.ApplyWhere(queryable, eleType);
if (eq.IsInlineCountEnabled)
{
inlineCount = (int)Queryable.Count((dynamic)queryable);
}
queryable = eq.ApplyOrderBy(queryable, eleType);
queryable = eq.ApplySkip(queryable, eleType);
queryable = eq.ApplyTake(queryable, eleType);
queryable = eq.ApplySelect(queryable, eleType);
queryable = eq.ApplyExpand(queryable, eleType);
// if a select or expand was encountered we need to
// execute the DbQueries here, so that any exceptions thrown can be properly returned.
// if we wait to have the query executed within the serializer, some exceptions will not
// serialize properly.
var listResult = Enumerable.ToList((dynamic)queryable);
var qr = new QueryResult(listResult, inlineCount);
var breezeConfig = context.HttpContext.RequestServices.GetService <IBreezeConfig>();
context.Result = new ObjectResult(qr)
{
Formatters = new FormatterCollection <IOutputFormatter>
{
#if NETCOREAPP3_0
new NewtonsoftJsonOutputFormatter(breezeConfig.GetJsonSerializerSettings(),
context.HttpContext.RequestServices.GetRequiredService <ArrayPool <char> >(),
context.HttpContext.RequestServices.GetRequiredService <MvcOptions>())
#else
new JsonOutputFormatter(breezeConfig.GetJsonSerializerSettings(),
context.HttpContext.RequestServices.GetRequiredService <ArrayPool <char> >())
#endif
}
};
var session = GetSession(queryable);
if (session != null)
{
Close(session);
}
base.OnActionExecuted(context);
}
public async Task <QueryResult <Group> > GetGroups(Query queryObj)
{
var result = new QueryResult <Group>();
var query = context.Groups.Where(g => g.isDeleted == false)
.Include(p => p.Project)
.Include(p => p.Enrollments)
.ThenInclude(e => e.Student)
.Include(p => p.UploadedFiles)
.Include(p => p.Lecturer)
.Include(p => p.Major)
.Include(p => p.Quarter)
.Include(p => p.Board)
.ThenInclude(be => be.BoardEnrollments)
.ThenInclude(ce => ce.BoardRole)
.Include(p => p.Board)
.ThenInclude(be => be.BoardEnrollments)
// .ThenInclude(ce => ce.Lecturer)
.Include(p => p.Board)
.ThenInclude(be => be.Group)
.ThenInclude(ge => ge.Project)
.AsQueryable();
//filter
if (queryObj.LecturerId.HasValue)
{
query = query.Where(q => q.Lecturer.LecturerId == queryObj.LecturerId.Value);
}
if (queryObj.ProjectId.HasValue)
{
query = query.Where(q => q.Project.ProjectId == queryObj.ProjectId.Value);
}
if (queryObj.isConfirm != null)
{
query = query.Where(q => q.isConfirm.Equals(queryObj.isConfirm));
}
if (queryObj.Email != null)
{
query = query.Where(q => q.Lecturer.Email.Equals(queryObj.Email) || q.Lecturer == null);
}
if (queryObj.QuarterId.HasValue)
{
query = query.Where(q => q.Quarter.QuarterId == queryObj.QuarterId.Value);
}
//search
if (queryObj.GroupNameSearch != null)
{
query = query.Where(q => q.GroupName.ToLower().NonUnicode().Contains(queryObj.GroupNameSearch.ToLower().NonUnicode()));
}
if (queryObj.LinkGitHubSearch != null)
{
query = query.Where(q => q.LinkGitHub.ToLower().NonUnicode().Contains(queryObj.LinkGitHubSearch.ToLower().NonUnicode()));
}
if (queryObj.ResultGradeSearch != null)
{
query = query.Where(q => q.ResultGrade.ToLower().NonUnicode().Contains(queryObj.ResultGradeSearch.ToLower().NonUnicode()));
}
if (queryObj.ResultScoreSearch != null)
{
query = query.Where(q => q.ResultScore.ToLower().NonUnicode().Contains(queryObj.ResultScoreSearch.ToLower().NonUnicode()));
}
//sort
var columnsMap = new Dictionary <string, Expression <Func <Group, object> > >()
{
["name"] = s => s.GroupName,
["quarter"] = s => s.Quarter.QuarterName,
["lecturer"] = s => s.Lecturer.Name,
["project"] = s => s.Project.Title
};
if (queryObj.SortBy != "id" || queryObj.IsSortAscending != true)
{
query = query.OrderByDescending(s => s.GroupId);
}
query = query.ApplyOrdering(queryObj, columnsMap);
result.TotalItems = await query.CountAsync();
//paging
query = query.ApplyPaging(queryObj);
result.Items = await query.ToListAsync();
return(result);
}
public async Task <QueryResult <Campaign> > GetAgentValidCampaignsAsync(string userId, CampaignQuery queryObj)
{
var result = new QueryResult <Campaign>();
var query = entities
.Where(cp => cp.UserId.Equals(userId) &&
cp.IsActive &&
cp.FinishDate > DateTime.Now)
.OrderByDescending(cp => cp.Id)
.Select(
c => new Campaign
{
Id = c.Id,
StartDate = c.StartDate,
FinishDate = c.FinishDate,
IsActive = c.IsActive,
CampaignDetails = (ICollection <CampaignDetail>)c.CampaignDetails
.Where(cd => !cd.State.Equals(CampaignStatus.Earned.ToString()))
.Select(
cd => new CampaignDetail
{
Id = cd.Id,
CampaignId = cd.CampaignId,
CustomerId = cd.CustomerId,
Customer = new Customer
{
Id = cd.Customer.Id,
FirstName = cd.Customer.FirstName,
LastName = cd.Customer.LastName,
IdentificationCard = cd.Customer.IdentificationCard,
Email = cd.Customer.Email,
Address = cd.Customer.Address,
City = cd.Customer.City,
Region = cd.Customer.Region,
PostalCode = cd.Customer.PostalCode,
Country = cd.Customer.Country,
HomePhone = cd.Customer.HomePhone,
CellPhone = cd.Customer.CellPhone,
State = cd.Customer.State
},
LastCallDate = cd.LastCallDate,
LastCallDuration = cd.LastCallDuration,
LastValidCallDate = cd.LastValidCallDate,
LastValidCallDuration = cd.LastValidCallDuration,
TotalCallsNumber = cd.TotalCallsNumber,
State = cd.State
}
)
}
);
query = query.ApplyFiltering(queryObj);
var columnsMap = new Dictionary <string, Expression <Func <Campaign, object> > >()
{
["finishDate"] = c => c.FinishDate,
};
query = query.ApplyOrdering(queryObj, columnsMap);
result.TotalItems = await query.CountAsync();
query = query.ApplyPaging(queryObj);
result.Items = await query.ToListAsync();
return(result);
}
public async void AddInstancesToListAsync_AddsExpected()
{
var options = new ConsulDiscoveryOptions();
var queryResult = new QueryResult <ServiceEntry[]>()
{
Response = new ServiceEntry[]
{
new ServiceEntry()
{
Service = new AgentService()
{
Service = "ServiceId",
Address = "foo.bar.com",
Port = 1234,
Tags = new string[] { "foo=bar", "secure=true" }
}
},
new ServiceEntry()
{
Service = new AgentService()
{
Service = "ServiceId",
Address = "foo1.bar1.com",
Port = 5678,
Tags = new string[] { "bar=foo", "secure=false" }
}
}
}
};
var result = Task.FromResult(queryResult);
var clientMoq = new Mock <IConsulClient>();
var healthMoq = new Mock <IHealthEndpoint>();
clientMoq.Setup(c => c.Health).Returns(healthMoq.Object);
healthMoq.Setup(h => h.Service("ServiceId", options.DefaultQueryTag, options.QueryPassing, QueryOptions.Default, default(CancellationToken))).Returns(result);
var dc = new ConsulDiscoveryClient(clientMoq.Object, options);
var list = new List <IServiceInstance>();
await dc.AddInstancesToListAsync(list, "ServiceId", QueryOptions.Default);
Assert.Equal(2, list.Count);
var inst = list[0];
Assert.Equal("foo.bar.com", inst.Host);
Assert.Equal("ServiceId", inst.ServiceId);
Assert.True(inst.IsSecure);
Assert.Equal(1234, inst.Port);
Assert.Equal(2, inst.Metadata.Count);
Assert.Contains("foo", inst.Metadata.Keys);
Assert.Contains("secure", inst.Metadata.Keys);
Assert.Contains("bar", inst.Metadata.Values);
Assert.Contains("true", inst.Metadata.Values);
Assert.Equal(new Uri("https://foo.bar.com:1234"), inst.Uri);
inst = list[1];
Assert.Equal("foo1.bar1.com", inst.Host);
Assert.Equal("ServiceId", inst.ServiceId);
Assert.False(inst.IsSecure);
Assert.Equal(5678, inst.Port);
Assert.Equal(2, inst.Metadata.Count);
Assert.Contains("bar", inst.Metadata.Keys);
Assert.Contains("secure", inst.Metadata.Keys);
Assert.Contains("foo", inst.Metadata.Values);
Assert.Contains("false", inst.Metadata.Values);
Assert.Equal(new Uri("http://foo1.bar1.com:5678"), inst.Uri);
}
/// <summary> Gets the given request. </summary>
/// <param name="request"> The request. </param>
/// <returns> A Task<object> </returns>
public async Task <object> Get(GetReportDownload request)
{
if (string.IsNullOrEmpty(request.IncludeItemTypes))
{
return(null);
}
request.DisplayType = "Export";
ReportViewType reportViewType = ReportHelper.GetReportViewType(request.ReportView);
var headers = new Dictionary <string, string>();
string fileExtension = "csv";
string contentType = "text/plain;charset='utf-8'";
switch (request.ExportType)
{
case ReportExportType.CSV:
break;
case ReportExportType.Excel:
contentType = "application/vnd.ms-excel";
fileExtension = "xls";
break;
}
var filename = "ReportExport." + fileExtension;
headers["Content-Disposition"] = string.Format("attachment; filename=\"{0}\"", filename);
headers["Content-Encoding"] = "UTF-8";
var user = !string.IsNullOrWhiteSpace(request.UserId) ? _userManager.GetUserById(request.UserId) : null;
ReportResult result = null;
switch (reportViewType)
{
case ReportViewType.ReportData:
ReportIncludeItemTypes reportRowType = ReportHelper.GetRowType(request.IncludeItemTypes);
ReportBuilder dataBuilder = new ReportBuilder(_libraryManager);
QueryResult <BaseItem> queryResult = await GetQueryResult(request, user).ConfigureAwait(false);
result = dataBuilder.GetResult(queryResult.Items, request);
result.TotalRecordCount = queryResult.TotalRecordCount;
break;
case ReportViewType.ReportActivities:
result = GetReportActivities(request);
break;
}
string returnResult = string.Empty;
switch (request.ExportType)
{
case ReportExportType.CSV:
returnResult = new ReportExport().ExportToCsv(result);
break;
case ReportExportType.Excel:
returnResult = new ReportExport().ExportToExcel(result);
break;
}
return(ResultFactory.GetResult(returnResult, contentType, headers));
}
public QueryResult <T> FilterQueryResult <T> (ClientTransaction clientTransaction, QueryResult <T> queryResult) where T : DomainObject
{
ArgumentUtility.CheckNotNull("queryResult", queryResult);
return(this
.Cast <IClientTransactionExtension>()
.Aggregate(queryResult, (current, extension) => extension.FilterQueryResult(clientTransaction, current)));
}
/// <summary> /// Executes the query on local store and returns the parsed result /// </summary> /// <param name="store">An instance of <see cref="IMobileServiceLocalStore"/></param> /// <param name="query">An instance of <see cref="MobileServiceTableQueryDescription"/></param> /// <returns>Task that will complete with the parsed result of the query.</returns> public static async Task <QueryResult> QueryAsync(this IMobileServiceLocalStore store, MobileServiceTableQueryDescription query) => QueryResult.Parse(await store.ReadAsync(query), null, validate: true);
public void CreateRequest(V1Connector CurrentV1Connection, List <Message> CurrentEmails)
{
V1XMLHelper V1XML = new V1XMLHelper();
V1Logging Logs = new V1Logging();
string ProjectScope = "Something for Testing";
string EmailBody;
MessagePart MessageParts;
SMTPResponse V1Response = new SMTPResponse();
MailChecker MailCheck = new MailChecker();
IServices services = new Services(CurrentV1Connection);
try
{
foreach (Message MailItem in CurrentEmails)
{
for (int ToCtr = 0; ToCtr < MailItem.Headers.To.Count; ToCtr++)
{
ProjectScope = V1XML.GetProjectScope(MailItem.Headers.To[ToCtr].Address);
if (ProjectScope != null)
{
Oid projectId = services.GetOid(ProjectScope);
IAssetType requestType = services.Meta.GetAssetType("Request");
Asset NewRequest = services.New(requestType, projectId);
IAttributeDefinition nameAttribute = requestType.GetAttributeDefinition("Name");
NewRequest.SetAttributeValue(nameAttribute, MailItem.Headers.Subject.ToString());
MessageParts = MailItem.FindFirstHtmlVersion();
if (MessageParts == null)
{
MessageParts = MailItem.FindFirstPlainTextVersion();
}
EmailBody = MessageParts.GetBodyAsText();
Logs.LogEvent("Operation - Creating Request for " + MailItem.Headers.To[ToCtr].Address);
IAttributeDefinition descriptionAttribute = requestType.GetAttributeDefinition("Description");
NewRequest.SetAttributeValue(descriptionAttribute, EmailBody);
IAttributeDefinition RequestedByAttribute = requestType.GetAttributeDefinition("RequestedBy");
NewRequest.SetAttributeValue(RequestedByAttribute, MailItem.Headers.From.ToString());
services.Save(NewRequest);
IAttributeDefinition RequestIDAttribute = requestType.GetAttributeDefinition("Number");
Query IDQuery = new Query(NewRequest.Oid);
IDQuery.Selection.Add(RequestIDAttribute);
QueryResult ResultID = services.Retrieve(IDQuery);
Asset Request = ResultID.Assets[0];
//NewRequest.GetAttribute(RequestIDAttribute).Value
Logs.LogEvent("Operation - Sending Response to Request Sender.");
//Commented out the Response back to the Sender per John Waedekin
//V1Response.SendResponse(MailItem, Request.GetAttribute(RequestIDAttribute).Value + " " + NewRequest.GetAttribute(nameAttribute).Value, ProjectScope);
MailCheck.DeleteMessagesOnServer(MailItem, ProjectScope);
}
}
}
}
catch (Exception ex)
{
Logs.LogEvent("ERROR - Creating Request - " + ex.InnerException.Message);
}
}
private IObservable <TObservation> LongPoll <TResponse, TObservation>(Func <ulong, Task <QueryResult <TResponse> > > poll, Func <QueryResult <TResponse>, TObservation> toObservation, string monitoringOperation, IDictionary <string, object> monitoringProperties) where TObservation : class
{
return(Observable.Create <TObservation>(async(o, cancel) =>
{
ulong index = default(ulong);
var successfullyContactedConsulAtLeastOnce = false;
while (true)
{
using (var eventContext = new EventContext("ConsulRx.Client", monitoringOperation))
{
eventContext["RequestIndex"] = index;
eventContext.AddValues(monitoringProperties);
QueryResult <TResponse> result = null;
Exception exception = null;
try
{
result = await poll(index).ConfigureAwait(false);
}
catch (Exception ex)
{
eventContext.IncludeException(ex);
exception = ex;
}
if (cancel.IsCancellationRequested)
{
eventContext["Cancelled"] = true;
o.OnCompleted();
return;
}
if (result != null)
{
index = result.LastIndex;
eventContext.IncludeConsulResult(result);
if (HealthyCodes.Contains(result.StatusCode))
{
//200 or 404 are the only response codes we should expect if consul and client are both configured properly
successfullyContactedConsulAtLeastOnce = true;
}
else
{
//if we got an error that indicates either server or client aren't healthy (e.g. 500 or 403)
//then model this as an exception (same as if server can't be contacted). We will figure out what to do below
exception = new ConsulErrorException(result);
eventContext.SetLevel(Level.Error);
}
}
if (exception == null)
{
o.OnNext(toObservation(result));
}
else
{
if (successfullyContactedConsulAtLeastOnce)
{
//if an error occurred, we reset the index so that we can start clean
//this is necessary because if the consul cluster was restarted it won't recognize
//the old index and will block until the longPollMaxWait expires
index = default(ulong);
//if we have been successful at contacting consul already, then we will retry under the assumption that
//things will eventually get healthy again
eventContext["SecondsUntilRetry"] = RetryDelay?.Seconds ?? 0;
if (RetryDelay != null)
{
await Task.Delay(RetryDelay.Value, cancel).ConfigureAwait(false);
}
}
else
{
//if we encountered an error at the very beginning, then we don't have enough confidence that retrying will actually help
//so we will stream the exception out and let the consumer figure out what to do
o.OnError(exception);
return;
}
}
}
}
}));
}
// Token: 0x0600037C RID: 892 RVA: 0x00014BD0 File Offset: 0x00012DD0
private static string GetAttachmentByUrlCompName(MailboxSession mailboxSession, string attachmentId, Stream outStream, int offset, int count, Unlimited <ByteQuantifiedSize> maxAttachmentSize, out int total)
{
attachmentId = "/" + attachmentId;
int andCheckLastSlashLocation = AttachmentHelper.GetAndCheckLastSlashLocation(attachmentId, attachmentId);
string text = attachmentId.Substring(0, andCheckLastSlashLocation);
string text2 = attachmentId.Substring(andCheckLastSlashLocation + 1);
andCheckLastSlashLocation = AttachmentHelper.GetAndCheckLastSlashLocation(text, attachmentId);
string propertyValue = text.Substring(0, andCheckLastSlashLocation);
StoreId storeId = null;
QueryFilter seekFilter = new ComparisonFilter(ComparisonOperator.Equal, FolderSchema.UrlName, propertyValue);
using (Folder folder = Folder.Bind(mailboxSession, mailboxSession.GetDefaultFolderId(DefaultFolderType.Root)))
{
using (QueryResult queryResult = folder.FolderQuery(FolderQueryFlags.DeepTraversal, AirSyncUtility.XsoFilters.GetHierarchyFilter, null, AttachmentHelper.folderPropertyIds))
{
if (queryResult.SeekToCondition(SeekReference.OriginBeginning, seekFilter))
{
object[][] rows = queryResult.GetRows(1);
storeId = (rows[0][0] as StoreId);
}
}
}
if (storeId == null)
{
throw new ObjectNotFoundException(ServerStrings.MapiCannotOpenAttachmentId(attachmentId));
}
AirSyncDiagnostics.TraceDebug <StoreId>(ExTraceGlobals.RequestsTracer, null, "Getting attachment with parentStoreId {0}.", storeId);
StoreId storeId2 = null;
seekFilter = new ComparisonFilter(ComparisonOperator.Equal, FolderSchema.UrlName, text);
using (Folder folder2 = Folder.Bind(mailboxSession, storeId))
{
using (QueryResult queryResult2 = folder2.ItemQuery(ItemQueryType.None, null, null, AttachmentHelper.itemPropertyIds))
{
if (queryResult2.SeekToCondition(SeekReference.OriginBeginning, seekFilter))
{
object[][] rows2 = queryResult2.GetRows(1);
storeId2 = (rows2[0][0] as StoreId);
}
}
}
if (storeId2 == null)
{
throw new ObjectNotFoundException(ServerStrings.MapiCannotOpenAttachmentId(attachmentId));
}
AirSyncDiagnostics.TraceDebug <StoreId>(ExTraceGlobals.RequestsTracer, null, "Getting attachment with itemStoreId {0}.", storeId2);
PropertyTagPropertyDefinition propertyTagPropertyDefinition = PropertyTagPropertyDefinition.CreateCustom("UrlCompName", 284360734U);
string attachmentItself;
using (Item item = Item.Bind(mailboxSession, storeId2))
{
AttachmentCollection attachmentCollection = item.AttachmentCollection;
attachmentCollection.Load(new PropertyDefinition[]
{
propertyTagPropertyDefinition
});
AttachmentId attachmentId2 = null;
foreach (AttachmentHandle handle in attachmentCollection)
{
using (Attachment attachment = attachmentCollection.Open(handle))
{
if (text2.Equals((string)attachment[propertyTagPropertyDefinition], StringComparison.Ordinal))
{
attachmentId2 = attachment.Id;
break;
}
}
}
if (attachmentId2 == null)
{
foreach (AttachmentHandle handle2 in attachmentCollection)
{
using (Attachment attachment2 = attachmentCollection.Open(handle2))
{
string str = (string)attachment2[propertyTagPropertyDefinition];
if (text2.EndsWith("_" + str, StringComparison.Ordinal))
{
attachmentId2 = attachment2.Id;
break;
}
}
}
}
if (attachmentId2 == null)
{
throw new ObjectNotFoundException(ServerStrings.MapiCannotOpenAttachmentId(attachmentId));
}
AirSyncDiagnostics.TraceDebug <AttachmentId>(ExTraceGlobals.RequestsTracer, null, "Getting attachment with attachment ID {0}.", attachmentId2);
using (Attachment attachment3 = attachmentCollection.Open(attachmentId2))
{
if (!maxAttachmentSize.IsUnlimited && attachment3.Size > (long)maxAttachmentSize.Value.ToBytes())
{
throw new DataTooLargeException(StatusCode.AttachmentIsTooLarge);
}
attachmentItself = AttachmentHelper.GetAttachmentItself(attachment3, outStream, offset, count, out total);
}
}
return(attachmentItself);
}
// Token: 0x060007BD RID: 1981 RVA: 0x00037EC4 File Offset: 0x000360C4
private static List <VersionedId> GetOldMeetingMessages(MailboxSession mailboxSession, MeetingMessage item, byte[] globalObjectId, int rumSequenceNumber, out OldMessageDeletion.LatestItemInfo latestItemInfo)
{
SortBy[] array = new SortBy[2];
latestItemInfo.FullUpdateDeleted = false;
latestItemInfo.RollingHighlight = (int)Utils.SafeGetProperty(item, CalendarItemBaseSchema.ChangeHighlight, 0);
latestItemInfo.LatestOldStartTime = ExDateTime.MinValue;
latestItemInfo.LatestOldEndTime = ExDateTime.MinValue;
latestItemInfo.LatestOldLocationStr = string.Empty;
latestItemInfo.LatestSequenceNumber = -1;
latestItemInfo.LatestItemId = item.Id;
latestItemInfo.LatestClientSubmitTime = (ExDateTime)Utils.SafeGetProperty(item, ItemSchema.SentTime, ExDateTime.MinValue);
ExDateTime valueOrDefault = item.GetValueOrDefault <ExDateTime>(CalendarItemBaseSchema.OwnerCriticalChangeTime, ExDateTime.MinValue);
VersionedId id = item.Id;
array[0] = new SortBy(CalendarItemBaseSchema.GlobalObjectId, SortOrder.Ascending);
array[1] = new SortBy(CalendarItemBaseSchema.AppointmentSequenceNumber, SortOrder.Descending);
ComparisonFilter seekFilter = new ComparisonFilter(ComparisonOperator.Equal, CalendarItemBaseSchema.GlobalObjectId, globalObjectId);
List <VersionedId> list = new List <VersionedId>();
using (Folder folder = Folder.Bind(mailboxSession, item.ParentId))
{
using (QueryResult queryResult = folder.ItemQuery(ItemQueryType.None, null, array, OldMessageDeletion.OMDColumnsToQuery))
{
queryResult.SeekToCondition(SeekReference.OriginBeginning, seekFilter);
bool flag = true;
while (flag)
{
IStorePropertyBag[] propertyBags = queryResult.GetPropertyBags(25);
if (propertyBags.Length <= 1)
{
break;
}
foreach (IStorePropertyBag storePropertyBag in propertyBags)
{
string valueOrDefault2 = storePropertyBag.GetValueOrDefault <string>(OldMessageDeletion.OMDColumnsToQuery[0], null);
if (!string.IsNullOrEmpty(valueOrDefault2) && (ObjectClass.IsMeetingRequest(valueOrDefault2) || ObjectClass.IsMeetingCancellation(valueOrDefault2)))
{
byte[] valueOrDefault3 = storePropertyBag.GetValueOrDefault <byte[]>(OldMessageDeletion.OMDColumnsToQuery[2], null);
if (!OldMessageDeletion.GlobalObjectIdMatches(globalObjectId, valueOrDefault3))
{
flag = false;
break;
}
VersionedId valueOrDefault4 = storePropertyBag.GetValueOrDefault <VersionedId>(OldMessageDeletion.OMDColumnsToQuery[1], null);
if (valueOrDefault4 != null && !id.Equals(valueOrDefault4))
{
int valueOrDefault5 = storePropertyBag.GetValueOrDefault <int>(OldMessageDeletion.OMDColumnsToQuery[3], -1);
if (valueOrDefault5 != -1)
{
if (valueOrDefault5 > rumSequenceNumber)
{
latestItemInfo.LatestSequenceNumber = valueOrDefault5;
return(null);
}
if (valueOrDefault5 == rumSequenceNumber)
{
ExDateTime valueOrDefault6 = storePropertyBag.GetValueOrDefault <ExDateTime>(OldMessageDeletion.OMDColumnsToQuery[8], ExDateTime.MinValue);
if (valueOrDefault6 > valueOrDefault)
{
latestItemInfo.LatestSequenceNumber = valueOrDefault5;
return(null);
}
}
if (latestItemInfo.LatestSequenceNumber == -1)
{
ExDateTime valueOrDefault7 = storePropertyBag.GetValueOrDefault <ExDateTime>(OldMessageDeletion.OMDColumnsToQuery[9], ExDateTime.MinValue);
if (valueOrDefault7 != ExDateTime.MinValue)
{
latestItemInfo.LatestOldStartTime = valueOrDefault7;
}
ExDateTime valueOrDefault8 = storePropertyBag.GetValueOrDefault <ExDateTime>(OldMessageDeletion.OMDColumnsToQuery[10], ExDateTime.MinValue);
if (valueOrDefault7 != ExDateTime.MinValue)
{
latestItemInfo.LatestOldEndTime = valueOrDefault8;
}
string valueOrDefault9 = storePropertyBag.GetValueOrDefault <string>(OldMessageDeletion.OMDColumnsToQuery[11], null);
if (!string.IsNullOrEmpty(valueOrDefault9))
{
latestItemInfo.LatestOldLocationStr = valueOrDefault9;
}
}
latestItemInfo.RollingHighlight |= storePropertyBag.GetValueOrDefault <int>(OldMessageDeletion.OMDColumnsToQuery[4], 0);
MeetingMessageType valueOrDefault10 = storePropertyBag.GetValueOrDefault <MeetingMessageType>(OldMessageDeletion.OMDColumnsToQuery[13], MeetingMessageType.None);
latestItemInfo.FullUpdateDeleted |= (valueOrDefault10 == MeetingMessageType.FullUpdate || valueOrDefault10 == MeetingMessageType.NewMeetingRequest);
list.Add(valueOrDefault4);
}
}
}
}
}
}
}
return(list);
}
private void AfterQueryExecuted(QueryResult queryResult)
{
_queryStats.UpdateQueryStats(queryResult);
_highlightings.Update(queryResult);
}
public Paging()
{
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region paging_0_1
IList <Product> results = session
.Query <Product, Products_ByUnitsInStock>()
.Where(x => x.UnitsInStock > 10)
.ToList();
#endregion
}
using (var session = store.OpenSession())
{
#region paging_0_2
IList <Product> results = session
.Advanced
.DocumentQuery <Product, Products_ByUnitsInStock>()
.WhereGreaterThan(x => x.UnitsInStock, 10)
.ToList();
#endregion
}
#region paging_0_3
QueryResult result = store
.DatabaseCommands
.Query(
"Products/ByUnitsInStock",
new IndexQuery
{
Query = "UnitsInStock_Range:{Ix10 TO NULL}"
});
#endregion
}
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region paging_1_1
IList <Product> results = session
.Query <Product, Products_ByUnitsInStock>()
.Where(x => x.UnitsInStock > 10)
.Take(9999) // server will decrease this value to 1024
.ToList();
#endregion
}
using (var session = store.OpenSession())
{
#region paging_1_2
IList <Product> results = session
.Advanced
.DocumentQuery <Product, Products_ByUnitsInStock>()
.WhereGreaterThan(x => x.UnitsInStock, 10)
.Take(9999) // server will decrease this value to 1024
.ToList();
#endregion
}
#region paging_1_3
QueryResult result = store
.DatabaseCommands
.Query(
"Products/ByUnitsInStock",
new IndexQuery
{
Query = "UnitsInStock_Range:{Ix10 TO NULL}",
PageSize = 9999
});
#endregion
}
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region paging_2_1
IList <Product> results = session
.Query <Product, Products_ByUnitsInStock>()
.Where(x => x.UnitsInStock > 10)
.Skip(20) // skip 2 pages worth of products
.Take(10) // take up to 10 products
.ToList(); // execute query
#endregion
}
using (var session = store.OpenSession())
{
#region paging_2_2
IList <Product> results = session
.Advanced
.DocumentQuery <Product, Products_ByUnitsInStock>()
.WhereGreaterThan(x => x.UnitsInStock, 10)
.Skip(20) // skip 2 pages worth of products
.Take(10) // take up to 10 products
.ToList(); // execute query
#endregion
}
#region paging_2_3
QueryResult result = store
.DatabaseCommands
.Query(
"Products/ByUnitsInStock",
new IndexQuery
{
Query = "UnitsInStock_Range:{Ix10 TO NULL}",
Start = 20, // skip 2 pages worth of products
PageSize = 10 // take up to 10 products
});
#endregion
}
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region paging_3_1
RavenQueryStatistics stats;
IList <Product> results = session
.Query <Product, Products_ByUnitsInStock>()
.Statistics(out stats) // fill query statistics
.Where(x => x.UnitsInStock > 10)
.Skip(20)
.Take(10)
.ToList();
int totalResults = stats.TotalResults;
#endregion
}
using (var session = store.OpenSession())
{
#region paging_3_2
RavenQueryStatistics stats;
IList <Product> results = session
.Advanced
.DocumentQuery <Product, Products_ByUnitsInStock>()
.Statistics(out stats) // fill query statistics
.WhereGreaterThan(x => x.UnitsInStock, 10)
.Skip(20)
.Take(10)
.ToList();
int totalResults = stats.TotalResults;
#endregion
}
}
using (var store = new DocumentStore())
{
#region paging_3_3
QueryResult result = store
.DatabaseCommands
.Query(
"Products/ByUnitsInStock",
new IndexQuery
{
Query = "UnitsInStock_Range:{Ix10 TO NULL}",
Start = 20,
PageSize = 10
});
int totalResults = result.TotalResults;
#endregion
}
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region paging_4_1
RavenQueryStatistics stats;
IList <Product> results;
int pageNumber = 0;
int pageSize = 10;
int skippedResults = 0;
do
{
results = session
.Query <Product, Products_ByUnitsInStock>()
.Statistics(out stats)
.Skip((pageNumber * pageSize) + skippedResults)
.Take(pageSize)
.Where(x => x.UnitsInStock > 10)
.Distinct()
.ToList();
skippedResults += stats.SkippedResults;
pageNumber++;
}while (results.Count > 0);
#endregion
}
using (var session = store.OpenSession())
{
#region paging_4_2
RavenQueryStatistics stats;
IList <Product> results;
int pageNumber = 0;
int pageSize = 10;
int skippedResults = 0;
do
{
results = session
.Advanced
.DocumentQuery <Product, Products_ByUnitsInStock>()
.Statistics(out stats)
.Skip((pageNumber * pageSize) + skippedResults)
.Take(pageSize)
.WhereGreaterThan(x => x.UnitsInStock, 10)
.Distinct()
.ToList();
skippedResults += stats.SkippedResults;
pageNumber++;
}while (results.Count > 0);
#endregion
}
}
using (var store = new DocumentStore())
{
#region paging_4_3
QueryResult result;
int pageNumber = 0;
int pageSize = 10;
int skippedResults = 0;
do
{
result = store
.DatabaseCommands
.Query(
"Products/ByUnitsInStock",
new IndexQuery
{
Query = "UnitsInStock_Range:{Ix10 TO NULL}",
Start = (pageNumber * pageSize) + skippedResults,
PageSize = pageSize,
IsDistinct = true
});
skippedResults += result.SkippedResults;
pageNumber++;
}while (result.Results.Count > 0);
#endregion
}
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region paging_6_1
RavenQueryStatistics stats;
IList <Order> results;
int pageNumber = 0;
int pageSize = 10;
int skippedResults = 0;
do
{
results = session
.Query <Order, Orders_ByOrderLines_ProductName>()
.Statistics(out stats)
.Skip((pageNumber * pageSize) + skippedResults)
.Take(pageSize)
.ToList();
skippedResults += stats.SkippedResults;
pageNumber++;
}while (results.Count > 0);
#endregion
}
using (var session = store.OpenSession())
{
#region paging_6_2
RavenQueryStatistics stats;
IList <Order> results;
int pageNumber = 0;
int pageSize = 10;
int skippedResults = 0;
do
{
results = session
.Advanced
.DocumentQuery <Order, Orders_ByOrderLines_ProductName>()
.Statistics(out stats)
.Skip((pageNumber * pageSize) + skippedResults)
.Take(pageSize)
.ToList();
skippedResults += stats.SkippedResults;
pageNumber++;
}while (results.Count > 0);
#endregion
}
}
using (var store = new DocumentStore())
{
#region paging_6_3
QueryResult result;
int pageNumber = 0;
int pageSize = 10;
int skippedResults = 0;
do
{
result = store
.DatabaseCommands
.Query(
"Orders/ByOrderLines/ProductName",
new IndexQuery
{
Start = (pageNumber * pageSize) + skippedResults,
PageSize = pageSize
});
skippedResults += result.SkippedResults;
pageNumber++;
}while (result.Results.Count > 0);
#endregion
}
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region paging_5_1
var pagingInformation = new RavenPagingInformation();
IList <Product> results = session
.Advanced
.LoadStartingWith <Product>(
"products/", // all documents starting with 'products/'
"1*|2*", // rest of the key must begin with "1" or "2" e.g. products/10, products/25
0 * 25, // skip 0 records (page 1)
25, // take up to 25
pagingInformation: pagingInformation); // fill `RavenPagingInformation` with operation data
results = session
.Advanced
.LoadStartingWith <Product>(
"products/", // all documents starting with 'products/'
"1*|2*", // rest of the key must begin with "1" or "2" e.g. products/10, products/25
1 * 25, // skip 25 records (page 2)
25, // take up to 25
pagingInformation: pagingInformation); // since this is a next page to 'page 1' and we are passing 'RavenPagingInformation' that was filled during 'page 1' retrieval, rapid pagination will take place
#endregion
}
}
using (var store = new DocumentStore())
{
using (var session = store.OpenSession())
{
#region paging_7_1
IList <string> results;
int pageNumber = 0;
const int pageSize = 10;
do
{
results = session
.Query <Orders_ByStoredProductName.Result, Orders_ByStoredProductName>()
.Select(x => x.Product)
.Skip((pageNumber * pageSize))
.Take(pageSize)
.Distinct()
.ToList();
pageNumber++;
}while (results.Count > 0);
#endregion
}
using (var session = store.OpenSession())
{
#region paging_7_2
IList <Orders_ByStoredProductName.Result> results;
int pageNumber = 0;
const int pageSize = 10;
do
{
results = session
.Advanced
.DocumentQuery <Order, Orders_ByStoredProductName>()
.SelectFields <Orders_ByStoredProductName.Result>("Product")
.Skip((pageNumber * pageSize))
.Take(pageSize)
.Distinct()
.ToList();
pageNumber++;
}while (results.Count > 0);
#endregion
}
{
#region paging_7_3
QueryResult result;
int pageNumber = 0;
const int pageSize = 10;
do
{
result = store
.DatabaseCommands
.Query(
"Orders/ByStoredProductName",
new IndexQuery
{
Start = (pageNumber * pageSize),
PageSize = pageSize,
IsDistinct = true,
FieldsToFetch = new[]
{
"Product"
}
});
pageNumber++;
} while (result.Results.Count > 0);
#endregion
}
}
}
public bool TryGetNextBatch(QueryResult result, int storageLimit, int defaultBatchSize, bool recurring, bool isFirstFetch, out object[][] nextBatch, out long getRowsTime)
{
getRowsTime = 0L;
if (this.ShouldBatch && !this.keyIndicesAreSet)
{
throw new InvalidOperationException("When batching is required, the critical columns' indices should be set prior to calling this method.");
}
int currentBatchSize = this.GetCurrentBatchSize(storageLimit, defaultBatchSize);
bool flag;
if (currentBatchSize == 0)
{
object[][] rows = result.GetRows(1);
if (rows.Length > 0)
{
if (this.ShouldBatch)
{
this.ResetQueryResumptionPoint(rows[0], recurring);
}
ExTraceGlobals.StorageTracer.TraceDebug <string, int, bool>((long)this.GetHashCode(), "{0}. Batch size is equal to zero; terminating the process... (items in view: {1}; RecurringPhase: {2}).", "CalendarViewBatchingStrategy::TryGetNextBatch", this.addedItemsCount, recurring);
}
else
{
if (this.ShouldBatch)
{
this.PhaseComplete();
}
ExTraceGlobals.StorageTracer.TraceDebug <string, int, bool>((long)this.GetHashCode(), "{0}. Batch size is equal to zero, and there are no more rows to process (items in view: {1}; RecurringPhase: {2}).", "CalendarViewBatchingStrategy::TryGetNextBatch", this.addedItemsCount, recurring);
}
nextBatch = null;
flag = false;
}
else if (this.ShouldBatch && isFirstFetch)
{
flag = this.TryResumeQueryOrStartFromBeginning(result, currentBatchSize, recurring, out nextBatch);
}
else
{
ExTraceGlobals.StorageTracer.TraceDebug((long)this.GetHashCode(), "{0}. Getting a batch with the size of {1} (items in view: {2}; RecurringPhase: {3}).", new object[]
{
"CalendarViewBatchingStrategy::TryGetNextBatch",
currentBatchSize,
this.addedItemsCount,
recurring
});
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
nextBatch = result.GetRows(currentBatchSize, out flag);
}
finally
{
stopwatch.Stop();
getRowsTime = stopwatch.ElapsedMilliseconds;
}
}
if (this.ShouldBatch && currentBatchSize != 0 && !flag)
{
this.PhaseComplete();
}
return(flag);
}
/// <summary>
/// Executes the query on local store and returns the first or default item from parsed result
/// </summary>
/// <param name="store">An instance of <see cref="IMobileServiceLocalStore"/></param>
/// <param name="query">An instance of <see cref="MobileServiceTableQueryDescription"/></param>
/// <returns>Task that will complete with the first or default item from parsed result of the query.</returns>
public static async Task <JObject> FirstOrDefault(this IMobileServiceLocalStore store, MobileServiceTableQueryDescription query)
{
QueryResult result = await store.QueryAsync(query);
return(result.Values.FirstOrDefault() as JObject);
}
private QueryResult <ServerItem> ApplyPaging(QueryResult <ServerItem> result, int?startIndex, int?limit)
{
result.Items = result.Items.Skip(startIndex ?? 0).Take(limit ?? int.MaxValue).ToArray();
return(result);
}
public string e(Querye querye)
{
Dictionary <string, object> metaData = null;
QueryResult qr = null;
Stopwatch stopWatch = null;
bool includeServerMetrics = false;
bool returnColumnNames = false;
string queryName = querye.d;
var inCourseRequest = InCourseRequest.New();
OrdenesApplication ordenesApplication = OrdenesApplication.Instance;
inCourseRequest.SecurityTokenId = ordenesApplication.GetSecurityTokenIdFromHeader();
inCourseRequest.Agencia = ordenesApplication.GetSecurityAgenciaFromHeader();
Query query = null;
try
{
SecurityHelper.ensureAuthenticated(inCourseRequest);
query = JsonConvert.DeserializeObject <Query>(querye.d, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple
});
var type = (QueryType)Enum.Parse(typeof(QueryType), query.Type);
//includeServerMetrics = null != opts && opts.ContainsKey("includeServerMetrics");
//returnColumnNames = null != opts && opts.ContainsKey("returnColumnNames");
includeServerMetrics = null != query.Options && query.Options.Exists(x => x.Key.Equals("includeServerMetrics", StringComparison.OrdinalIgnoreCase));
returnColumnNames = null != query.Options && query.Options.Exists(x => x.Key.Equals("returnColumnNames", StringComparison.OrdinalIgnoreCase));
if (includeServerMetrics)
{
stopWatch = Stopwatch.StartNew();
metaData = new Dictionary <string, object>(1);
}
SecurityHelper.ensureAuthorized(query, inCourseRequest);
queryName = query.Name;
//query.ensureAuthorized(inCourseRequest);
//var queryName = query.getDecriptedQueryName();
//TODO Encender QueryLog.Start para loguear... hay que adaptarlo a Ordenes
QueryLog.Start(query, inCourseRequest);
var requireIdentity = query.Options.Find(x => x.Key.Equals("requireIdentityFilter", StringComparison.OrdinalIgnoreCase));
// Es comun que varias consultas necesiten el usuario que las activa....
if (requireIdentity != null && Convert.ToBoolean(requireIdentity.Value))
{
//query.Filters.Add("IdUsuario", session.Identity_rid);
query.Filters.Add(new Parameter()
{
Key = "IdUsuario", Value = MAEUserSession.Instancia.IdUsuario
});
}
if (query.Options.Exists(x => x.Key == "extendToKnownType"))
{
ExtendQueryFilters(query);
}
if (queryName.Contains("_CUSTOM_"))
{
qr = new QueryResult();
var tName = queryName.Split(new string[] { "_CUSTOM_" }, StringSplitOptions.None)[1] + "CustomQueryById";
object result = reflect(query, tName);
qr.Data = new object[] { result };
qr.Status = "EX0000";
qr.MetaData = metaData;
}
else
{
switch (type)
{
case QueryType.Grid:
var r = new QueryPagingResult();
int totalRows;
string[] columnNames;
object[] r_grid = null;
var draw = 0;
//query.Filters.Remove("maxrecord"); //TODO: porque remueves este parametro?
if (query.Options.Exists(x => x.Key.Equals("gridAdapter", StringComparison.OrdinalIgnoreCase)))
{
var result = (CustomQueryReturn)reflect(query, queryName);
r_grid = result.Data;
totalRows = result.TotalRows;
}
else
{
r_grid = SqlServerHelper.RunGrid("orden_owner." + queryName, query.Filters, out columnNames, out totalRows);
if (returnColumnNames)
{
r.ColumnNames = columnNames;
}
}
var pageSize = query.Filters.Find(i => i.Key == "pageSize");
draw = (pageSize != null) ? Convert.ToInt32(pageSize.Value) : totalRows;
r.Data = r_grid;
r.Status = "EX0000";
r.MetaData = metaData;
r.draw = (int)draw;
r.recordsTotal = totalRows;
r.recordsFiltered = totalRows; //r_grid.Length;
qr = r;
break;
case QueryType.Combos:
qr = new QueryResult();
DatabaseQueryResult r_combos = null;
if (query.Options.Exists(x => x.Key == "filtersAdapter"))
{
r_combos = (DatabaseQueryResult)reflect(query, queryName);
}
else
{
r_combos = SqlServerHelper.RunCombos("orden_owner." + queryName, query.Filters);
}
qr.Data = r_combos.ResultSets.ToArray();
qr.Status = "EX0000";
qr.MetaData = metaData;
break;
case QueryType.Data:
qr = new QueryResult();
qr.Data = new object[1]; // TODO: FIXME: arreglar para tener mas de un data set
qr.Data[0] = SqlServerHelper.RunDictionary("orden_owner." + queryName, query.Filters);
qr.Status = "EX0000";
qr.MetaData = metaData;
break;
case QueryType.FullRecord:
if (query.Options.Exists(x => x.Key.Equals("gridAdapter", StringComparison.OrdinalIgnoreCase)))
{
var rqr = new QueryPagingResult();
var result = (CustomQueryReturn)reflect(query, queryName);
r_grid = result.Data;
totalRows = result.TotalRows;
draw = totalRows;
rqr.Data = r_grid;
rqr.Status = "EX0000";
rqr.MetaData = metaData;
rqr.draw = (int)draw;
rqr.recordsTotal = totalRows;
rqr.recordsFiltered = totalRows; //r_grid.Length;
qr = rqr;
}
else
{
qr = new QueryResult();
var r_fullrecord = SqlServerHelper.RunFullRecord("orden_owner." + queryName, query.Filters);
qr.Data = r_fullrecord.ResultSets.ToArray();
qr.Status = "EX0000";
qr.MetaData = metaData;
}
break;
case QueryType.FullByEntity:
qr = new QueryResult();
//TODO ADAPTAR PARA USAR EF...
//var r_fullrecord = ReadDatabase.Instance.RunFullRecord("orden_owner." + queryName, query.Filters);
//qr.Data = r_fullrecord.ResultSets.ToArray();
qr.Status = "EX0000";
qr.MetaData = metaData;
break;
}
}
//TODO Encender QueryLog.FinishOK para loguear... adapatar a Ordenes
QueryLog.FinishOK(query, qr, inCourseRequest);
}
catch (SessionException sex)
{
qr = new QueryResult();
qr.Data = new object[2] {
inCourseRequest.Id, "Sessión Expirada"
};
qr.Status = "SE6666";
qr.MetaData = metaData;
//TODO: levantar log despues...
QueryLog.FinishWithError(queryName, qr, sex, inCourseRequest);
}
catch (FunctionalException fe)
{
qr = new QueryResult();
qr.Data = new object[2] {
inCourseRequest.Id, fe.Message
};
qr.Status = string.Format("FE{0}", fe.Code.ToString("0000"));
qr.MetaData = metaData;
//TODO: levantar log despues...
QueryLog.FinishWithError(queryName, qr, fe, inCourseRequest);
}
catch (Exception ex)
{
qr = new QueryResult();
qr.Data = new object[2] {
inCourseRequest.Id, ex.Message
};
qr.Status = "TE9999";
qr.MetaData = metaData;
//TODO: levantar log despues...
QueryLog.FinishWithError(queryName, qr, ex, inCourseRequest);
}
finally
{
if (includeServerMetrics)
{
qr.MetaData.Add("serverMetrics", stopWatch.ElapsedMilliseconds);
stopWatch.Reset();
}
}
qr.RequestId = inCourseRequest.Id;
WebOperationContext.Current.OutgoingResponse.ContentType = "application/json; charset=utf-8";
return(JsonConvert.SerializeObject(qr));
}
/// <summary>
/// Gets the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{ItemsResult}.</returns>
protected QueryResult <BaseItemDto> GetResult(GetItemsByName request)
{
var dtoOptions = GetDtoOptions(AuthorizationContext, request);
User user = null;
BaseItem parentItem;
if (!string.IsNullOrWhiteSpace(request.UserId))
{
user = UserManager.GetUserById(request.UserId);
parentItem = string.IsNullOrEmpty(request.ParentId) ? LibraryManager.GetUserRootFolder() : LibraryManager.GetItemById(request.ParentId);
}
else
{
parentItem = string.IsNullOrEmpty(request.ParentId) ? LibraryManager.RootFolder : LibraryManager.GetItemById(request.ParentId);
}
IList <BaseItem> items;
var excludeItemTypes = request.GetExcludeItemTypes();
var includeItemTypes = request.GetIncludeItemTypes();
var mediaTypes = request.GetMediaTypes();
var query = new InternalItemsQuery(user)
{
ExcludeItemTypes = excludeItemTypes,
IncludeItemTypes = includeItemTypes,
MediaTypes = mediaTypes,
DtoOptions = dtoOptions
};
Func <BaseItem, bool> filter = i => FilterItem(request, i, excludeItemTypes, includeItemTypes, mediaTypes);
if (parentItem.IsFolder)
{
var folder = (Folder)parentItem;
if (!string.IsNullOrWhiteSpace(request.UserId))
{
items = request.Recursive ?
folder.GetRecursiveChildren(user, query).ToList() :
folder.GetChildren(user, true).Where(filter).ToList();
}
else
{
items = request.Recursive ?
folder.GetRecursiveChildren(filter) :
folder.Children.Where(filter).ToList();
}
}
else
{
items = new[] { parentItem }.Where(filter).ToList();
}
var extractedItems = GetAllItems(request, items);
var filteredItems = FilterItems(request, extractedItems, user);
filteredItems = LibraryManager.Sort(filteredItems, user, request.GetOrderBy());
var ibnItemsArray = filteredItems.ToList();
IEnumerable <BaseItem> ibnItems = ibnItemsArray;
var result = new QueryResult <BaseItemDto>
{
TotalRecordCount = ibnItemsArray.Count
};
if (request.StartIndex.HasValue || request.Limit.HasValue)
{
if (request.StartIndex.HasValue)
{
ibnItems = ibnItems.Skip(request.StartIndex.Value);
}
if (request.Limit.HasValue)
{
ibnItems = ibnItems.Take(request.Limit.Value);
}
}
var tuples = ibnItems.Select(i => new Tuple <BaseItem, List <BaseItem> >(i, new List <BaseItem>()));
var dtos = tuples.Select(i => DtoService.GetItemByNameDto(i.Item1, dtoOptions, i.Item2, user));
result.Items = dtos.Where(i => i != null).ToArray();
return(result);
}
/// <summary>
/// Parses a <see cref="PlayerInfo"/> object from the given QueryResult.
/// </summary>
/// <param name="result">The result.</param>
/// <returns>A <see cref="PlayerInfo"/> object.</returns>
public PlayerInfo ParseFromQuery(QueryResult result)
{
return(new PlayerInfo(result.Get <int>("UserID"),
new ChatData(result.Get <string>("Prefix"), result.Get <string>("Suffix"), result.Get <string>("Color")),
new PermissionCollection(Regex.Replace(result.Get <string>("Permissions"), @"\s+", "").Split(','))));
}
public ReplyBodyReader(IGenericBsonSerializer <T> serializer, ReplyMessage replyMessage)
{
_serializer = serializer;
_replyMessage = replyMessage;
_result = new QueryResult <T>(_replyMessage.ReplyHeader.CursorId);
}
private void HandleResponse(QueryResult queryResult)
{
_invokeAfterQueryExecuted?.Invoke(queryResult);
Result = _processResults(queryResult, _conventions);
QueryResult = queryResult;
}
public ActionResult <QueryResult <BaseItemDto> > GetYears(
[FromQuery] int?startIndex,
[FromQuery] int?limit,
[FromQuery] string?sortOrder,
[FromQuery] string?parentId,
[FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] ItemFields[] fields,
[FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] string[] excludeItemTypes,
[FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] string[] includeItemTypes,
[FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] string[] mediaTypes,
[FromQuery] string?sortBy,
[FromQuery] bool?enableUserData,
[FromQuery] int?imageTypeLimit,
[FromQuery, ModelBinder(typeof(CommaDelimitedArrayModelBinder))] ImageType[] enableImageTypes,
[FromQuery] Guid?userId,
[FromQuery] bool recursive = true,
[FromQuery] bool?enableImages = true)
{
var dtoOptions = new DtoOptions {
Fields = fields
}
.AddClientFields(Request)
.AddAdditionalDtoOptions(enableImages, enableUserData, imageTypeLimit, enableImageTypes);
User? user = null;
BaseItem parentItem;
if (userId.HasValue && !userId.Equals(Guid.Empty))
{
user = _userManager.GetUserById(userId.Value);
parentItem = string.IsNullOrEmpty(parentId) ? _libraryManager.GetUserRootFolder() : _libraryManager.GetItemById(parentId);
}
else
{
parentItem = string.IsNullOrEmpty(parentId) ? _libraryManager.RootFolder : _libraryManager.GetItemById(parentId);
}
IList <BaseItem> items;
var query = new InternalItemsQuery(user)
{
ExcludeItemTypes = excludeItemTypes,
IncludeItemTypes = includeItemTypes,
MediaTypes = mediaTypes,
DtoOptions = dtoOptions
};
bool Filter(BaseItem i) => FilterItem(i, excludeItemTypes, includeItemTypes, mediaTypes);
if (parentItem.IsFolder)
{
var folder = (Folder)parentItem;
if (!userId.Equals(Guid.Empty))
{
items = recursive ? folder.GetRecursiveChildren(user, query).ToList() : folder.GetChildren(user, true).Where(Filter).ToList();
}
else
{
items = recursive ? folder.GetRecursiveChildren(Filter) : folder.Children.Where(Filter).ToList();
}
}
else
{
items = new[] { parentItem }.Where(Filter).ToList();
}
var extractedItems = GetAllItems(items);
var filteredItems = _libraryManager.Sort(extractedItems, user, RequestHelpers.GetOrderBy(sortBy, sortOrder));
var ibnItemsArray = filteredItems.ToList();
IEnumerable <BaseItem> ibnItems = ibnItemsArray;
var result = new QueryResult <BaseItemDto> {
TotalRecordCount = ibnItemsArray.Count
};
if (startIndex.HasValue || limit.HasValue)
{
if (startIndex.HasValue)
{
ibnItems = ibnItems.Skip(startIndex.Value);
}
if (limit.HasValue)
{
ibnItems = ibnItems.Take(limit.Value);
}
}
var tuples = ibnItems.Select(i => new Tuple <BaseItem, List <BaseItem> >(i, new List <BaseItem>()));
var dtos = tuples.Select(i => _dtoService.GetItemByNameDto(i.Item1, dtoOptions, i.Item2, user));
result.Items = dtos.Where(i => i != null).ToArray();
return(result);
}
private M[]? QuerySpecificMemberTypeIfRequested <M>(MemberTypes memberType, string?optionalName, BindingFlags bindingAttr, Func <MemberInfo, bool>?optionalPredicate, MemberTypes targetMemberType, out QueryResult <M> queryResult) where M : MemberInfo
{
if ((memberType & targetMemberType) == 0)
{
// This type of member was not requested.
queryResult = default;
return(null);
}
queryResult = Query <M>(optionalName, bindingAttr, optionalPredicate);
// .NET Framework compat: If exactly one type of member was requested, the returned array has to be of that specific type (M[], not MemberInfo[]). Create it now and return it
// to cause GetMember() to short-cut the search.
if ((memberType & ~targetMemberType) == 0)
{
return(queryResult.ToArray());
}
// .NET Framework compat: If we got here, than one MemberType was requested. Return null to signal GetMember() to keep querying the other member types and concatenate the results.
return(null);
}
public void SetResult(string displayName, string rawQuery, QueryResult queryResult)
{
DisplayName = displayName;
RawQuery = rawQuery;
QueryResult = queryResult;
}
private void fillTreeView()
{
QueryResult queryresult = PersisterHelper.Get("select * from articulo");
TreeViewHelper.Fill(TreeView, queryresult);
}
public GetAuthorQueryResult(Author document, QueryResult result)
{
Document = document;
Result = result;
}
