public RepositorySetting(string repositoryPath, int numberOfCommits, DateTime historyDateTime, FetchType fetchType)
{
RepositoryPath = repositoryPath;
NumberOfCommits = numberOfCommits;
HistoryDateTime = historyDateTime;
FetchType = fetchType;
}
/// <summary>
/// Returns all Attributes in the FetchType tree
/// </summary>
/// <param name="fe">The fe.</param>
/// <returns></returns>
public static IEnumerable <FetchAttributeInfo> GetAllAttributes(this FetchType fe)
{
var entity = (FetchEntityType)fe.Items[0];
return((from item in entity.Items
select(IEnumerable <FetchAttributeInfo>) GetAllAttributes(entity.name, (dynamic)item)).SelectMany(v => v as FetchAttributeInfo[] ?? v.ToArray()));
}
public static string MapObjToFetchXml(FetchType fetchXml)
{
string viewstring = null;
try
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = true;
using (MemoryStream ms = new MemoryStream())
{
XmlSerializerNamespaces names = new XmlSerializerNamespaces();
names.Add("", "");
XmlWriter stringWriter = null;
using (stringWriter = XmlWriter.Create(ms, settings))
{
XmlSerializer serializer1 = new XmlSerializer(typeof(FetchType));
serializer1.Serialize(stringWriter, fetchXml, names);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
using (StreamReader sr = new StreamReader(ms)){
viewstring = sr.ReadToEnd();
}
}
}
}
catch (Exception e)
{
//------To Handle
}
return(viewstring);
}
/// <summary>
/// FETCH指令返回邮件的相关信息
/// </summary>
/// <param name="mailIndex"></param>
/// <param name="fetchType">处理的参数</param>
/// <returns></returns>
public String FETCHResponse(Int32 mailIndex, FetchType fetchType)
{
streamWriter.WriteLine("A05 FETCH " + mailIndex + " " + fetchType.ToString());
streamWriter.Flush();
response = readToEnd();
return(response);
}
private string FetchTypeToString(FetchType fetchType)
{
if (fetchType == FetchType.HIGHEST_RANKED)
{
return "HIGHEST_RANKED";
}
return "";
}
public QueryPlan Explain(FetchType fetchType = FetchType.FetchMany, Action <IConfigureExplainExpressions> configureExplain = null)
{
var handler = toDiagnosticHandler(fetchType);
var cmd = CommandBuilder.ToCommand(Tenant, handler);
return(Executor.As <MartenQueryExecutor>().Connection.ExplainQuery(cmd, configureExplain));
}
private string FetchTypeToString(FetchType fetchType)
{
if (fetchType == FetchType.HIGHEST_RANKED)
{
return("HIGHEST_RANKED");
}
return("");
}
public static string GetOData4Query(FetchType fetch, string organizationServiceUrl, FetchXmlBuilder sender)
{
if (sender.Service == null)
{
throw new Exception("Must have an active connection to CRM to compose OData query.");
}
var url = organizationServiceUrl;
var entity = fetch.Items.Where(i => i is FetchEntityType).FirstOrDefault() as FetchEntityType;
if (entity == null)
{
throw new Exception("Fetch must contain entity definition");
}
url += "/" + LogicalToCollectionName(entity.name, sender);
var query = "";
if (!string.IsNullOrEmpty(fetch.top))
{
query = AppendQuery(query, "$top", fetch.top);
}
if (entity.Items != null)
{
if (fetch.aggregate)
{
var aggregate = GetAggregate(entity, sender);
var filter = GetFilter(entity, sender, null);
var apply = aggregate;
if (!String.IsNullOrEmpty(filter))
{
apply = $"filter({filter})/{aggregate}";
}
query = AppendQuery(query, "$apply", apply);
}
else
{
var select = GetSelect(entity, sender);
var order = GetOrder(entity, sender);
var expandFilter = "";
var expand = GetExpand(entity, sender, ref expandFilter);
var filter = GetFilter(entity, sender, expandFilter);
query = AppendQuery(query, "$select", select);
query = AppendQuery(query, "$orderby", order);
query = AppendQuery(query, "$expand", expand);
query = AppendQuery(query, "$filter", filter);
}
}
if (!string.IsNullOrEmpty(query))
{
url += "?" + query;
}
return(url);
}
public NpgsqlCommand BuildCommand(FetchType fetchType)
{
var handler = toDiagnosticHandler(fetchType);
var cmd = new NpgsqlCommand();
handler.ConfigureCommand(cmd);
return(cmd);
}
private static void updateViewRelatedObj(FetchType fetchType, string attributeName, List <ViewsRelationsObj> relationObj)
{
int index = attributeName.IndexOf(".");
if (index == -1)
{
if (relationObj.Where(x => x.relationAlias == null).Count() == 0)
{
foreach (object fetch in fetchType.Items)
{
if (fetch is FetchEntityType)
{
foreach (object obj in ((FetchEntityType)fetch).Items)
{
if (obj is FetchAttributeType && attributeName == ((FetchAttributeType)obj).name)
{
FetchEntityType fetchent = (FetchEntityType)fetch;
relationObj.Add(new ViewsRelationsObj()
{
entity = fetchent.name,
entityMetadata = GlobalOperations.Instance.CRMOpHelper.RetriveEntityAtrribute(fetchent.name)
});
}
}
}
}
}
}
else
{
string alias = attributeName.Substring(0, index);
if (relationObj.Where(x => x.relationAlias != null && attributeName.StartsWith(x.relationAlias)).Count() == 0)
{
foreach (object fetch in fetchType.Items)
{
foreach (object obj in ((FetchEntityType)fetch).Items)
{
if (obj is FetchLinkEntityType)
{
FetchLinkEntityType relation = getFechXmlFromLinks((FetchLinkEntityType)obj, attributeName);
if (relation != null)
{
relationObj.Add(new ViewsRelationsObj()
{
entity = relation.name,
entityMetadata = GlobalOperations.Instance.CRMOpHelper.RetriveEntityAtrribute(relation.name),
relationAlias = relation.alias,
relationFrom = relation.from,
relationTo = relation.to
});
}
}
}
}
}
}
}
public static NpgsqlCommand ToCommand <T>(this IQueryable <T> queryable, FetchType fetchType = FetchType.FetchMany)
{
if (queryable is MartenLinqQueryable <T> q1)
{
return(q1.ToPreviewCommand(fetchType));
}
throw new InvalidOperationException($"{nameof(ToCommand)} is only valid on Marten IQueryable objects");
}
public QueryPlan Explain(FetchType fetchType = FetchType.FetchMany)
{
var handler = toDiagnosticHandler(fetchType);
var cmd = new NpgsqlCommand();
handler.ConfigureCommand(cmd);
return(Executor.As <MartenQueryExecutor>().Connection.ExplainQuery(cmd));
}
private void btnAdd_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtRepository.Text) || Directory.Exists(txtRepository.Text))
{
FetchType f = rbCount.Checked ? FetchType.Count : FetchType.DateTime;
RepositorySetting rs = new RepositorySetting(txtRepository.Text, (int)nudCommits.Value,
dateTimePicker1.Value, f);
UserSettingsManager.UserSettings.RepositoriesSetting.AddRepository(rs);
RefreshList();
}
}
public static NpgsqlCommand ToCommand <T>(this IQueryable <T> queryable, FetchType fetchType = FetchType.FetchMany)
{
var q = queryable as MartenQueryable <T>;
if (q == null)
{
throw new InvalidOperationException($"{nameof(ToCommand)} is only valid on Marten IQueryable objects");
}
return(q.BuildCommand(fetchType));
}
public RadioCollection(PIDConstant pidc, int updateFreq, int writeTimes, FetchType fetchType, double diff, double interval = 1)
{
this.Interval = interval;
this.UpdateFrequency = updateFreq;
this.WriteTimes = writeTimes;
this.FetchType = fetchType;
this.Difference = diff;
this.PIDConstants = pidc;
this.StrategyEnable = false;
this.StrategyPeriod = StrategyPeriod.Rest;
}
public QueryPlan Explain(FetchType fetchType = FetchType.FetchMany)
{
var model = MartenQueryParser.Flyweight.GetParsedQuery(Expression);
var handler = toDiagnosticHandler(model, fetchType);
var cmd = new NpgsqlCommand();
handler.ConfigureCommand(cmd);
return(Executor.As <MartenQueryExecutor>().Connection.ExplainQuery(cmd));
}
private MailHeadModel getMailHeader(Int32 index)
{
response = Instruction.FETCHResponse(index, FetchType.UID);
String uid = Regex.Match(response, IMAPHelper.UIDPattern).Groups["uid"].ToString();
response = Instruction.FETCHResponse(index, FetchType.Expression("BODY[HEADER.FIELDS (Date From Subject Content-Type Content-Transfer-Encoding)]"));
String body = Regex.Match(response, IMAPHelper.FetchMailPattern).Groups["body"].ToString();
response = Instruction.STOREReduceFlagResponse(index, StoreFlags.Seen);
return(ReceiveHelper.GetMailHead(uid, body));
}
public static Command CreateText(FetchType fetchType = FetchType.Fetch, string text = null)
{
var p = Command.CreateInstance();
p.CmdType = CommandType.Text;
if (text.IsNotNullOrEmpty())
{
p.Text = text;
}
p.FetchType = fetchType;
return(p);
}
public static Command CreateProcedure(FetchType fetchType = FetchType.Fetch, string text = null)
{
var p = Command.CreateInstance();
p.FetchType = fetchType;
p.CmdType = CommandType.StoredProcedure;
if (text.IsNotNullOrEmpty())
{
p.Text = text;
}
return(p);
}
public NpgsqlCommand BuildCommand(FetchType fetchType)
{
// Need to do each fetch type
var model = new MartenQueryParser().GetParsedQuery(Expression);
var handler = toDiagnosticHandler(model, fetchType);
var cmd = new NpgsqlCommand();
handler.ConfigureCommand(cmd);
return(cmd);
}
public static Command CreateProcedure <T>(FetchType fetchType = FetchType.Fetch, string text = null)
{
var p = Command.CreateInstance();
p.FetchType = fetchType;
p.CmdType = CommandType.StoredProcedure;
if (text.IsNotNullOrEmpty())
{
p.Text = text;
}
p.EntityType = typeof(T).AssemblyQualifiedName;
return(p);
}
public static string GetOData4Query(FetchType fetch, string organizationServiceUrl, FetchXmlBuilder sender)
{
if (sender.Service == null)
{
throw new Exception("Must have an active connection to CRM to compose OData query.");
}
var converted = ConvertOData(fetch, sender);
var url = organizationServiceUrl + converted;
return(url);
}
public static PebbleApp[] GetPage(int offset, WatchHardware hardware, FetchType type, int limit = 100)
{
//Create a GET request here and get the data.
string url = "https://api2.getpebble.com/v2/apps/collection/all/" + type.ToString().Replace('_', '-') + "?platform=all&hardware=" + hardware.ToString() + "&filter_hardware=false&image_ratio=1&limit=" + limit.ToString() + "&offset=" + offset.ToString();
//Request
string raw = DoGetRequest(url);
//Save
SaveAsset(savePath + "raw_pages\\" + type.ToString() + "_" + hardware.ToString() + "_" + offset.ToString() + ".json", Encoding.UTF8.GetBytes(raw));
//Deserialize JSON.
PebbleApp_Page page = (PebbleApp_Page)DeserializeObject(raw, typeof(PebbleApp_Page));
//Extract data and return it
return(page.data);
}
private static string getFecthXmlString(List <ViewFeo> viewFeoList, FetchType fecthObj)
{
foreach (ViewFeo viewFeo in viewFeoList)
{
if (viewFeo.AttributeObj != null)
{
addNewAttributeToFech(fecthObj, viewFeo.AttributeName, viewFeo.AttributeObj);
}
else
{
throw new Exception("Relation Not Found");
}
}
return(FormXmlMapper.MapObjToFetchXml(fecthObj));
}
public static PebbleApp[] GetAppsForHardware(FetchType type, WatchHardware hardware, int max = -1)
{
List <PebbleApp> found = new List <PebbleApp>();
while (true)
{
PebbleApp[] got = GetPage(found.Count, hardware, type);
found.AddRange(got);
//Refresh the UI or something
if ((max != -1 && found.Count > max) || got.Length < 100)
{
break;
}
}
return(found.ToArray());
}
public static void SeekEntireType(FetchType type)
{
int platform = 0;
while (platform < 5)
{
//Ran for each platform
WatchHardware hw = (WatchHardware)platform;
Console.WriteLine("Getting apps for " + type.ToString() + " on hardware " + hw.ToString());
//Get apps and add them
foreach (PebbleApp app in GetAppsForHardware(type, hw))
{
UpdateApp(app, hw);
}
platform++;
}
}
private static List <T> PerformSumColumnAggregation <T>(FetchType fe, List <T> entities, FetchAttributeType aggregate, List <FetchAttributeInfo> attributes) where T : Entity
{
var aggregateEntities = new Dictionary <string, T>();
var distinctValues = new HashSet <string>();
var resultAttributeNames = new HashSet <string>(attributes.Where(a => a.Attribute.aggregateSpecified).Select(a => a.Attribute.alias));
foreach (var entity in entities.Where(e => e.HasAliasedAttribute(aggregate.alias) &&
e.GetAliasedValue <object>(aggregate.alias) != null))
{
var key = new StringBuilder();
foreach (var attribute in attributes.Where(a => a.Attribute != aggregate))
{
key.AppendFormat("{0}.{1},{2}|", attribute.EntityLogicalName, attribute.Attribute.alias,
entity.GetAliasedValue <object>(attribute.Attribute.alias));
}
if (fe.distinctSpecified && fe.distinct)
{
var value = key + "~" + entity.GetAliasedValue <object>(aggregate.alias);
if (distinctValues.Contains(value))
{
continue;
}
distinctValues.Add(value);
}
var aliasValue = entity.GetAliasedValue <Money>(aggregate.alias).GetValueOrDefault();
if (aggregateEntities.TryGetValue(key.ToString(), out T temp))
{
var current = (Money)temp.GetAttributeValue <AliasedValue>(aggregate.alias).Value;
current.Value += aliasValue;
}
else
{
entity[aggregate.alias] = new AliasedValue(null, aggregate.alias, new Money(aliasValue));
foreach (var att in entity.Attributes.Keys.ToList().Where(k => !resultAttributeNames.Contains(k)))
{
entity.Attributes.Remove(att);
}
aggregateEntities.Add(key.ToString(), entity);
}
}
return(aggregateEntities.Values.ToList());
}
public ApplicationCompositionSchema(bool inline, string detailSchema, SchemaMode renderMode, CompositionFieldRenderer renderer,
string printSchema, string dependantfields, FetchType fetchType)
{
_inline = inline;
Renderer = renderer;
_detailSchema = detailSchema;
PrintSchema = printSchema;
RenderMode = renderMode;
FetchType = fetchType;
if (dependantfields != null)
{
var fields = dependantfields.Split(',');
foreach (var field in fields)
{
_dependantFields.Add(field);
}
}
}
internal static string GetSQLQuery(FetchType fetch)
{
aliasmap = new Dictionary <string, string>();
var sql = new StringBuilder();
var entity = fetch.Items.FirstOrDefault(i => i is FetchEntityType) as FetchEntityType;
if (entity == null)
{
throw new Exception("Fetch must contain entity definition");
}
sql.Append("SELECT ");
if (fetch.distinctSpecified && fetch.distinct)
{
sql.Append("DISTINCT ");
}
if (!string.IsNullOrEmpty(fetch.top))
{
sql.Append($"TOP {fetch.top} ");
}
if (entity.Items != null)
{
selectcols = GetSelect(entity);
ordercols = GetOrder(entity.Items.Where(i => i is FetchOrderType).ToList(), string.Empty);
var join = GetJoin(entity.Items.Where(i => i is FetchLinkEntityType).ToList(), entity.name);
var where = GetWhere(entity.name, string.Empty, entity.Items.Where(i => i is filter && ((filter)i).Items != null && ((filter)i).Items.Length > 0).ToList());
sql.AppendLine(string.Join(", ", selectcols));
sql.AppendLine($"FROM {entity.name}");
if (join != null && join.Count > 0)
{
sql.AppendLine(string.Join("\n", join));
}
if (!string.IsNullOrEmpty(where))
{
sql.AppendLine($"WHERE {where}");
}
if (ordercols != null && ordercols.Count > 0)
{
sql.Append("ORDER BY ");
sql.AppendLine(string.Join(", ", ordercols));
}
}
return(sql.ToString());
}
public static string ConvertQueryExpressionToFetchXml(QueryExpression qe)
{
var items = new List <object>();
// Add Column Set
items.AddRange(qe.ColumnSet.Columns.Select(c => new FetchAttributeType {
name = c
}));
// Add Filters
items.Add(CreateFilter(qe.Criteria));
// Add Links
items.AddRange(qe.LinkEntities.Select(CreateLink));
// FetchOrderType order
items.AddRange(qe.Orders.Select(c => new FetchOrderType {
attribute = c.AttributeName, descending = (c.OrderType == OrderType.Descending)
}));
var fetch = new FetchType
{
Items = new Object [] {
new FetchEntityType {
name = qe.EntityName,
Items = items.ToArray()
}
},
count = qe.TopCount.HasValue ? qe.TopCount.ToString() : null,
};
var xmlserializer = new XmlSerializer(typeof(FetchType));
using (var stringWriter = new StringWriter())
{
using (var writer = XmlWriter.Create(stringWriter, new XmlWriterSettings {
Indent = true
}))
{
xmlserializer.Serialize(writer, fetch);
return(stringWriter.ToString());
}
}
}
private IQueryHandler toDiagnosticHandler(FetchType fetchType)
{
switch (fetchType)
{
case FetchType.Count:
return(ToLinqQuery().ToCount <int>());
case FetchType.Any:
return(ToLinqQuery().ToAny());
case FetchType.FetchMany:
return(ToLinqQuery().ToList());
case FetchType.FetchOne:
return(OneResultHandler <T> .First(ToLinqQuery()));
}
throw new ArgumentOutOfRangeException(nameof(fetchType));
}
protected object BaseFetchCommand(FetchType fetchSelector)
{
if (!Client.IsAvailable())
return null;
try
{
Client?.GetConnectionHandler()?.SetFetching();
return CommandTypeSelector(fetchSelector);
}
catch
{
Client?.GetConnectionHandler()?.SetOpened();
return null;
}
finally
{
Client?.GetConnectionHandler()?.SetOpened();
}
}
public static string GetODataQuery(FetchType fetch, string organizationServiceUrl, FetchXmlBuilder sender)
{
if (sender.Service == null)
{
throw new Exception("Must have an active connection to CRM to compose OData query.");
}
var url = organizationServiceUrl;
var entity = fetch.Items.Where(i => i is FetchEntityType).FirstOrDefault() as FetchEntityType;
if (entity == null)
{
throw new Exception("Fetch must contain entity definition");
}
url += "/" + LogicalToSchemaName(entity.name, sender) + "Set";
var query = "";
if (!string.IsNullOrEmpty(fetch.top))
{
query = AppendQuery(query, "$top", fetch.top);
}
if (entity.Items != null)
{
var select = GetSelect(entity, sender);
var order = GetOrder(entity, sender);
var expand = GetExpand(entity, sender, ref select);
var filter = GetFilter(entity, sender);
query = AppendQuery(query, "$select", select);
query = AppendQuery(query, "$orderby", order);
query = AppendQuery(query, "$expand", expand);
query = AppendQuery(query, "$filter", filter);
}
if (!string.IsNullOrEmpty(query))
{
url += "?" + query;
}
return url;
}
internal void SetFetchType(FetchType value)
{
_fetchType = value;
}
public override void ExplicitVisit(FetchType fragment)
{
_fragments.Add(fragment);
}
public void FetchData(IAsyncResult result, FetchType what)
{
int readlen = 0;
try
{
readlen = m_stream.EndRead(result);
if (readlen == 0)
{
m_error = Error.ConnectionClosed;
m_processError( m_error);
}
else
{
pushReceivedBuffer( result.AsyncState as byte[]);
byte[] msg = null;
switch (what)
{
case FetchType.Line:
msg = fetchLineFromBuffer();
break;
case FetchType.Content:
msg = fetchContentFromBuffer();
break;
}
if (msg != null)
{
m_processMessage(msg);
}
else
{
byte[] netbuffer = new byte[ m_client.ReceiveBufferSize];
m_stream.BeginRead( netbuffer, 0, netbuffer.Length, ReadLineCallback, netbuffer);
}
}
}
catch
{
m_error = Error.ReadFailed;
}
}
public void GetGlobalLeaderboard(
string in_leaderboardId,
FetchType in_fetchType,
int in_maxResults ,
SuccessCallback in_success = null,
FailureCallback in_failure = null,
object in_cbObject = null)
{
Dictionary<string, object> data = new Dictionary<string, object>();
data[OperationParam.SocialLeaderboardServiceLeaderboardId.Value] = in_leaderboardId;
data[OperationParam.SocialLeaderboardServiceFetchType.Value] = FetchTypeToString(in_fetchType);
data[OperationParam.SocialLeaderboardServiceMaxResults.Value] = in_maxResults;
ServerCallback callback = BrainCloudClient.CreateServerCallback(in_success, in_failure, in_cbObject);
ServerCall sc = new ServerCall(ServiceName.SocialLeaderboard, ServiceOperation.GetGlobalLeaderboard, data, callback);
m_brainCloudClientRef.SendRequest(sc);
}
public override void Visit(FetchType node) { this.action(node); }
private object CommandTypeSelector(FetchType fetchSelector)
{
try
{
switch (fetchSelector)
{
case FetchType.Integer:
case FetchType.String:
return Command?.ExecuteScalar();
case FetchType.Row:
DataSet dataSet = new DataSet();
using (MySqlDataAdapter dataAdapter = new MySqlDataAdapter(Command))
dataAdapter.Fill(dataSet);
return dataSet;
case FetchType.Table:
DataTable dataTable = new DataTable();
using (MySqlDataAdapter adapter = new MySqlDataAdapter(Command))
adapter.Fill(dataTable);
return dataTable;
default:
return null;
}
}
catch
{
Client?.GetConnectionHandler()?.SetOpened();
return null;
}
}
