//IEnumerable<T> WhereActiveOrderBy(
//REFACTOR: we're building things up in memory, and inefficiently as well...
//MESS: NAIVE: these are nasty messes of code as well.
public ActionResult Contracts()
{
//get a list with the newest employees/offices for each employee/office code.
var newestOffices = db.newestOffices();
var newestEmployees = db.newestEmployees();
return authenticatedAction(new String[] { "UT", "UR" }, () => {
content:
var result = makeJSONResult();
using (JsonTextWriter w = new JsonTextWriter()) {
w.WriteStartArray();
foreach (Contract c in db.Contracts.WAOBTL()) {
w.writeSharedJSONMembers(c);
w.writeSharedJSONProlog();
foreach (Company co in db.Companies.Where(tco => tco.contractCode == c.code).WAOBTL()) {
w.writeSharedJSONMembers(co);
w.WriteMember("offices");
w.WriteStartArray();
foreach (Office o in newestOffices
.Where(o => o.companyCode == co.code)
.Where(o => o.contractCode == c.code)
.WAOBTL()
) {
w.WriteStartObject();
//LOOK AT THIS! WE'RE NOT JUST SENDING OVER THE CODE, BUT THE VERSION AS WELL!
w.WriteMember("code");
w.WriteString(o.code + "?" + o.version.ToString());
w.WriteMember("description");
w.WriteString(o.description);
w.WriteEndObject();
}
w.WriteEndArray();
w.WriteMember("employees");
w.WriteStartArray();
foreach (Employee e in newestEmployees
.Where(e => e.companyCode == co.code)
.Where(e => e.contractCode == c.code)
.WAOBTL()) {
w.WriteStartObject();
//LOOK AT THIS! WE'RE NOT JUST SENDING OVER THE CODE, BUT THE VERSION AS WELL!
w.WriteMember("code");
w.WriteString(e.code + "?" + e.version.ToString());
w.WriteMember("description");
w.WriteString(e.firstName + " " + e.lastName);
w.WriteEndObject();
}
w.WriteEndArray();
w.WriteEndObject();
}
w.writeSharedJSONEpilog();
}
w.WriteEndArray();
result.Content = w.ToString();
}
logger.Debug("TreesController.Contracts accessed.");
return result;
});
}
public void Example()
{
#region Usage
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter writer = new JsonTextWriter(sw))
{
writer.Formatting = Formatting.Indented;
writer.WriteStartObject();
writer.WritePropertyName("CPU");
writer.WriteValue("Intel");
writer.WritePropertyName("PSU");
writer.WriteValue("500W");
writer.WritePropertyName("Drives");
writer.WriteStartArray();
writer.WriteValue("DVD read/writer");
writer.WriteComment("(broken)");
writer.WriteValue("500 gigabyte hard drive");
writer.WriteValue("200 gigabype hard drive");
writer.WriteEnd();
writer.WriteEndObject();
}
Console.WriteLine(sb.ToString());
// {
// "CPU": "Intel",
// "PSU": "500W",
// "Drives": [
// "DVD read/writer"
// /*(broken)*/,
// "500 gigabyte hard drive",
// "200 gigabype hard drive"
// ]
// }
#endregion
Assert.AreEqual(@"{
""CPU"": ""Intel"",
""PSU"": ""500W"",
""Drives"": [
""DVD read/writer""
/*(broken)*/,
""500 gigabyte hard drive"",
""200 gigabype hard drive""
]
}", sb.ToString());
}
public override void EndRequest()
{
base.EndRequest();
Context.Response.ContentType = "application/json";
using (var streamWriter = new StreamWriter(Context.Response.OutputStream))
using (var writer = new JsonTextWriter(streamWriter))
{
writer.WriteStartObject();
writer.WritePropertyName("c");
writer.WriteValue(_channelId);
writer.WriteEndObject();
}
}
public void Dispose()
{
_writer?.WriteEndObject();
_writer?.Flush();
_streamWriter?.Flush();
_streamWriter?.Dispose();
_gZipStream?.Dispose();
if (_leaveOpen == false)
{
_stream?.Flush();
_stream?.Dispose();
}
}
public void ReadingAndWritingJsonText()
{
#region ReadingAndWritingJsonText
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter writer = new JsonTextWriter(sw))
{
writer.Formatting = Formatting.Indented;
writer.WriteStartObject();
writer.WritePropertyName("CPU");
writer.WriteValue("Intel");
writer.WritePropertyName("PSU");
writer.WriteValue("500W");
writer.WritePropertyName("Drives");
writer.WriteStartArray();
writer.WriteValue("DVD read/writer");
writer.WriteComment("(broken)");
writer.WriteValue("500 gigabyte hard drive");
writer.WriteValue("200 gigabype hard drive");
writer.WriteEnd();
writer.WriteEndObject();
}
// {
// "CPU": "Intel",
// "PSU": "500W",
// "Drives": [
// "DVD read/writer"
// /*(broken)*/,
// "500 gigabyte hard drive",
// "200 gigabype hard drive"
// ]
// }
#endregion
}
void WriteAccount(JsonTextWriter writer, TwitterAccount account)
{
writer.WriteStartObject ();
if (account.Credential is NetworkCredential) {
NetworkCredential nc = account.Credential as NetworkCredential;
writer.WriteKey ("username");
writer.WriteString (nc.UserName);
writer.WriteKey ("password");
writer.WriteString (nc.Password);
} else if (account.Credential is OAuthPasswordCache) {
OAuthPasswordCache pc = account.Credential as OAuthPasswordCache;
writer.WriteKey ("username");
writer.WriteString (pc.UserName);
writer.WriteKey ("password");
writer.WriteString (pc.Password);
writer.WriteKey ("token");
writer.WriteString (pc.AccessToken);
writer.WriteKey ("secret");
writer.WriteString (pc.AccessSecret);
}
if (account.SelfUserID > 0) {
writer.WriteKey ("id");
writer.WriteNumber (account.SelfUserID);
}
writer.WriteKey ("rest");
writer.WriteStartObject ();
string[] rest_keys = new string[] {"home", "mentions", "dm"};
TwitterAccount.RestUsage[] rests = new TwitterAccount.RestUsage[] {account.RestHome, account.RestMentions, account.RestDirectMessages};
for (int i = 0; i < rest_keys.Length; i ++) {
writer.WriteKey (rest_keys[i]);
writer.WriteStartObject ();
writer.WriteKey ("enable");
writer.WriteBoolean (rests[i].IsEnabled);
writer.WriteKey ("count");
writer.WriteNumber (rests[i].Count);
writer.WriteKey ("interval");
writer.WriteNumber ((int)rests[i].Interval.TotalSeconds);
writer.WriteEndObject ();
}
writer.WriteEndObject ();
writer.WriteKey ("streaming");
if (account.StreamingClient == null) {
writer.WriteNull ();
} else {
writer.WriteStartObject ();
writer.WriteKey ("mode");
if (account.StreamingClient.Target is TwitterAccount) {
writer.WriteString ("follow");
writer.WriteKey ("username");
writer.WriteString ((account.StreamingClient.Target as TwitterAccount).ScreenName);
} else if (account.StreamingClient.Target is SearchStatuses) {
writer.WriteString ("track");
writer.WriteKey ("keywords");
writer.WriteString (account.StreamingClient.SearchKeywords);
} else if (account.StreamingClient.Target is ListStatuses) {
writer.WriteString ("list");
writer.WriteKey ("id");
writer.WriteNumber ((account.StreamingClient.Target as ListStatuses).List.ID);
}
writer.WriteEndObject ();
}
writer.WriteEndObject ();
}
void SaveConfigInternalStyles(JsonTextWriter writer)
{
writer.WriteStartObject ();
writer.WriteKey ("colors");
writer.WriteStartObject ();
SaveConfigInternalColors (writer);
writer.WriteEndObject ();
writer.WriteKey ("fonts");
writer.WriteStartObject ();
SaveConfigInternalFonts (writer);
writer.WriteEndObject ();
writer.WriteKey ("icon_size");
writer.WriteNumber (IconSize);
writer.WriteEndObject ();
}
protected override void ProcessRequest()
{
string httpMethod = Request.RequestType;
if (!CaselessString.Equals(httpMethod, "GET") &&
!CaselessString.Equals(httpMethod, "HEAD"))
{
throw new JsonRpcException(string.Format("HTTP {0} is not supported for RPC execution. Use HTTP GET or HEAD only.", httpMethod));
}
//
// Response will be plain text, though it would have been nice to
// be more specific, like text/json.
//
Response.ContentType = "text/plain";
//
// Convert the query string into a call object.
//
JsonWriter writer = new JsonTextWriter();
writer.WriteStartObject();
writer.WriteMember("id");
writer.WriteNumber(0);
writer.WriteMember("method");
string methodName = Mask.NullString(Request.PathInfo);
if (methodName.Length == 0)
writer.WriteNull();
else
writer.WriteString(methodName.Substring(1));
writer.WriteMember("params");
writer.WriteStartObject();
NameValueCollection query = Request.QueryString;
if (query.HasKeys())
{
foreach (string name in query)
{
if (Mask.NullString(name).Length == 0)
continue;
writer.WriteMember(name);
string[] values = query.GetValues(name);
if (values.Length == 0)
writer.WriteNull();
else if (values.Length == 1)
writer.WriteString(values[0]);
else
writer.WriteArray(values);
}
}
writer.WriteEndObject();
writer.WriteEndObject();
//
// Delegate rest of the work to JsonRpcDispatcher.
//
JsonRpcDispatcher dispatcher = new JsonRpcDispatcher(Service);
if (HttpRequestSecurity.IsLocal(Request))
dispatcher.SetLocalExecution();
dispatcher.Process(new StringReader(writer.ToString()), Response.Output);
}
public override void Post(HttpRequest Request, HttpResponse Response, params string[] PathParams)
{
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.Cache.SetMaxAge(TimeSpan.Zero);
JObject inputData = null;
try
{
using (StreamReader reader = new StreamReader(Request.InputStream))
{
using (JsonTextReader jsonReader = new JsonTextReader(reader))
{
inputData = JObject.Load(jsonReader);
}
}
}
catch
{
RespondBadRequest(Response);
}
Int64 AppUserId;
if (IsAuthorizedRequest(Request, Response, true, out AppUserId))
{
Response.ContentType = @"application/json";
JToken jt;
string animal_type = null, animal_name = null, animal_age = null;
if (inputData.TryGetValue(@"animal_type", out jt))
{
animal_type = jt.Value <string>();
}
if (inputData.TryGetValue(@"animal_name", out jt))
{
animal_name = jt.Value <string>();
}
if (inputData.TryGetValue(@"animal_age", out jt))
{
animal_age = jt.Value <string>();
}
using (StreamWriter streamWriter = new StreamWriter(Response.OutputStream))
{
using (JsonTextWriter jsonWriter = new JsonTextWriter(streamWriter))
{
AppUserAnimal appUserAnimal = AppUserAnimal.FetchByID(AppUserId);
if (appUserAnimal == null)
{
appUserAnimal = new AppUserAnimal();
}
if (animal_type != null)
{
appUserAnimal.AnimalType = animal_type;
}
if (animal_name != null)
{
appUserAnimal.AnimalName = animal_name;
}
if (animal_age != null)
{
appUserAnimal.AnimagAge = animal_age;
}
appUserAnimal.AppUserId = AppUserId;
appUserAnimal.Save();
jsonWriter.WriteStartObject();
jsonWriter.WriteEndObject();
}
}
}
}
void SaveConfigInternal(JsonTextWriter writer, TimelineBase timelines)
{
foreach (object item in timelines.TimeLines) {
writer.WriteStartObject ();
writer.WriteKey ("type");
TimelineInfo tl = item as TimelineInfo;
TabInfo tb = item as TabInfo;
if (tl != null) {
if (tl.Search != null) {
writer.WriteString ("search");
writer.WriteKey ("keywords");
writer.WriteString (tl.Search.Keyword);
} else if (tl.List != null) {
writer.WriteString ("list");
writer.WriteKey ("id");
writer.WriteNumber (tl.List.List.ID);
} else {
writer.WriteString ("account");
writer.WriteKey ("subtype");
if (tl.Statuses == tl.RestAccount.HomeTimeline)
writer.WriteString ("home");
else if (tl.Statuses == tl.RestAccount.Mentions)
writer.WriteString ("mentions");
else if (tl.Statuses == tl.RestAccount.DirectMessages)
writer.WriteString ("directmessages");
writer.WriteKey ("name");
writer.WriteString (tl.RestAccount.ScreenName);
}
} else if (tb != null) {
writer.WriteString ("tab");
writer.WriteKey ("title");
writer.WriteString (tb.Title);
writer.WriteKey ("windows");
writer.WriteStartArray ();
SaveConfigInternal (writer, tb);
writer.WriteEndArray ();
} else {
writer.WriteNull ();
}
writer.WriteEndObject ();
}
}
private static string ProcessInternal(string sessionId, string jsonRpc, object jsonRpcContext)
{
var handler = Handler.GetSessionHandler(sessionId);
JsonRequest[] batch = null;
try
{
if (isSingleRpc(jsonRpc))
{
var foo = JsonConvert.DeserializeObject <JsonRequest>(jsonRpc);
batch = new[] { foo };
}
else
{
batch = JsonConvert.DeserializeObject <JsonRequest[]>(jsonRpc);
}
}
catch (Exception ex)
{
return(Newtonsoft.Json.JsonConvert.SerializeObject(new JsonResponse
{
Error = handler.ProcessParseException(jsonRpc, new JsonRpcException(-32700, "Parse error", ex))
}));
}
if (batch.Length == 0)
{
return(Newtonsoft.Json.JsonConvert.SerializeObject(new JsonResponse
{
Error = handler.ProcessParseException(jsonRpc,
new JsonRpcException(3200, "Invalid Request", "Batch of calls was empty."))
}));
}
var singleBatch = batch.Length == 1;
StringBuilder sbResult = null;
for (var i = 0; i < batch.Length; i++)
{
var jsonRequest = batch[i];
var jsonResponse = new JsonResponse();
if (jsonRequest == null)
{
jsonResponse.Error = handler.ProcessParseException(jsonRpc,
new JsonRpcException(-32700, "Parse error",
"Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."));
}
else if (jsonRequest.Method == null)
{
jsonResponse.Error = handler.ProcessParseException(jsonRpc,
new JsonRpcException(-32600, "Invalid Request", "Missing property 'method'"));
}
else if (!isSimpleValueType(jsonRequest.Id))
{
jsonResponse.Error = handler.ProcessParseException(jsonRpc,
new JsonRpcException(-32600, "Invalid Request", "Id property must be either null or string or integer."));
}
else
{
jsonResponse.Id = jsonRequest.Id;
var data = handler.Handle(jsonRequest, jsonRpcContext);
if (data == null)
{
continue;
}
jsonResponse.JsonRpc = data.JsonRpc;
jsonResponse.Error = data.Error;
jsonResponse.Result = data.Result;
}
if (jsonResponse.Result == null && jsonResponse.Error == null)
{
// Per json rpc 2.0 spec
// result : This member is REQUIRED on success.
// This member MUST NOT exist if there was an error invoking the method.
// Either the result member or error member MUST be included, but both members MUST NOT be included.
jsonResponse.Result = new Newtonsoft.Json.Linq.JValue((Object)null);
}
// special case optimization for single Item batch
if (singleBatch && (jsonResponse.Id != null || jsonResponse.Error != null))
{
StringWriter sw = new StringWriter();
JsonTextWriter writer = new JsonTextWriter(sw);
writer.WriteStartObject();
if (!string.IsNullOrEmpty(jsonResponse.JsonRpc))
{
writer.WritePropertyName("jsonrpc"); writer.WriteValue(jsonResponse.JsonRpc);
}
if (jsonResponse.Error != null)
{
writer.WritePropertyName("error"); writer.WriteRawValue(JsonConvert.SerializeObject(jsonResponse.Error));
}
else
{
writer.WritePropertyName("result"); writer.WriteRawValue(JsonConvert.SerializeObject(jsonResponse.Result));
}
writer.WritePropertyName("id"); writer.WriteValue(jsonResponse.Id);
writer.WriteEndObject();
return(sw.ToString());
//return JsonConvert.SerializeObject(jsonResponse);
}
else if (jsonResponse.Id == null && jsonResponse.Error == null)
{
// do nothing
sbResult = new StringBuilder(0);
}
else
{
// write out the response
if (i == 0)
{
sbResult = new StringBuilder("[");
}
sbResult.Append(JsonConvert.SerializeObject(jsonResponse));
if (i < batch.Length - 1)
{
sbResult.Append(',');
}
else if (i == batch.Length - 1)
{
sbResult.Append(']');
}
}
}
return(sbResult.ToString());
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
var streamWriter = new StreamWriter(stream);
var writer = new JsonTextWriter(streamWriter);
writer.WriteStartArray();
foreach (var result in results)
{
if (result == null)
{
writer.WriteNull();
continue;
}
writer.WriteStartObject();
writer.WritePropertyName("Status");
writer.WriteValue((int)result.StatusCode);
writer.WritePropertyName("Headers");
writer.WriteStartObject();
foreach (var header in result.Headers.Concat(result.Content.Headers))
{
foreach (var val in header.Value)
{
writer.WritePropertyName(header.Key);
writer.WriteValue(val);
}
}
writer.WriteEndObject();
writer.WritePropertyName("Result");
var jsonContent = result.Content as JsonContent;
if (jsonContent != null && jsonContent.Data != null)
{
jsonContent.Data.WriteTo(writer, Default.Converters);
}
else
{
var stringContent = result.Content as MultiGetSafeStringContent;
if (stringContent != null)
{
writer.WriteStartObject();
writer.WritePropertyName("Error");
writer.WriteValue(stringContent.Content);
writer.WriteEndObject();
}
else
{
writer.WriteStartObject();
writer.WritePropertyName("Error");
writer.WriteValue("Content not valid for multi_get " + result.Content);
writer.WriteEndObject();
}
}
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.Flush();
return(new CompletedTask());
}
public static string SerializeObjects(IEnumerable <TabularObject> objects
, bool includeTranslations = true
, bool includePerspectives = true
, bool includeRLS = true
, bool includeOLS = true
, bool includeInstanceID = false
)
{
var model = objects.FirstOrDefault()?.Model;
if (model == null)
{
return("[]");
}
if (includeTranslations)
{
foreach (var obj in objects.OfType <IInternalTranslatableObject>())
{
obj.SaveTranslations(true);
}
}
if (includePerspectives)
{
foreach (var obj in objects.OfType <IInternalTabularPerspectiveObject>())
{
obj.SavePerspectives(true);
}
}
if (includeRLS)
{
foreach (var obj in objects.OfType <Table>())
{
obj.SaveRLS();
}
}
if (includeOLS && model.Handler.CompatibilityLevel >= 1400)
{
foreach (var obj in objects.OfType <Table>())
{
obj.SaveOLS(true);
}
foreach (var obj in objects.OfType <Column>())
{
obj.SaveOLS();
}
}
var byType = objects.GroupBy(obj => obj.GetType(), obj => TOM.JsonSerializer.SerializeObject(obj.MetadataObject));
using (var sw = new StringWriter())
{
using (var jw = new JsonTextWriter(sw))
{
jw.Formatting = Formatting.Indented;
jw.WriteStartObject();
if (includeInstanceID)
{
jw.WritePropertyName("InstanceID");
jw.WriteValue(model.Handler.InstanceID);
}
foreach (var type in byType)
{
jw.WritePropertyName(TypeToJson(type.Key));
jw.WriteStartArray();
foreach (var obj in type)
{
jw.WriteRawValue(obj);
}
jw.WriteEndArray();
}
jw.WriteEndObject();
}
foreach (var obj in objects.OfType <IInternalAnnotationObject>())
{
obj.ClearTabularEditorAnnotations();
}
return(sw.ToString());
}
}
protected override void WriteTransaction(JsonTextWriter writer, Transaction tx)
{
WritePropertyValue(writer, "txid", tx.GetHash().ToString());
WritePropertyValue(writer, "version", tx.Version);
WritePropertyValue(writer, "locktime", tx.LockTime.Value);
writer.WritePropertyName("vin");
writer.WriteStartArray();
foreach (var txin in tx.Inputs)
{
writer.WriteStartObject();
if (txin.PrevOut.Hash == uint256.Zero)
{
WritePropertyValue(writer, "coinbase", Encoders.Hex.EncodeData(txin.ScriptSig.ToBytes()));
}
else
{
WritePropertyValue(writer, "txid", txin.PrevOut.Hash.ToString());
WritePropertyValue(writer, "vout", txin.PrevOut.N);
writer.WritePropertyName("scriptSig");
writer.WriteStartObject();
WritePropertyValue(writer, "asm", txin.ScriptSig.ToString());
WritePropertyValue(writer, "hex", Encoders.Hex.EncodeData(txin.ScriptSig.ToBytes()));
writer.WriteEndObject();
}
WritePropertyValue(writer, "sequence", (uint)txin.Sequence);
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.WritePropertyName("vout");
writer.WriteStartArray();
int i = 0;
foreach (var txout in tx.Outputs)
{
writer.WriteStartObject();
writer.WritePropertyName("value");
writer.WriteRawValue(ValueFromAmount(txout.Value));
WritePropertyValue(writer, "n", i);
writer.WritePropertyName("scriptPubKey");
writer.WriteStartObject();
WritePropertyValue(writer, "asm", txout.ScriptPubKey.ToString());
WritePropertyValue(writer, "hex", Encoders.Hex.EncodeData(txout.ScriptPubKey.ToBytes()));
var destinations = new List <TxDestination>()
{
txout.ScriptPubKey.GetDestination(this.network)
};
if (destinations[0] == null)
{
destinations = txout.ScriptPubKey.GetDestinationPublicKeys(this.network)
.Select(p => p.Hash)
.ToList <TxDestination>();
}
if (destinations.Count == 1)
{
WritePropertyValue(writer, "reqSigs", 1);
WritePropertyValue(writer, "type", GetScriptType(txout.ScriptPubKey.FindTemplate(this.network)));
writer.WritePropertyName("addresses");
writer.WriteStartArray();
writer.WriteValue(destinations[0].GetAddress(Network).ToString());
writer.WriteEndArray();
}
else
{
var multi = PayToMultiSigTemplate.Instance.ExtractScriptPubKeyParameters(this.network, txout.ScriptPubKey);
if (multi != null)
{
WritePropertyValue(writer, "reqSigs", multi.SignatureCount);
}
WritePropertyValue(writer, "type", GetScriptType(txout.ScriptPubKey.FindTemplate(this.network)));
if (multi != null)
{
writer.WritePropertyName("addresses");
writer.WriteStartArray();
foreach (PubKey key in multi.PubKeys)
{
writer.WriteValue(key.Hash.GetAddress(this.Network).ToString());
}
writer.WriteEndArray();
}
}
writer.WriteEndObject(); //endscript
writer.WriteEndObject(); //in out
i++;
}
writer.WriteEndArray();
}
public Task SubscribeAsync(IEnumerable <string> channelIds)
{
var ws = _WebSocket;
var ct = _WebSocketCancellationTokenSource?.Token;
if (ws == null)
{
return(new InvalidOperationException().ToTask <object>());
}
ArraySegment <byte> b;
using (var ms = new MemoryStream())
using (var sw = new StreamWriter(ms, new UTF8Encoding(false), 128, true))
using (var jtw = new JsonTextWriter(sw))
{
jtw.WriteStartObject();
jtw.WritePropertyName("command");
jtw.WriteValue("message");
jtw.WritePropertyName("identifier");
jtw.WriteValue("{\"channel\":\"ChatChannel\"}");
using (var sw2 = new StringWriter())
using (var jtw2 = new JsonTextWriter(sw2))
{
jtw2.WriteStartObject();
jtw2.WritePropertyName("channels");
jtw2.WriteStartArray();
foreach (var id in channelIds)
{
jtw2.WriteValue(id);
}
jtw2.WriteEndArray();
jtw2.WritePropertyName("action");
jtw2.WriteValue("subscribe");
jtw2.WriteEndObject();
jtw2.Flush();
jtw.WritePropertyName("data");
jtw.WriteValue(sw2.ToString());
}
jtw.WriteEndObject();
jtw.Flush();
sw.Flush();
if (!ms.TryGetBuffer(out b))
{
return(new InvalidOperationException().ToTask <object>());
}
}
return(ws.SendAsync(b, WebSocketMessageType.Text, true, ct ?? default(CancellationToken)));
}
/// <summary>
/// Internal method which generates the SPARQL Query Results JSON output
/// </summary>
/// <param name="results">Result Set to save</param>
/// <param name="output">Stream to save to</param>
private void GenerateOutput(SparqlResultSet results, TextWriter output)
{
JsonTextWriter writer = new JsonTextWriter(output);
writer.Formatting = Newtonsoft.Json.Formatting.Indented;
//Start a Json Object for the Result Set
writer.WriteStartObject();
//Create the Head Object
writer.WritePropertyName("head");
writer.WriteStartObject();
if (results.ResultsType == SparqlResultsType.VariableBindings)
{
//SELECT query results
//Create the Variables Object
writer.WritePropertyName("vars");
writer.WriteStartArray();
foreach (String var in results.Variables)
{
writer.WriteValue(var);
}
writer.WriteEndArray();
//End Head Object
writer.WriteEndObject();
//Create the Result Object
writer.WritePropertyName("results");
writer.WriteStartObject();
writer.WritePropertyName("bindings");
writer.WriteStartArray();
foreach (SparqlResult result in results)
{
//Create a Binding Object
writer.WriteStartObject();
foreach (String var in results.Variables)
{
if (!result.HasValue(var))
{
continue; //No output for unbound variables
}
INode value = result.Value(var);
if (value == null)
{
continue;
}
//Create an Object for the Variable
writer.WritePropertyName(var);
writer.WriteStartObject();
writer.WritePropertyName("type");
switch (value.NodeType)
{
case NodeType.Blank:
//Blank Node
writer.WriteValue("bnode");
writer.WritePropertyName("value");
String id = ((IBlankNode)value).InternalID;
id = id.Substring(id.IndexOf(':') + 1);
writer.WriteValue(id);
break;
case NodeType.GraphLiteral:
//Error
throw new RdfOutputException("Result Sets which contain Graph Literal Nodes cannot be serialized in the SPARQL Query Results JSON Format");
case NodeType.Literal:
//Literal
ILiteralNode lit = (ILiteralNode)value;
if (lit.DataType != null)
{
writer.WriteValue("typed-literal");
}
else
{
writer.WriteValue("literal");
}
writer.WritePropertyName("value");
writer.WriteValue(lit.Value);
if (!lit.Language.Equals(String.Empty))
{
writer.WritePropertyName("xml:lang");
writer.WriteValue(lit.Language);
}
else if (lit.DataType != null)
{
writer.WritePropertyName("datatype");
writer.WriteValue(lit.DataType.AbsoluteUri);
}
break;
case NodeType.Uri:
//Uri
writer.WriteValue("uri");
writer.WritePropertyName("value");
writer.WriteValue(value.ToString());
break;
default:
throw new RdfOutputException("Result Sets which contain Nodes of unknown Type cannot be serialized in the SPARQL Query Results JSON Format");
}
//End the Variable Object
writer.WriteEndObject();
}
//End the Binding Object
writer.WriteEndObject();
}
//End Result Object
writer.WriteEndArray();
writer.WriteEndObject();
}
else
{
//ASK query result
//Set an empty Json Object in the Head
writer.WriteEndObject();
//Create a Boolean Property
writer.WritePropertyName("boolean");
writer.WriteValue(results.Result);
}
//End the Json Object for the Result Set
writer.WriteEndObject();
}
private static void WriteCommandMetrics(JsonTextWriter writer, HystrixCommandMetrics commandMetrics)
{
IHystrixCommandKey key = commandMetrics.CommandKey;
ICircuitBreaker circuitBreaker = HystrixCircuitBreakerFactory.GetInstance(key);
writer.WriteStartObject();
writer.WriteStringField("type", "HystrixCommand");
writer.WriteStringField("name", key.Name);
writer.WriteStringField("group", commandMetrics.CommandGroup.Name);
writer.WriteLongField("currentTime", Time.CurrentTimeMillisJava);
// circuit breaker
if (circuitBreaker == null)
{
// circuit breaker is disabled and thus never open
writer.WriteBooleanField("isCircuitBreakerOpen", false);
}
else
{
writer.WriteBooleanField("isCircuitBreakerOpen", circuitBreaker.IsOpen);
}
HealthCounts healthCounts = commandMetrics.Healthcounts;
writer.WriteIntegerField("errorPercentage", healthCounts.ErrorPercentage);
writer.WriteLongField("errorCount", healthCounts.ErrorCount);
writer.WriteLongField("requestCount", healthCounts.TotalRequests);
// rolling counters
writer.WriteLongField("rollingCountBadRequests", commandMetrics.GetRollingCount(HystrixEventType.BAD_REQUEST));
writer.WriteLongField("rollingCountCollapsedRequests", commandMetrics.GetRollingCount(HystrixEventType.COLLAPSED));
writer.WriteLongField("rollingCountEmit", commandMetrics.GetRollingCount(HystrixEventType.EMIT));
writer.WriteLongField("rollingCountExceptionsThrown", commandMetrics.GetRollingCount(HystrixEventType.EXCEPTION_THROWN));
writer.WriteLongField("rollingCountFailure", commandMetrics.GetRollingCount(HystrixEventType.FAILURE));
writer.WriteLongField("rollingCountFallbackEmit", commandMetrics.GetRollingCount(HystrixEventType.FALLBACK_EMIT));
writer.WriteLongField("rollingCountFallbackFailure", commandMetrics.GetRollingCount(HystrixEventType.FALLBACK_FAILURE));
writer.WriteLongField("rollingCountFallbackMissing", commandMetrics.GetRollingCount(HystrixEventType.FALLBACK_MISSING));
writer.WriteLongField("rollingCountFallbackRejection", commandMetrics.GetRollingCount(HystrixEventType.FALLBACK_REJECTION));
writer.WriteLongField("rollingCountFallbackSuccess", commandMetrics.GetRollingCount(HystrixEventType.FALLBACK_SUCCESS));
writer.WriteLongField("rollingCountResponsesFromCache", commandMetrics.GetRollingCount(HystrixEventType.RESPONSE_FROM_CACHE));
writer.WriteLongField("rollingCountSemaphoreRejected", commandMetrics.GetRollingCount(HystrixEventType.SEMAPHORE_REJECTED));
writer.WriteLongField("rollingCountShortCircuited", commandMetrics.GetRollingCount(HystrixEventType.SHORT_CIRCUITED));
writer.WriteLongField("rollingCountSuccess", commandMetrics.GetRollingCount(HystrixEventType.SUCCESS));
writer.WriteLongField("rollingCountThreadPoolRejected", commandMetrics.GetRollingCount(HystrixEventType.THREAD_POOL_REJECTED));
writer.WriteLongField("rollingCountTimeout", commandMetrics.GetRollingCount(HystrixEventType.TIMEOUT));
writer.WriteIntegerField("currentConcurrentExecutionCount", commandMetrics.CurrentConcurrentExecutionCount);
writer.WriteLongField("rollingMaxConcurrentExecutionCount", commandMetrics.RollingMaxConcurrentExecutions);
// latency percentiles
writer.WriteIntegerField("latencyExecute_mean", commandMetrics.ExecutionTimeMean);
writer.WriteObjectFieldStart("latencyExecute");
writer.WriteIntegerField("0", commandMetrics.GetExecutionTimePercentile(0));
writer.WriteIntegerField("25", commandMetrics.GetExecutionTimePercentile(25));
writer.WriteIntegerField("50", commandMetrics.GetExecutionTimePercentile(50));
writer.WriteIntegerField("75", commandMetrics.GetExecutionTimePercentile(75));
writer.WriteIntegerField("90", commandMetrics.GetExecutionTimePercentile(90));
writer.WriteIntegerField("95", commandMetrics.GetExecutionTimePercentile(95));
writer.WriteIntegerField("99", commandMetrics.GetExecutionTimePercentile(99));
writer.WriteIntegerField("99.5", commandMetrics.GetExecutionTimePercentile(99.5));
writer.WriteIntegerField("100", commandMetrics.GetExecutionTimePercentile(100));
writer.WriteEndObject();
writer.WriteIntegerField("latencyTotal_mean", commandMetrics.TotalTimeMean);
writer.WriteObjectFieldStart("latencyTotal");
writer.WriteIntegerField("0", commandMetrics.GetTotalTimePercentile(0));
writer.WriteIntegerField("25", commandMetrics.GetTotalTimePercentile(25));
writer.WriteIntegerField("50", commandMetrics.GetTotalTimePercentile(50));
writer.WriteIntegerField("75", commandMetrics.GetTotalTimePercentile(75));
writer.WriteIntegerField("90", commandMetrics.GetTotalTimePercentile(90));
writer.WriteIntegerField("95", commandMetrics.GetTotalTimePercentile(95));
writer.WriteIntegerField("99", commandMetrics.GetTotalTimePercentile(99));
writer.WriteIntegerField("99.5", commandMetrics.GetTotalTimePercentile(99.5));
writer.WriteIntegerField("100", commandMetrics.GetTotalTimePercentile(100));
writer.WriteEndObject();
// property values for reporting what is actually seen by the command rather than what was set somewhere
IHystrixCommandOptions commandProperties = commandMetrics.Properties;
writer.WriteIntegerField("propertyValue_circuitBreakerRequestVolumeThreshold", commandProperties.CircuitBreakerRequestVolumeThreshold);
writer.WriteIntegerField("propertyValue_circuitBreakerSleepWindowInMilliseconds", commandProperties.CircuitBreakerSleepWindowInMilliseconds);
writer.WriteIntegerField("propertyValue_circuitBreakerErrorThresholdPercentage", commandProperties.CircuitBreakerErrorThresholdPercentage);
writer.WriteBooleanField("propertyValue_circuitBreakerForceOpen", commandProperties.CircuitBreakerForceOpen);
writer.WriteBooleanField("propertyValue_circuitBreakerForceClosed", commandProperties.CircuitBreakerForceClosed);
writer.WriteBooleanField("propertyValue_circuitBreakerEnabled", commandProperties.CircuitBreakerEnabled);
writer.WriteStringField("propertyValue_executionIsolationStrategy", commandProperties.ExecutionIsolationStrategy.ToString());
writer.WriteIntegerField("propertyValue_executionIsolationThreadTimeoutInMilliseconds", commandProperties.ExecutionTimeoutInMilliseconds);
writer.WriteIntegerField("propertyValue_executionTimeoutInMilliseconds", commandProperties.ExecutionTimeoutInMilliseconds);
writer.WriteBooleanField("propertyValue_executionIsolationThreadInterruptOnTimeout", false);
writer.WriteStringField("propertyValue_executionIsolationThreadPoolKeyOverride", commandProperties.ExecutionIsolationThreadPoolKeyOverride);
writer.WriteIntegerField("propertyValue_executionIsolationSemaphoreMaxConcurrentRequests", commandProperties.ExecutionIsolationSemaphoreMaxConcurrentRequests);
writer.WriteIntegerField("propertyValue_fallbackIsolationSemaphoreMaxConcurrentRequests", commandProperties.FallbackIsolationSemaphoreMaxConcurrentRequests);
writer.WriteIntegerField("propertyValue_metricsRollingStatisticalWindowInMilliseconds", commandProperties.MetricsRollingStatisticalWindowInMilliseconds);
writer.WriteBooleanField("propertyValue_requestCacheEnabled", commandProperties.RequestCacheEnabled);
writer.WriteBooleanField("propertyValue_requestLogEnabled", commandProperties.RequestLogEnabled);
writer.WriteIntegerField("reportingHosts", 1); // this will get summed across all instances in a cluster
writer.WriteStringField("threadPool", commandMetrics.ThreadPoolKey.Name);
writer.WriteEndObject();
}
IEnumerable <Task> ExportData(SaveFileDialog saveFile, bool indexesOnly)
{
Output("Exporting to {0}", saveFile.SafeFileName);
Output("- Indexes only, documents will be excluded");
var stream = saveFile.OpenFile();
var jsonRequestFactory = new HttpJsonRequestFactory();
var baseUrl = server.CurrentDatabaseAddress;
var credentials = new NetworkCredential();
var convention = new DocumentConvention();
var streamWriter = new StreamWriter(new GZipStream(stream, CompressionMode.Compress));
var jsonWriter = new JsonTextWriter(streamWriter)
{
Formatting = Formatting.Indented
};
Output("Begin reading indexes");
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("Indexes");
jsonWriter.WriteStartArray();
int totalCount = 0;
const int batchSize = 128;
var completed = false;
while (!completed)
{
var url = (baseUrl + "/indexes/?start=" + totalCount + "&pageSize=" + batchSize).NoCache();
var request = jsonRequestFactory.CreateHttpJsonRequest(this, url, "GET", credentials, convention);
var response = request.ReadResponseStringAsync();
yield return(response);
var documents = response.Result;
var array = JArray.Parse(documents);
if (array.Count == 0)
{
Output("Done with reading indexes, total: {0}", totalCount);
completed = true;
}
else
{
totalCount += array.Count;
Output("Reading batch of {0,3} indexes, read so far: {1,10:#,#}", array.Count, totalCount);
foreach (JToken item in array)
{
item.WriteTo(jsonWriter);
}
}
}
jsonWriter.WriteEndArray();
jsonWriter.WritePropertyName("Docs");
jsonWriter.WriteStartArray();
if (indexesOnly)
{
Output("Skipping documents");
}
else
{
Output("Begin reading documents");
var lastEtag = Guid.Empty;
totalCount = 0;
completed = false;
while (!completed)
{
var url = (baseUrl + "/docs/?pageSize=" + batchSize + "&etag=" + lastEtag).NoCache();
var request = jsonRequestFactory.CreateHttpJsonRequest(this, url, "GET", credentials, convention);
var response = request.ReadResponseStringAsync();
yield return(response);
var array = JArray.Parse(response.Result);
if (array.Count == 0)
{
Output("Done with reading documents, total: {0}", totalCount);
completed = true;
}
else
{
totalCount += array.Count;
Output("Reading batch of {0,3} documents, read so far: {1,10:#,#}", array.Count,
totalCount);
foreach (JToken item in array)
{
item.WriteTo(jsonWriter);
}
lastEtag = new Guid(array.Last.Value <JObject>("@metadata").Value <string>("@etag"));
}
}
}
Execute.OnUIThread(() =>
{
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
streamWriter.Flush();
streamWriter.Dispose();
stream.Dispose();
});
Output("Export complete");
}
// submit our data to the database, sinc to the watch and exit
private void saveOnClick(object sender, EventArgs e)
{
// gather all data (excluding list data)
string perscription = ((AutoCompleteTextView)FindViewById(Resource.Id.autoCompletePerscription)).Text;
string startDate = ((EditText)FindViewById(Resource.Id.perscriptionStartTime)).Text;
string endDate = ((EditText)FindViewById(Resource.Id.perscriptionEndTime)).Text;
string dosage = ((EditText)FindViewById(Resource.Id.txtDosage)).Text;
string form = (string)((Spinner)FindViewById(Resource.Id.formselect)).SelectedItem;
string takewith = (string)((Spinner)FindViewById(Resource.Id.instructionselect)).SelectedItem;
string Interval = (string)((Spinner)FindViewById(Resource.Id.intervalselect)).SelectedItem;
// validate data (excluding list data) already validated
Regex r = new Regex("^[0-9][0-9]/(0[0-9])|(1[0-2])/([0-2][0-9])|(3[0-1])");
bool error_occured = false;
StringBuilder error = new StringBuilder("Incorrect/missing inputs for ");
if (!r.IsMatch(startDate))
{
error_occured = true;
error.Append("Perscription start time");
}
if (endDate.Length > 0 && !r.IsMatch(endDate))
{
error_occured = true;
error.Append("Perscription end time");
}
if (perscription.Length == 0)
{
error_occured = true;
error.Append("Perscription ");
}
if (dosage.Length == 0 || decimal.Parse(dosage) == 0)
{
error_occured = true;
error.Append("Dosage ");
}
if (intervalAdapter.Count == 0)
{
error_occured = true;
error.Append("Intervals ");
}
if (error_occured)
{
Toast tost = Toast.MakeText(this, error.ToString(), ToastLength.Long);
tost.Show();
return;
}
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter writer = new JsonTextWriter(sw)) {
writer.Formatting = Formatting.Indented;
writer.WriteStartObject();
writer.WritePropertyName("user");
writer.WriteValue("*****@*****.**");// temporary until google authentication complete
writer.WritePropertyName("perscription");
writer.WriteValue(perscription);
writer.WritePropertyName("start_date");
writer.WriteValue(startDate);
writer.WritePropertyName("end_date");
writer.WriteValue(endDate);
writer.WritePropertyName("dosage");
writer.WriteValue(dosage);
writer.WritePropertyName("form");
writer.WriteValue(form);
writer.WritePropertyName("take_with");
writer.WriteValue(takewith);
writer.WritePropertyName("Interval");
writer.WriteValue(Interval);
writer.WritePropertyName("Intervals");
writer.WriteStartArray();
for (int x = 0; x < intervalAdapter.Count; x++)
{
writer.WriteValue(intervalAdapter.GetItem(x));
}
writer.WriteEnd();
writer.WriteEndObject();
}
// nowhere to send to yet
//sendRequest(sb.ToString());
// exit
Intent i = new Intent();
i.PutExtra("Perscription", sb.ToString());
SetResult(Result.Ok, i);
Finish();
}
public async Task <List <FlightDetails> > GetSiaFlightSearch(string originAirport, string destinationAirport, DateTime departureDate, DateTime returnDate, FlightClassType classType, int passengers)
{
List <FlightDetails> result = new List <FlightDetails>();
// Generate JSON input data for API call
StringBuilder sb = new StringBuilder();
using (JsonWriter writer = new JsonTextWriter(new StringWriter(sb)))
{
writer.Formatting = Formatting.Indented;
writer.WriteStartObject();
writer.WritePropertyName("clientUUID");
writer.WriteValue(Guid.NewGuid().ToString());
writer.WritePropertyName("request");
writer.WriteStartObject();
writer.WritePropertyName("itineraryDetails");
writer.WriteStartArray();
writer.WriteStartObject();
writer.WritePropertyName("originAirportCode");
writer.WriteValue(originAirport);
writer.WritePropertyName("destinationAirportCode");
writer.WriteValue(destinationAirport);
writer.WritePropertyName("departureDate");
writer.WriteValue(departureDate.ToString("yyyy-MM-dd"));
if (returnDate != new DateTime())
{
writer.WritePropertyName("returnDate");
writer.WriteValue(returnDate.ToString("yyyy-MM-dd"));
}
writer.WriteEndObject();
writer.WriteEndArray();
writer.WritePropertyName("cabinClass");
writer.WriteValue(((char)classType).ToString());
writer.WritePropertyName("adultCount");
writer.WriteValue(passengers);
writer.WritePropertyName("flightSortingRequired");
writer.WriteValue(true);
writer.WriteEndObject();
writer.WriteEndObject();
writer.Close();
}
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "")
{
Content = new StringContent(sb.ToString(), Encoding.UTF8, "application/json")
};
using (var response = await _client.SendAsync(request))
{
if (response.IsSuccessStatusCode)
{
JObject jsonResults = JObject.Parse(await response.Content.ReadAsStringAsync());
// Check for errors from API.
if (jsonResults.TryGetValue("message", out JToken message) && !String.IsNullOrEmpty(message.Value <string>()))
{
return(null);
}
else
{
// Flights found, get flight number and aircraft model for seat capacity.
if (jsonResults["response"]["segments"] == null)
{
FlightDetails departureFlight = new FlightDetails();
IList <JToken> flights = jsonResults["response"]["flights"].Children().ToList();
// Get first flight from result for departure
result.Add(new FlightDetails()
{
CurrentCapacity = passengers,
ClassType = classType,
IataOriginAirportCode = originAirport,
IataDestinationAirportCode = destinationAirport,
//IcaoOriginAirportCode = Globals.Airports[originAirport].Code,
//IcaoDestinationAirportCode = Globals.Airports[destinationAirport].Code,
Date = flights[0]["segments"][0].Value <DateTime>("departureDateTime"),
FlightNumber = flights[0]["segments"][0]["legs"][0]["operatingAirline"].Value <string>("code") + jsonResults["response"]["flights"][0]["segments"][0]["legs"][0].Value <string>("flightNumber"),
AircraftName = flights[0]["segments"][0]["legs"][0]["aircraft"].Value <string>("name"),
});
// Get first flight from result for return
if (flights.Count > 1)
{
result.Add(new FlightDetails()
{
CurrentCapacity = passengers,
ClassType = classType,
IataOriginAirportCode = destinationAirport,
IataDestinationAirportCode = originAirport,
//IcaoOriginAirportCode = Globals.Airports[destinationAirport].Code,
//IcaoDestinationAirportCode = Globals.Airports[originAirport].Code,
Date = flights[1]["segments"][0].Value <DateTime>("departureDateTime"),
FlightNumber = flights[1]["segments"][0]["legs"][0]["operatingAirline"].Value <string>("code") + jsonResults["response"]["flights"][1]["segments"][0]["legs"][0].Value <string>("flightNumber"),
AircraftName = flights[1]["segments"][0]["legs"][0]["aircraft"].Value <string>("name"),
});
}
}
}
}
else
{
return(null);
}
}
return(result);
}
public override void WriteEndObject()
{
_textWriter.WriteEndObject();
_innerWriter.WriteEndObject();
base.WriteEndObject();
}
public void WriteStructEnd()
{
writer.WriteEndObject();
}
private void WriteObject(object obj, bool isBase, Type type, JsonTextWriter writer, ObjectsBufferSave objectsBuffer)
{
writer.WriteStartObject();
writer.WritePropertyName(fieldType);
writer.WriteValue(type.AssemblyQualifiedName);
if (!type.IsValueType && !isBase)
{
writer.WritePropertyName(fieldRef);
writer.WriteValue(obj.GetHashCode());
}
if (type.IsArray)
{
Array arr = (Array)obj;
writer.WritePropertyName(fieldArraySize);
if (arr.Rank > 1)
{
writer.WriteStartArray();
for (int i = 0; i < arr.Rank; i++)
{
writer.WriteValue(arr.GetLength(i));
}
writer.WriteEndArray();
}
else
{
writer.WriteValue(arr.Length);
}
writer.WritePropertyName(fieldArrayElements);
int[] indexes = new int[arr.Rank];
WriteArray(writer, objectsBuffer, (Array)obj, arr.Rank - 1, indexes);
}
FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (FieldInfo field in fields)
{
if (field.GetCustomAttribute(typeof(NonSerializedAttribute)) == null)
{
object value = field.GetValue(obj);
string name = field.Name;
Type fieldType = field.FieldType;
writer.WritePropertyName(name);
if (IsValueType(fieldType))
{
if (IsPrimitive(fieldType))
{
writer.WriteValue(value);
}
else
{
WriteObject(value, false, fieldType, writer, objectsBuffer);
}
}
else
{
if (value != null)
{
int refIndex = value.GetHashCode();
writer.WriteValue(refOperatorStr + refIndex.ToString());
objectsBuffer.AddObject(value);
}
else
{
writer.WriteValue(refOperatorStr + "null");
}
}
}
}
Type baseType = type.BaseType;
if (baseType != null)
{
if (Attribute.GetCustomAttribute(baseType, typeof(SerializableAttribute)) != null)
{
writer.WritePropertyName(fieldBase);
WriteObject(obj, true, baseType, writer, objectsBuffer);
}
}
writer.WriteEndObject();
}
public async Task ExportToJson(string tableName, TextWriter writer, Action <int> progress = null)
{
try
{
var table = storageContext.GetTableReference(tableName);
var existsTable = await table.ExistsAsync();
if (!existsTable)
{
var message = $"Table '{tableName}' does not exist";
throw new FileNotFoundException(message);
}
var tableQuery = new TableQuery <DynamicTableEntity>();
TableContinuationToken tableContinuationToken = null;
var querySegmentIndex = 0;
JsonWriter wr = new JsonTextWriter(writer);
// prepare the array in result
wr.WriteStartArray();
// download the pages
do
{
// query the data
var queryResponse = await table.ExecuteQuerySegmentedAsync(tableQuery, tableContinuationToken, null, null);
var queryResponseEntitiesCount = queryResponse.Results.Count;
// move to next segment
tableContinuationToken = queryResponse.ContinuationToken;
// process the segment
++querySegmentIndex;
progress?.Invoke(queryResponseEntitiesCount);
// do the backup
foreach (var entity in queryResponse.Results)
{
wr.WriteStartObject();
wr.WritePropertyName(TableConstants.RowKey);
wr.WriteValue(entity.RowKey);
wr.WritePropertyName(TableConstants.PartitionKey);
wr.WriteValue(entity.PartitionKey);
wr.WritePropertyName(TableConstants.Properties);
wr.WriteStartArray();
foreach (var propertyKvp in entity.Properties)
{
wr.WriteStartObject();
wr.WritePropertyName(TableConstants.PropertyName);
wr.WriteValue(propertyKvp.Key);
wr.WritePropertyName(TableConstants.PropertyType);
wr.WriteValue(propertyKvp.Value.PropertyType);
wr.WritePropertyName(TableConstants.PropertyValue);
wr.WriteValue(GetPropertyValue(propertyKvp.Value.PropertyType, propertyKvp.Value));
wr.WriteEndObject();
}
wr.WriteEnd();
wr.WriteEndObject();
}
}while (tableContinuationToken != null);
// finishe the export
wr.WriteEnd();
wr.Flush();
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Save a log from a stream to the filesystem, also validates the data.
/// </summary>
/// <param name="stream">The stream where the log is found.</param>
/// <returns>Returns the log's unique id to use when requesting it from storage.</returns>
public static string PutFromStream(Stream stream)
{
string logID;
string path;
do
{
logID = Guid.NewGuid().ToString("D");
path = Path.Combine(AppDataDir, logID);
} while (File.Exists(path));
try
{
var s = new StreamReader(stream);
var reader = new JSchemaValidatingReader(new JsonTextReader(s));
using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write))
using (var w = new StreamWriter(fs))
using (var writer = new JsonTextWriter(w))
{
reader.Schema = Schema;
reader.ValidationEventHandler += (sender, args) => throw new JsonException();
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.None:
break;
case JsonToken.StartObject:
writer.WriteStartObject();
break;
case JsonToken.StartArray:
writer.WriteStartArray();
break;
case JsonToken.StartConstructor:
writer.WriteStartConstructor(reader.Value.ToString());
break;
case JsonToken.PropertyName:
writer.WritePropertyName(reader.Value.ToString());
break;
case JsonToken.Comment:
writer.WriteComment(reader.Value.ToString());
break;
case JsonToken.Raw:
writer.WriteRaw(reader.Value.ToString());
break;
case JsonToken.Integer:
writer.WriteValue(reader.Value);
break;
case JsonToken.Float:
writer.WriteValue(reader.Value);
break;
case JsonToken.String:
writer.WriteValue(reader.Value);
break;
case JsonToken.Boolean:
writer.WriteValue(reader.Value);
break;
case JsonToken.Null:
writer.WriteNull();
break;
case JsonToken.Undefined:
writer.WriteUndefined();
break;
case JsonToken.EndObject:
writer.WriteEndObject();
break;
case JsonToken.EndArray:
writer.WriteEndArray();
break;
case JsonToken.EndConstructor:
writer.WriteEndConstructor();
break;
case JsonToken.Date:
writer.WriteValue(reader.Value);
break;
case JsonToken.Bytes:
writer.WriteValue(reader.Value);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
catch (JsonException)
{
File.Delete(path);
throw;
}
catch (IOException e)
{
if (e.HResult != -2146232800)
{
throw;
}
}
return(logID);
}
private string Serialize(SerializeMethod method, object value)
{
string json;
switch (method)
{
case SerializeMethod.JsonNet:
json = JsonConvert.SerializeObject(value);
break;
case SerializeMethod.JsonNetWithIsoConverter:
json = JsonConvert.SerializeObject(value, new IsoDateTimeConverter());
break;
case SerializeMethod.JsonNetLinq:
{
TestClass c = value as TestClass;
if (c != null)
{
JObject o = new JObject(
new JProperty("strings", new JArray(
c.strings
)),
new JProperty("dictionary", new JObject(c.dictionary.Select(d => new JProperty(d.Key, d.Value)))),
new JProperty("Name", c.Name),
new JProperty("Now", c.Now),
new JProperty("BigNumber", c.BigNumber),
new JProperty("Address1", new JObject(
new JProperty("Street", c.Address1.Street),
new JProperty("Phone", c.Address1.Phone),
new JProperty("Entered", c.Address1.Entered))),
new JProperty("Addresses", new JArray(c.Addresses.Select(a =>
new JObject(
new JProperty("Street", a.Street),
new JProperty("Phone", a.Phone),
new JProperty("Entered", a.Entered)))))
);
json = o.ToString(Formatting.None);
}
else
{
json = string.Empty;
}
break;
}
case SerializeMethod.JsonNetManual:
{
TestClass c = value as TestClass;
if (c != null)
{
StringWriter sw = new StringWriter();
JsonTextWriter writer = new JsonTextWriter(sw);
writer.WriteStartObject();
writer.WritePropertyName("strings");
writer.WriteStartArray();
foreach (string s in c.strings)
{
writer.WriteValue(s);
}
writer.WriteEndArray();
writer.WritePropertyName("dictionary");
writer.WriteStartObject();
foreach (KeyValuePair <string, int> keyValuePair in c.dictionary)
{
writer.WritePropertyName(keyValuePair.Key);
writer.WriteValue(keyValuePair.Value);
}
writer.WriteEndObject();
writer.WritePropertyName("Name");
writer.WriteValue(c.Name);
writer.WritePropertyName("Now");
writer.WriteValue(c.Now);
writer.WritePropertyName("BigNumber");
writer.WriteValue(c.BigNumber);
writer.WritePropertyName("Address1");
writer.WriteStartObject();
writer.WritePropertyName("Street");
writer.WriteValue(c.BigNumber);
writer.WritePropertyName("Street");
writer.WriteValue(c.BigNumber);
writer.WritePropertyName("Street");
writer.WriteValue(c.BigNumber);
writer.WriteEndObject();
writer.WritePropertyName("Addresses");
writer.WriteStartArray();
foreach (Address address in c.Addresses)
{
writer.WriteStartObject();
writer.WritePropertyName("Street");
writer.WriteValue(address.Street);
writer.WritePropertyName("Phone");
writer.WriteValue(address.Phone);
writer.WritePropertyName("Entered");
writer.WriteValue(address.Entered);
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.WriteEndObject();
writer.Flush();
json = sw.ToString();
}
else
{
json = string.Empty;
}
break;
}
case SerializeMethod.JsonNetBinary:
{
MemoryStream ms = new MemoryStream(Buffer);
JsonSerializer serializer = new JsonSerializer();
BsonWriter writer = new BsonWriter(ms);
serializer.Serialize(writer, value);
//json = BitConverter.ToString(ms.ToArray(), 0, (int)ms.Position);
json = "Bytes = " + ms.Position;
break;
}
case SerializeMethod.JavaScriptSerializer:
json = SerializeWebExtensions(value);
break;
case SerializeMethod.DataContractJsonSerializer:
json = SerializeDataContractJson(value);
break;
case SerializeMethod.DataContractSerializer:
json = SerializeDataContract(value);
break;
case SerializeMethod.BinaryFormatter:
json = SerializeBinaryFormatter(value);
break;
default:
throw new ArgumentOutOfRangeException("method");
}
return(json);
}
public override void Get(HttpRequest Request, HttpResponse Response, params string[] PathParams)
{
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.Cache.SetMaxAge(TimeSpan.Zero);
try
{
//Int64 bid_id = (Request.QueryString["bid_id"] != null ? Int64.Parse(Request.QueryString["bid_id"].ToString()) : 0 );
Response.ContentType = @"application/json";
using (StreamWriter streamWriter = new StreamWriter(Response.OutputStream))
{
using (JsonTextWriter jsonWriter = new JsonTextWriter(streamWriter))
{
Int64 bid_id = 0;
Int64 AppUserId;
Int64 TempAppUserId = 0;
if (IsAuthorizedRequest(Request, Response, false, out AppUserId))
{
//the last bid of the app user that ended
Bid b = Bid.FetchByAppUserId(AppUserId);
if (b != null)
{
//if the bid isn't closed (there arn't any orders for this bid)
Order o = Order.FetchByBidId(b.BidId);
//if (o == null)
if (o == null || o.UserPaySupplierStatus == UserPaymentStatus.NotPayed)
{
bid_id = b.BidId;
}
}
}
else
{
TempAppUserId = Request["temp_app_user_id"] != null?Convert.ToInt64(Request["temp_app_user_id"]) : 0;
if (TempAppUserId != 0)
{
//the last bid of the temp app user that ended
Bid b = Bid.FetchByTempAppUserId(TempAppUserId);
if (b != null)
{
//if the bid isn't closed (there arn't any orders for this bid)
Order o = Order.FetchByBidId(b.BidId);
//if (o == null)
if (o == null || o.UserPaySupplierStatus == UserPaymentStatus.NotPayed)
{
bid_id = b.BidId;
}
}
}
}
Bid bid = Bid.FetchByID(bid_id);
if (bid_id == 0 || bid == null)
{
jsonWriter.WriteStartObject();
jsonWriter.WriteEndObject();
}
else
{
DateTime DateExpiryOffers = bid.EndDate.AddHours(Convert.ToDouble(Settings.GetSetting(Settings.Keys.EXPIRY_OFFER_TIME_HOURS)));
List <OfferUI> lstOfferUI = (bid_id != 0 && bid != null && DateTime.UtcNow < DateExpiryOffers ? OfferController.GetAllOfferByBidId(bid_id) : new List <OfferUI>());
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName(@"bid_id");
jsonWriter.WriteValue(bid_id);
jsonWriter.WritePropertyName(@"products");
jsonWriter.WriteStartArray();
List <BidProductUI> products = BidController.GetProductsByBid(bid_id);
foreach (BidProductUI item in products)
{
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName(@"product_id");
jsonWriter.WriteValue(item.ProductId);
jsonWriter.WritePropertyName(@"order_amount");
jsonWriter.WriteValue(item.Amount);
jsonWriter.WritePropertyName(@"product_name");
jsonWriter.WriteValue(item.ProductName);
jsonWriter.WritePropertyName(@"product_image");
jsonWriter.WriteValue(item.ProductImage);
jsonWriter.WriteEndObject();
}
jsonWriter.WriteEndArray();
jsonWriter.WritePropertyName(@"offers");
jsonWriter.WriteStartArray();
foreach (OfferUI item in lstOfferUI)
{
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName(@"offer_id");
jsonWriter.WriteValue(item.OfferId);
jsonWriter.WritePropertyName(@"supplier_id");
jsonWriter.WriteValue(item.SupplierId);
jsonWriter.WritePropertyName(@"mastercard_code");
if (item.MastercardCode == "")
{
jsonWriter.WriteValue((-1).ToString());
}
else
{
jsonWriter.WriteValue(item.MastercardCode);
}
jsonWriter.WritePropertyName(@"avg_rate");
jsonWriter.WriteValue(item.AvgRate);
jsonWriter.WritePropertyName(@"supplier_name");
jsonWriter.WriteValue(item.SupplierName);
jsonWriter.WritePropertyName(@"total_price");
jsonWriter.WriteValue(item.TotalPrice);
jsonWriter.WritePropertyName(@"gift");
jsonWriter.WriteValue(item.Gift);
jsonWriter.WriteEndObject();
}
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
}
}
}
}
catch (Exception) { }
}
/// <summary>
/// Serializes the Span to JSON.
/// </summary>
/// <param name="writer">The JSON Writer.</param>
/// <param name="span">The Span.</param>
/// <remarks>
/// Implementation note, for performance and correctness:
/// 1. Don't emit null fields at all if the value isn't populated.
/// No need for that space in the content on the wire.
/// 2. Design this method to be repeatable for multiple spans in case
/// we want to batch.
/// </remarks>
private static void SpanToJson(JsonTextWriter writer, Span span)
{
writer.WriteStartObject();
// meta-data
writer.WritePropertyName(TraceId);
writer.WriteValue(span.TypedContext.TraceId);
writer.WritePropertyName(SpanId);
var spanId = span.TypedContext.SpanId;
writer.WriteValue(spanId);
if (!string.IsNullOrEmpty(span.TypedContext.ParentId))
{
writer.WritePropertyName(ParentId);
writer.WriteValue(span.TypedContext.ParentId);
}
writer.WritePropertyName(OperationName);
writer.WriteValue(span.OperationName);
// timing
writer.WritePropertyName(Timestamp);
writer.WriteValue(span.Started.ToUnixMicros());
if (span.Duration.HasValue)
{
writer.WritePropertyName(Duration);
writer.WriteValue(span.Duration.Value.ToMicros());
}
// special flags
writer.WritePropertyName(Debug);
writer.WriteValue(span.Debug);
if (span.SpanKind.HasValue)
{
writer.WritePropertyName(Kind);
switch (span.SpanKind)
{
case SpanKind.CONSUMER:
writer.WriteValue("CONSUMER");
break;
case SpanKind.PRODUCER:
writer.WriteValue("PRODUCER");
break;
case SpanKind.CLIENT:
writer.WriteValue("CLIENT");
break;
case SpanKind.SERVER:
writer.WriteValue("SERVER");
break;
default:
throw new NotSupportedException($"Unknown span kind: [{span.SpanKind}]");
}
}
// endpoints
WriteEndpoint(writer, true, span.LocalEndpoint);
if (span.RemoteEndpoint != null)
{
WriteEndpoint(writer, false, span.RemoteEndpoint);
}
// tags
if (span.Tags.Any())
{
WriteTags(writer, span.Tags);
}
// annotations
if (span.Annotations.Any())
{
WriteAnnotations(writer, span.Annotations);
}
writer.WriteEndObject();
}
public static void WriteTo(this Item item, JsonTextWriter writer)
{
writer.WriteStartObject();
writer.WritePropertyName(item.Format.GetName());
switch (item.Format)
{
case SecsFormat.List:
writer.WriteStartArray();
foreach (var subitem in item.Items)
{
subitem.WriteTo(writer);
}
writer.WriteEndArray();
break;
case SecsFormat.ASCII:
case SecsFormat.JIS8:
writer.WriteValue(item.GetString());
break;
case SecsFormat.Binary:
WriteValue <byte>(writer, item);
break;
case SecsFormat.Boolean:
WriteValue <bool>(writer, item);
break;
case SecsFormat.I8:
WriteValue <long>(writer, item);
break;
case SecsFormat.I1:
WriteValue <sbyte>(writer, item);
break;
case SecsFormat.I2:
WriteValue <short>(writer, item);
break;
case SecsFormat.I4:
WriteValue <int>(writer, item);
break;
case SecsFormat.F4:
WriteValue <float>(writer, item);
break;
case SecsFormat.F8:
WriteValue <double>(writer, item);
break;
case SecsFormat.U8:
WriteValue <ulong>(writer, item);
break;
case SecsFormat.U1:
WriteValue <byte>(writer, item);
break;
case SecsFormat.U2:
WriteValue <ushort>(writer, item);
break;
case SecsFormat.U4:
WriteValue <uint>(writer, item);
break;
}
writer.WriteEndObject();
void WriteValue <T>(JsonTextWriter w, Item i) where T : unmanaged
{
w.WriteStartArray();
foreach (var v in i.GetValues <T>())
{
w.WriteValue(v);
}
w.WriteEndArray();
}
}
void SaveConfigInternalMisc(JsonTextWriter writer)
{
writer.WriteStartObject ();
writer.WriteKey ("include_mentions");
writer.WriteBoolean (_mgr.HomeIncludeMentions);
writer.WriteEndObject ();
}
void WriteSearch(JsonTextWriter writer, SearchStatuses search)
{
writer.WriteStartObject ();
writer.WriteKey ("keywords");
writer.WriteString (search.Keyword);
writer.WriteKey ("username");
writer.WriteString (search.Account.ScreenName);
WriteRestUsage (writer, search.RestInfo);
writer.WriteEndObject ();
}
private void BuildResponseJson(StringBuilder sb, PendingDownstreamMessage message)
{
using (var stringWriter = new StringWriter(sb))
using (var writer = new JsonTextWriter(stringWriter))
{
if (message == null)
{
writer.WriteStartArray();
writer.WriteValue("noop");
writer.WriteEndArray();
}
else
{
var responseType = message.Message.GetType();
var responseServiceType = ServiceRegistry.GetAssembly(responseType.Assembly).TypesByType[responseType];
writer.WriteStartObject();
writer.WritePropertyName("r");
writer.WriteValue((int)message.Kind);
writer.WritePropertyName("a");
writer.WriteValue((int)message.AssociationId);
writer.WritePropertyName("t");
writer.WriteValue(responseServiceType.Message.Id);
writer.WritePropertyName("p");
JsonUtil.SerializeMessage(writer, responseServiceType, message.Message);
writer.WriteEndObject();
}
}
}
public virtual async Task <string> ExportData(Stream stream, SmugglerOptions options, bool incremental, bool lastEtagsFromFile, PeriodicBackupStatus backupStatus)
{
options = options ?? SmugglerOptions;
if (options == null)
{
throw new ArgumentNullException("options");
}
var file = options.BackupPath;
#if !SILVERLIGHT
if (incremental)
{
if (Directory.Exists(options.BackupPath) == false)
{
if (File.Exists(options.BackupPath))
{
options.BackupPath = Path.GetDirectoryName(options.BackupPath) ?? options.BackupPath;
}
else
{
Directory.CreateDirectory(options.BackupPath);
}
}
if (lastEtagsFromFile && backupStatus == null)
{
ReadLastEtagsFromFile(options);
}
if (backupStatus != null)
{
ReadLastEtagsFromClass(options, backupStatus);
}
file = Path.Combine(options.BackupPath, SystemTime.UtcNow.ToString("yyyy-MM-dd-HH-mm", CultureInfo.InvariantCulture) + ".ravendb-incremental-dump");
if (File.Exists(file))
{
var counter = 1;
while (true)
{
file = Path.Combine(options.BackupPath, SystemTime.UtcNow.ToString("yyyy-MM-dd-HH-mm", CultureInfo.InvariantCulture) + " - " + counter + ".ravendb-incremental-dump");
if (File.Exists(file) == false)
{
break;
}
counter++;
}
}
}
#else
if (incremental)
{
throw new NotSupportedException("Incremental exports are not supported in SL.");
}
#endif
Mode = await GetMode();
bool ownedStream = stream == null;
try
{
stream = stream ?? File.Create(file);
using (var gZipStream = new GZipStream(stream, CompressionMode.Compress,
#if SILVERLIGHT
CompressionLevel.BestCompression,
#endif
leaveOpen: true))
using (var streamWriter = new StreamWriter(gZipStream))
{
var jsonWriter = new JsonTextWriter(streamWriter)
{
Formatting = Formatting.Indented
};
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("Indexes");
jsonWriter.WriteStartArray();
if ((options.OperateOnTypes & ItemType.Indexes) == ItemType.Indexes)
{
await ExportIndexes(jsonWriter);
}
jsonWriter.WriteEndArray();
jsonWriter.WritePropertyName("Docs");
jsonWriter.WriteStartArray();
if ((options.OperateOnTypes & ItemType.Documents) == ItemType.Documents)
{
options.LastDocsEtag = await ExportDocuments(options, jsonWriter, options.LastDocsEtag);
}
jsonWriter.WriteEndArray();
jsonWriter.WritePropertyName("Attachments");
jsonWriter.WriteStartArray();
if ((options.OperateOnTypes & ItemType.Attachments) == ItemType.Attachments)
{
options.LastAttachmentEtag = await ExportAttachments(jsonWriter, options.LastAttachmentEtag);
}
jsonWriter.WriteEndArray();
jsonWriter.WritePropertyName("Transformers");
jsonWriter.WriteStartArray();
if ((options.OperateOnTypes & ItemType.Transformers) == ItemType.Transformers)
{
await ExportTransformers(jsonWriter);
}
jsonWriter.WriteEndArray();
jsonWriter.WriteEndObject();
streamWriter.Flush();
}
#if !SILVERLIGHT
if (incremental && lastEtagsFromFile)
{
WriteLastEtagsFromFile(options);
}
#endif
return(file);
}
finally
{
if (ownedStream && stream != null)
{
stream.Dispose();
}
}
}
public void Save(ConfigSaveDelegate save)
{
using (StreamWriter streamWriter = new StreamWriter (ConfigFilePath, false, System.Text.Encoding.UTF8))
using (JsonTextWriter writer = new JsonTextWriter (streamWriter)) {
writer.WriteStartObject ();
writer.WriteKey ("accounts");
writer.WriteStartArray ();
for (int i = 0; i < _accounts.Length; i ++)
WriteAccount (writer, _accounts[i]);
writer.WriteEndArray ();
writer.WriteKey ("searches");
writer.WriteStartArray ();
for (int i = 0; i < _searches.Length; i ++)
WriteSearch (writer, _searches[i]);
writer.WriteEndArray ();
writer.WriteKey ("lists");
writer.WriteStartArray ();
for (int i = 0; i < _lists.Length; i++)
WriteList (writer, _lists[i]);
writer.WriteEndArray ();
save (writer);
writer.WriteEndObject ();
}
}
private void PopulateControls()
{
string featuredImageUrl = string.Empty;
string markupTop = string.Empty;
string markupBottom = string.Empty;
featuredImageUrl = String.IsNullOrWhiteSpace(Config.InstanceFeaturedImage) ? featuredImageUrl : SiteUtils.GetNavigationSiteRoot() + Config.InstanceFeaturedImage;
markupTop = displaySettings.ModuleInstanceMarkupTop;
markupBottom = displaySettings.ModuleInstanceMarkupBottom;
strOutput.Append(markupTop);
if (Config.UseHeader && Config.HeaderLocation == "InnerBodyPanel" && !String.IsNullOrWhiteSpace(Config.HeaderContent) && !String.Equals(Config.HeaderContent, "<p> </p>"))
{
try
{
strOutput.Append(string.Format(displaySettings.HeaderContentFormat, Config.HeaderContent));
}
catch (FormatException ex)
{
log.ErrorFormat(markupErrorFormat, "HeaderContentFormat", moduleTitle, ex);
}
}
StringBuilder jsonString = new StringBuilder();
StringWriter stringWriter = new StringWriter(jsonString);
JsonTextWriter jsonWriter = new JsonTextWriter(stringWriter);
// http://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_DateTimeZoneHandling.htm
jsonWriter.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
// http://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_DateFormatHandling.htm
jsonWriter.DateFormatHandling = DateFormatHandling.IsoDateFormat;
string jsonObjName = "sflexi" + module.ModuleId.ToString() + (Config.IsGlobalView ? "Modules" : "Items");
if (Config.RenderJSONOfData)
{
jsonWriter.WriteRaw("var " + jsonObjName + " = ");
if (Config.JsonLabelObjects || Config.IsGlobalView)
{
jsonWriter.WriteStartObject();
}
else
{
jsonWriter.WriteStartArray();
}
}
List <IndexedStringBuilder> itemsMarkup = new List <IndexedStringBuilder>();
//List<Item> categorizedItems = new List<Item>();
bool usingGlobalViewMarkup = !String.IsNullOrWhiteSpace(displaySettings.GlobalViewMarkup);
int currentModuleID = -1;
foreach (Item item in items)
{
bool itemIsEditable = IsEditable || WebUser.IsInRoles(item.EditRoles);
bool itemIsViewable = itemIsEditable || WebUser.IsAdminOrContentAdminOrContentPublisherOrContentAuthor || WebUser.IsInRoles(item.ViewRoles);
if (!itemIsViewable)
{
continue;
}
//int itemCount = 0;
//StringBuilder content = new StringBuilder();
IndexedStringBuilder content = new IndexedStringBuilder();
ModuleConfiguration itemModuleConfig = Config;
if (Config.IsGlobalView)
{
itemModuleConfig = new ModuleConfiguration(module);
content.SortOrder1 = itemModuleConfig.GlobalViewSortOrder;
content.SortOrder2 = item.SortOrder;
}
else
{
content.SortOrder1 = item.SortOrder;
}
item.ModuleFriendlyName = itemModuleConfig.ModuleFriendlyName;
if (String.IsNullOrWhiteSpace(itemModuleConfig.ModuleFriendlyName))
{
Module itemModule = new Module(item.ModuleGuid);
if (itemModule != null)
{
item.ModuleFriendlyName = itemModule.ModuleTitle;
}
}
//List<ItemFieldValue> fieldValues = ItemFieldValue.GetItemValues(item.ItemGuid);
//using item.ModuleID here because if we are using a 'global view' we need to be sure the item edit link uses the correct module id.
string itemEditUrl = SiteUtils.GetNavigationSiteRoot() + "/SuperFlexi/Edit.aspx?pageid=" + PageId + "&mid=" + item.ModuleID + "&itemid=" + item.ItemID;
string itemEditLink = itemIsEditable ? String.Format(displaySettings.ItemEditLinkFormat, itemEditUrl) : string.Empty;
if (Config.RenderJSONOfData)
{
if (Config.IsGlobalView)
{
if (currentModuleID != item.ModuleID)
{
if (currentModuleID != -1)
{
jsonWriter.WriteEndObject();
jsonWriter.WriteEndObject();
}
currentModuleID = item.ModuleID;
//always label objects in globalview
jsonWriter.WritePropertyName("m" + currentModuleID.ToString());
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("Module");
jsonWriter.WriteValue(item.ModuleFriendlyName);
jsonWriter.WritePropertyName("Items");
jsonWriter.WriteStartObject();
}
}
if (Config.JsonLabelObjects || Config.IsGlobalView)
{
jsonWriter.WritePropertyName("i" + item.ItemID.ToString());
}
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("ItemId");
jsonWriter.WriteValue(item.ItemID.ToString());
jsonWriter.WritePropertyName("SortOrder");
jsonWriter.WriteValue(item.SortOrder.ToString());
if (IsEditable)
{
jsonWriter.WritePropertyName("EditUrl");
jsonWriter.WriteValue(itemEditUrl);
}
}
content.Append(displaySettings.ItemMarkup);
foreach (Field field in fields)
{
//if (!WebUser.IsInRoles(field.ViewRoles))
//{
// continue;
//}
if (String.IsNullOrWhiteSpace(field.Token))
{
field.Token = "$_NONE_$"; //just in case someone has loaded the database with fields without using a source file.
}
bool fieldValueFound = false;
var itemFieldValues = fieldValues.Where(fv => fv.ItemGuid == item.ItemGuid);
var tokens = fields.Select(x => new { x.Token, x.FieldGuid, x.PreTokenString, x.PostTokenString, x.PreTokenStringWhenFalse, x.PreTokenStringWhenTrue, x.PostTokenStringWhenFalse, x.PostTokenStringWhenTrue, x.ControlType });
foreach (ItemFieldValue fieldValue in itemFieldValues)
{
if (field.FieldGuid == fieldValue.FieldGuid)
{
fieldValueFound = true;
if (String.IsNullOrWhiteSpace(fieldValue.FieldValue) ||
fieldValue.FieldValue.StartsWith("&deleted&") ||
fieldValue.FieldValue.StartsWith("&deleted&") ||
fieldValue.FieldValue.StartsWith("<p>&deleted&</p>") ||
fieldValue.FieldValue.StartsWith("<p>&deleted&</p>") ||
(!WebUser.IsAdminOrContentAdminOrContentPublisherOrContentAuthor &&
!WebUser.IsInRoles(field.ViewRoles)))
{
content.Replace("^" + field.Token + "^", string.Empty);
content.Replace("^" + field.Token, string.Empty);
content.Replace(field.Token + "^", string.Empty);
content.Replace(field.Token, string.Empty);
}
else
{
if (IsDateField(field))
{
DateTime dateTime = new DateTime();
if (DateTime.TryParse(fieldValue.FieldValue, out dateTime))
{
/// ^field.Token is used when we don't want the preTokenString and postTokenString to be used
content.Replace("^" + field.Token + "^", dateTime.ToString(field.DateFormat));
content.Replace("^" + field.Token, dateTime.ToString(field.DateFormat) + field.PostTokenString);
content.Replace(field.Token + "^", field.PreTokenString + dateTime.ToString(field.DateFormat));
content.Replace(field.Token, field.PreTokenString + dateTime.ToString(field.DateFormat) + field.PostTokenString);
}
}
if (IsCheckBoxListField(field) || IsRadioButtonListField(field))
{
foreach (CheckBoxListMarkup cblm in Config.CheckBoxListMarkups)
{
if (cblm.Field == field.Name)
{
StringBuilder cblmContent = new StringBuilder();
List <string> values = fieldValue.FieldValue.SplitOnCharAndTrim(';');
if (values.Count > 0)
{
foreach (string value in values)
{
//why did we use _ValueItemID_ here instead of _ItemID_?
cblmContent.Append(cblm.Markup.Replace(field.Token, value).Replace("$_ValueItemID_$", item.ItemID.ToString()) + cblm.Separator);
cblm.SelectedValues.Add(new CheckBoxListMarkup.SelectedValue {
Value = value, ItemID = item.ItemID
});
//cblm.SelectedValues.Add(fieldValue);
}
}
cblmContent.Length -= cblm.Separator.Length;
content.Replace(cblm.Token, cblmContent.ToString());
}
}
}
if (field.ControlType == "CheckBox")
{
string checkBoxContent = string.Empty;
if (fieldValue.FieldValue == field.CheckBoxReturnValueWhenTrue)
{
content.Replace("^" + field.Token + "^", fieldValue.FieldValue);
content.Replace("^" + field.Token, fieldValue.FieldValue + field.PostTokenString + field.PostTokenStringWhenTrue);
content.Replace(field.Token + "^", field.PreTokenString + field.PreTokenStringWhenTrue + fieldValue.FieldValue);
content.Replace(field.Token, field.PreTokenString + field.PreTokenStringWhenTrue + fieldValue.FieldValue + field.PostTokenString + field.PostTokenStringWhenTrue);
}
else if (fieldValue.FieldValue == field.CheckBoxReturnValueWhenFalse)
{
content.Replace("^" + field.Token + "^", fieldValue.FieldValue);
content.Replace("^" + field.Token, fieldValue.FieldValue + field.PostTokenString + field.PostTokenStringWhenFalse);
content.Replace(field.Token + "^", field.PreTokenString + field.PreTokenStringWhenFalse + fieldValue.FieldValue);
content.Replace(field.Token, field.PreTokenString + field.PreTokenStringWhenFalse + fieldValue.FieldValue + field.PostTokenString + field.PostTokenStringWhenFalse);
}
}
// ^field.Token^ is used when we don't want the preTokenString and postTokenString to be used
content.Replace("^" + field.Token + "^", fieldValue.FieldValue);
content.Replace("^" + field.Token, fieldValue.FieldValue + field.PostTokenString);
content.Replace(field.Token + "^", field.PreTokenString + fieldValue.FieldValue);
content.Replace(field.Token, field.PreTokenString + fieldValue.FieldValue + field.PostTokenString);
//We want any tokens used in our pre or post token strings to be replaced.
//todo: add controlType specific logic to be sure tokens used in pre and post are replaced with proper formatting (i.e.: date field)
List <string> prePostTokenStrings = new List <string>();
if (!String.IsNullOrWhiteSpace(field.PreTokenString))
{
prePostTokenStrings.Add(field.PreTokenString);
}
if (!String.IsNullOrWhiteSpace(field.PostTokenString))
{
prePostTokenStrings.Add(field.PostTokenString);
}
if (!String.IsNullOrWhiteSpace(field.PreTokenStringWhenTrue))
{
prePostTokenStrings.Add(field.PreTokenStringWhenTrue);
}
if (!String.IsNullOrWhiteSpace(field.PreTokenStringWhenFalse))
{
prePostTokenStrings.Add(field.PreTokenStringWhenFalse);
}
if (!String.IsNullOrWhiteSpace(field.PostTokenStringWhenTrue))
{
prePostTokenStrings.Add(field.PostTokenStringWhenTrue);
}
if (!String.IsNullOrWhiteSpace(field.PostTokenStringWhenFalse))
{
prePostTokenStrings.Add(field.PostTokenStringWhenFalse);
}
var sharedTokens = tokens.Where(token => prePostTokenStrings.Any(tokenString => tokenString.Contains(token.Token))).ToList();
//foreach (var token in tokens)
//{
// if (prePostTokenStrings.Contains(token.Token))
// {
// sharedTokens.Add(token);
// }
//}
foreach (var token in sharedTokens)
{
var sharedTokenFieldValue = fieldValues.Where(x => x.FieldGuid == token.FieldGuid && x.ItemGuid == item.ItemGuid).Select(y => y.FieldValue).Single();
//content.Replace(token.Token, );
//if (token.ControlType == "CheckBox")
//{
// string checkBoxContent = string.Empty;
// if (sharedTokenFieldValue == field.CheckBoxReturnValueWhenTrue)
// {
// content.Replace("^" + field.Token + "^", fieldValue.FieldValue);
// content.Replace("^" + field.Token, fieldValue.FieldValue + field.PostTokenString + field.PostTokenStringWhenTrue);
// content.Replace(field.Token + "^", field.PreTokenString + field.PreTokenStringWhenTrue + fieldValue.FieldValue);
// content.Replace(field.Token, field.PreTokenString + field.PreTokenStringWhenTrue + fieldValue.FieldValue + field.PostTokenString + field.PostTokenStringWhenTrue);
// }
// else if (fieldValue.FieldValue == field.CheckBoxReturnValueWhenFalse)
// {
// content.Replace("^" + field.Token + "^", fieldValue.FieldValue);
// content.Replace("^" + field.Token, fieldValue.FieldValue + field.PostTokenString + field.PostTokenStringWhenFalse);
// content.Replace(field.Token + "^", field.PreTokenString + field.PreTokenStringWhenFalse + fieldValue.FieldValue);
// content.Replace(field.Token, field.PreTokenString + field.PreTokenStringWhenFalse + fieldValue.FieldValue + field.PostTokenString + field.PostTokenStringWhenFalse);
// }
//}
if (!String.IsNullOrWhiteSpace(sharedTokenFieldValue))
{
content.Replace("^" + token.Token + "^", sharedTokenFieldValue);
content.Replace("^" + token.Token, sharedTokenFieldValue + token.PostTokenString);
content.Replace(token.Token + "^", token.PreTokenString + sharedTokenFieldValue);
content.Replace(token.Token, token.PreTokenString + sharedTokenFieldValue + token.PostTokenString);
}
}
}
//if (!String.IsNullOrWhiteSpace(field.LinkedField))
//{
// Field linkedField = fields.Find(delegate(Field f) { return f.Name == field.LinkedField; });
// if (linkedField != null)
// {
// ItemFieldValue linkedValue = fieldValues.Find(delegate(ItemFieldValue fv) { return fv.FieldGuid == linkedField.FieldGuid; });
// content.Replace(linkedField.Token, linkedValue.FieldValue);
// }
//}
if (Config.RenderJSONOfData &&
(WebUser.IsAdminOrContentAdminOrContentPublisherOrContentAuthor || WebUser.IsInRoles(field.ViewRoles)))
{
jsonWriter.WritePropertyName(field.Name);
//if (IsDateField(field))
//{
// DateTime dateTime = new DateTime();
// if (DateTime.TryParse(fieldValue.FieldValue, out dateTime))
// {
// jsonWriter.WriteValue(dateTime);
// }
//}
//else
//{
if (field.ControlType == "CheckBox" && field.CheckBoxReturnBool == true)
{
jsonWriter.WriteValue(Convert.ToBoolean(fieldValue.FieldValue));
}
else
{
jsonWriter.WriteValue(fieldValue.FieldValue);
}
//}
}
}
}
if (!fieldValueFound)
{
if (WebUser.IsAdminOrContentAdminOrContentPublisherOrContentAuthor || WebUser.IsInRoles(field.ViewRoles))
{
content.Replace(field.Token, field.DefaultValue);
if (Config.RenderJSONOfData)
{
jsonWriter.WritePropertyName(field.Name);
if (field.ControlType == "CheckBox" && field.CheckBoxReturnBool == true)
{
jsonWriter.WriteValue(Convert.ToBoolean(field.DefaultValue));
}
else
{
jsonWriter.WriteValue(field.DefaultValue);
}
}
}
else
{
content.Replace(field.Token, string.Empty);
}
}
}
if (Config.RenderJSONOfData)
{
//if (config.IsGlobalView)
//{
// jsonWriter.WriteEndObject();
//}
jsonWriter.WriteEndObject();
}
content.Replace("$_EditLink_$", itemEditLink);
content.Replace("$_ItemID_$", item.ItemID.ToString());
content.Replace("$_SortOrder_$", item.SortOrder.ToString());
if (!String.IsNullOrWhiteSpace(content))
{
itemsMarkup.Add(content);
}
}
if (Config.DescendingSort)
{
itemsMarkup.Sort(delegate(IndexedStringBuilder a, IndexedStringBuilder b)
{
int xdiff = b.SortOrder1.CompareTo(a.SortOrder1);
if (xdiff != 0)
{
return(xdiff);
}
else
{
return(b.SortOrder2.CompareTo(a.SortOrder2));
}
});
}
else
{
itemsMarkup.Sort(delegate(IndexedStringBuilder a, IndexedStringBuilder b)
{
int xdiff = a.SortOrder1.CompareTo(b.SortOrder1);
if (xdiff != 0)
{
return(xdiff);
}
else
{
return(a.SortOrder2.CompareTo(b.SortOrder2));
}
});
}
StringBuilder allItems = new StringBuilder();
if (displaySettings.ItemsPerGroup == -1)
{
foreach (IndexedStringBuilder sb in itemsMarkup)
{
//allItems.Append(displaySettings.GlobalViewModuleGroupMarkup.Replace("$_ModuleGroupName_$", sb.GroupName));
allItems.Append(sb.ToString());
}
if (usingGlobalViewMarkup)
{
strOutput.AppendFormat(displaySettings.ItemsWrapperFormat, displaySettings.GlobalViewMarkup.Replace("$_ModuleGroups_$", allItems.ToString()));
}
else
{
strOutput.AppendFormat(displaySettings.ItemsWrapperFormat, allItems.ToString());
}
}
else
{
int itemIndex = 0;
decimal totalGroupCount = Math.Ceiling(itemsMarkup.Count / Convert.ToDecimal(displaySettings.ItemsPerGroup));
if (totalGroupCount < 1 && itemsMarkup.Count > 0)
{
totalGroupCount = 1;
}
int currentGroup = 1;
List <StringBuilder> groups = new List <StringBuilder>();
while (currentGroup <= totalGroupCount && itemIndex < itemsMarkup.Count)
{
StringBuilder group = new StringBuilder();
group.Append(displaySettings.ItemsRepeaterMarkup);
//group.SortOrder1 = itemsMarkup[itemIndex].SortOrder1;
//group.SortOrder2 = itemsMarkup[itemIndex].SortOrder2;
//group.GroupName = itemsMarkup[itemIndex].GroupName;
for (int i = 0; i < displaySettings.ItemsPerGroup; i++)
{
if (itemIndex < itemsMarkup.Count)
{
group.Replace("$_Items[" + i.ToString() + "]_$", itemsMarkup[itemIndex].ToString());
itemIndex++;
}
else
{
break;
}
}
groups.Add(group);
currentGroup++;
}
//groups.Sort(delegate (IndexedStringBuilder a, IndexedStringBuilder b) {
// int xdiff = a.SortOrder1.CompareTo(b.SortOrder1);
// if (xdiff != 0) return xdiff;
// else return a.SortOrder2.CompareTo(b.SortOrder2);
//});
foreach (StringBuilder group in groups)
{
allItems.Append(group.ToString());
}
strOutput.AppendFormat(displaySettings.ItemsWrapperFormat, Regex.Replace(allItems.ToString(), @"(\$_Items\[[0-9]+\]_\$)", string.Empty, RegexOptions.Multiline));
}
//strOutput.Append(displaySettings.ItemListMarkupBottom);
if (Config.RenderJSONOfData)
{
if (Config.JsonLabelObjects || Config.IsGlobalView)
{
jsonWriter.WriteEndObject();
if (Config.IsGlobalView)
{
jsonWriter.WriteEndObject();
jsonWriter.WriteEnd();
}
}
else
{
jsonWriter.WriteEndArray();
}
MarkupScript jsonScript = new MarkupScript();
jsonWriter.Close();
stringWriter.Close();
jsonScript.RawScript = stringWriter.ToString();
jsonScript.Position = Config.JsonRenderLocation;
jsonScript.ScriptName = "sflexi" + module.ModuleId.ToString() + Config.MarkupDefinitionName.ToCleanFileName() + "-JSON";
List <MarkupScript> scripts = new List <MarkupScript>();
scripts.Add(jsonScript);
SuperFlexiHelpers.SetupScripts(scripts, Config, displaySettings, siteSettings.UseSslOnAllPages, IsEditable, IsPostBack, ClientID, ModuleId, PageId, Page, this);
}
if (Config.UseFooter && Config.FooterLocation == "InnerBodyPanel" && !String.IsNullOrWhiteSpace(Config.FooterContent) && !String.Equals(Config.FooterContent, "<p> </p>"))
{
try
{
strOutput.AppendFormat(displaySettings.FooterContentFormat, Config.FooterContent);
}
catch (System.FormatException ex)
{
log.ErrorFormat(markupErrorFormat, "FooterContentFormat", moduleTitle, ex);
}
}
strOutput.Append(markupBottom);
SuperFlexiHelpers.ReplaceStaticTokens(strOutput, Config, IsEditable, displaySettings, module.ModuleId, pageSettings, siteSettings, out strOutput);
//this is for displaying all of the selected values from the items outside of the items themselves
foreach (CheckBoxListMarkup cblm in Config.CheckBoxListMarkups)
{
StringBuilder cblmContent = new StringBuilder();
if (fields.Count > 0 && cblm.SelectedValues.Count > 0)
{
Field theField = fields.Where(field => field.Name == cblm.Field).Single();
if (theField != null)
{
List <CheckBoxListMarkup.SelectedValue> distinctSelectedValues = new List <CheckBoxListMarkup.SelectedValue>();
foreach (CheckBoxListMarkup.SelectedValue selectedValue in cblm.SelectedValues)
{
CheckBoxListMarkup.SelectedValue match = distinctSelectedValues.Find(i => i.Value == selectedValue.Value);
if (match == null)
{
distinctSelectedValues.Add(selectedValue);
}
else
{
match.Count++;
}
}
//var selectedValues = cblm.SelectedValues.GroupBy(selectedValue => selectedValue.Value)
// .Select(distinctSelectedValue => new { Value = distinctSelectedValue.Key, Count = distinctSelectedValue.Count(), ItemID = distinctSelectedValue.ItemID })
// .OrderBy(x => x.Value);
foreach (CheckBoxListMarkup.SelectedValue value in distinctSelectedValues)
{
cblmContent.Append(cblm.Markup.Replace(theField.Token, value.Value).Replace("$_ValueItemID_$", value.ItemID.ToString()) + cblm.Separator);
cblmContent.Replace("$_CBLValueCount_$", value.Count.ToString());
}
}
if (cblmContent.Length >= cblm.Separator.Length)
{
cblmContent.Length -= cblm.Separator.Length;
}
strOutput.Replace(cblm.Token, cblmContent.ToString());
}
strOutput.Replace(cblm.Token, string.Empty);
}
theLit.Text = strOutput.ToString();
}
void WriteList(JsonTextWriter writer, ListStatuses list)
{
writer.WriteStartObject ();
writer.WriteKey ("id");
writer.WriteNumber (list.List.ID);
writer.WriteKey ("username");
writer.WriteString (list.Account.ScreenName);
WriteRestUsage (writer, list.RestInfo);
writer.WriteEndObject ();
}
public async Task ExportAsync(Stream outStream, ExportImportOptions options, Action <ExportImportProgressInfo> progressCallback, ICancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var progressInfo = new ExportImportProgressInfo {
Description = "The fulfilmentCenters are loading"
};
progressCallback(progressInfo);
//var backupObject = await GetBackupObject(progressCallback);
using (var sw = new StreamWriter(outStream, Encoding.UTF8))
using (var writer = new JsonTextWriter(sw))
{
writer.WriteStartObject();
var centers = await _fulfillmentCenterSearchService.SearchCentersAsync(new FulfillmentCenterSearchCriteria { Take = int.MaxValue });
writer.WritePropertyName("FulfillmentCenterTotalCount");
writer.WriteValue(centers.TotalCount);
writer.WritePropertyName("FulfillmentCenters");
writer.WriteStartArray();
foreach (var fulfillmentCenter in centers.Results)
{
_serializer.Serialize(writer, fulfillmentCenter);
}
writer.WriteEndArray();
progressInfo.Description = "Evaluation the number of inventory records";
progressCallback(progressInfo);
var searchResult = await _inventorySearchService.SearchInventoriesAsync(new InventorySearchCriteria { Take = BatchSize });
var totalCount = searchResult.TotalCount;
writer.WritePropertyName("InventoriesTotalCount");
writer.WriteValue(totalCount);
writer.WritePropertyName("Inventories");
writer.WriteStartArray();
for (int i = BatchSize; i < totalCount; i += BatchSize)
{
progressInfo.Description = $"{i} of {totalCount} inventories have been loaded";
progressCallback(progressInfo);
searchResult = await _inventorySearchService.SearchInventoriesAsync(new InventorySearchCriteria { Skip = i, Take = BatchSize });
foreach (var inventory in searchResult.Results)
{
_serializer.Serialize(writer, inventory);
}
writer.Flush();
progressInfo.Description = $"{ Math.Min(totalCount, i + BatchSize) } of { totalCount } inventories exported";
progressCallback(progressInfo);
}
writer.WriteEndArray();
writer.WriteEndObject();
writer.Flush();
}
}
public override void Post(HttpRequest Request, HttpResponse Response, params string[] PathParams)
{
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.Cache.SetMaxAge(TimeSpan.Zero);
JObject inputData = null;
try
{
using (StreamReader reader = new StreamReader(Request.InputStream))
{
using (JsonTextReader jsonReader = new JsonTextReader(reader))
{
inputData = JObject.Load(jsonReader);
}
}
}
catch
{
RespondBadRequest(Response);
}
Response.ContentType = @"application/json";
Int64 SupplierId;
if (IsAuthorizedRequestSupplier(Request, Response, true, out SupplierId))
{
JToken jt;
Int64 BidId = 0;
decimal total_price = 0;
string gift = null, supplier_remarks = null;
bool is_service = false;
if (inputData.TryGetValue(@"bid_id", out jt))
{
BidId = jt.Value <Int64>();
}
if (inputData.TryGetValue(@"total_price", out jt))
{
total_price = jt.Value <decimal>();
}
if (inputData.TryGetValue(@"gift", out jt))
{
gift = jt.Value <string>();
}
if (inputData.TryGetValue(@"supplier_remarks", out jt))
{
supplier_remarks = Regex.Replace(jt.Value <string>(), @"\p{Cs}", "");
}
;
if (inputData.TryGetValue(@"is_service", out jt))
{
is_service = jt.Value <bool>();
}
using (StreamWriter streamWriter = new StreamWriter(Response.OutputStream))
{
using (JsonTextWriter jsonWriter = new JsonTextWriter(streamWriter))
{
if (is_service)
{
OfferService offer = OfferService.FetchByBidIdAndSupplierId(BidId, SupplierId);
if (offer != null)
{
RespondError(Response, HttpStatusCode.Found, "offer-already-exists");
}
BidService b = BidService.FetchByID(BidId);
if (b != null && b.EndDate <= DateTime.UtcNow)
{
RespondError(Response, HttpStatusCode.BadRequest, "bid-expiry-date");
}
offer = new OfferService();
offer.BidId = BidId;
offer.CreateDate = DateTime.UtcNow;
offer.SupplierRemarks = supplier_remarks;
offer.Price = total_price;
offer.SupplierId = SupplierId;
offer.Save();
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName(@"offer_id");
jsonWriter.WriteValue(offer.OfferId);
jsonWriter.WriteEndObject();
}
else if (total_price > 0)
{
Offer offer = Offer.FetchByBidIdAndSupplierId(BidId, SupplierId);
if (offer != null)
{
RespondError(Response, HttpStatusCode.Found, "offer-already-exists");
}
Bid b = Bid.FetchByID(BidId);
if (b != null && b.EndDate <= DateTime.UtcNow)
{
RespondError(Response, HttpStatusCode.BadRequest, "bid-expiry-date");
}
offer = new Offer();
offer.BidId = BidId;
offer.CreateDate = DateTime.UtcNow;
offer.Gift = gift;
offer.Price = total_price;
offer.SupplierId = SupplierId;
offer.Save();
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName(@"offer_id");
jsonWriter.WriteValue(offer.OfferId);
jsonWriter.WriteEndObject();
}
else
{
RespondError(Response, HttpStatusCode.BadRequest, @"price-zero");
}
}
}
}
}
private void buttonImportCatalog_Click(object sender, EventArgs e)
{
// 把内容写入到数据库
if (treeViewCatalog.Nodes.Count == 0)
{
return;
}
try
{
UserCatalog config = new UserCatalog();
Queue <TreeNode> nodesList = new Queue <TreeNode>();
nodesList.Enqueue(treeViewCatalog.Nodes[0]);
while (nodesList.Count > 0)
{
TreeNode currentNode = nodesList.Dequeue();
currentNode.Tag = currentNode.Text;
if (currentNode.Parent != null)
{
currentNode.Tag = currentNode.Parent.Tag as string + "." + currentNode.Text;
}
string[] nodeValue = currentNode.Text.Split(':');
if (nodeValue.Length == 3)
{
string strKeyValue = currentNode.Parent.Tag as string;
if (!config.catalogs.ContainsKey(strKeyValue))
{
config.catalogs[strKeyValue] = new List <CatalogItem>();
}
config.catalogs[strKeyValue].Add(
new CatalogItem
{
name = nodeValue[0],
value = nodeValue[1],
index = Convert.ToInt32(nodeValue[2])
});
}
else
{
config.catalogs.Add(currentNode.Tag as string, new List <CatalogItem>());
}
foreach (TreeNode v in currentNode.Nodes)
{
nodesList.Enqueue(v);
}
}
StringWriter sw = new StringWriter();
JsonWriter writer = new JsonTextWriter(sw);
writer.WriteStartObject();
foreach (var item in config.catalogs)
{
writer.WritePropertyName(StringToUnicode(item.Key));
writer.WriteStartArray();
if (item.Value.Count != 0)
{
foreach (var childItem in item.Value)
{
writer.WriteStartArray();
writer.WriteValue(StringToUnicode(childItem.name));
writer.WriteValue(childItem.value);
writer.WriteValue(childItem.index);
writer.WriteEndArray();
}
}
writer.WriteEndArray();
}
writer.WriteEndObject();
writer.Flush();
string strJson = sw.ToString();
if (!string.IsNullOrEmpty(strJson))
{
strJson = strJson.Replace("\\\\", "\\");
string sql = "update preferences set val='{0}' where key='user_categories'";
SQLiteCommand command = new SQLiteCommand(string.Format(sql, strJson), m_dbConnection);
command.ExecuteNonQuery();
}
}
catch (Exception ex)
{
}
}
public override void Get(HttpRequest Request, HttpResponse Response, params string[] PathParams)
{
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.Cache.SetMaxAge(TimeSpan.Zero);
try
{
Int64 SupplierId;
if (IsAuthorizedRequestSupplier(Request, Response, true, out SupplierId))
{
Response.ContentType = @"application/json";
using (StreamWriter streamWriter = new StreamWriter(Response.OutputStream))
{
using (JsonTextWriter jsonWriter = new JsonTextWriter(streamWriter))
{
Int64 BidId = Request.QueryString["bid_id"] != null?Convert.ToInt64(Request.QueryString["bid_id"]) : 0;
bool IsService = Request.QueryString["is_service"] != null?Convert.ToBoolean(Request.QueryString["is_service"]) : false;
MainBid mainBid = IsService ? SupplierController.GetNewServiceBidById(BidId, SupplierId) : SupplierController.GetNewBidById(BidId, SupplierId);
if (mainBid != null)
{
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName(@"bid_id");
jsonWriter.WriteValue(mainBid.BidId);
jsonWriter.WritePropertyName(@"end_time");
jsonWriter.WriteValue(mainBid.EndBid);
jsonWriter.WritePropertyName(@"city");
jsonWriter.WriteValue(mainBid.City);
jsonWriter.WritePropertyName(@"products");
jsonWriter.WriteStartArray();
string strGift = "";
decimal totalPrice = 0;
if (mainBid.LstProduct != null && mainBid.LstProduct.Count > 0)
{
foreach (BidProductUI item in mainBid.LstProduct)
{
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName(@"product_id");
jsonWriter.WriteValue(item.ProductId);
jsonWriter.WritePropertyName(@"product_name");
jsonWriter.WriteValue(item.ProductName);
jsonWriter.WritePropertyName(@"product_amount");
jsonWriter.WriteValue(item.ProductAmount);
jsonWriter.WritePropertyName(@"product_image");
jsonWriter.WriteValue(item.ProductImage);
jsonWriter.WritePropertyName(@"order_amount");
jsonWriter.WriteValue(item.Amount);
jsonWriter.WritePropertyName(@"product_price");
jsonWriter.WriteValue(item.Price * item.Amount);
strGift += (item.ProductGift != null && item.ProductGift.Trim() != "" ? item.ProductGift + ", " : "");
totalPrice += item.Price * item.Amount;
jsonWriter.WriteEndObject();
}
}
jsonWriter.WriteEndArray();
jsonWriter.WritePropertyName(@"total_price");
jsonWriter.WriteValue(totalPrice);
int index = strGift.LastIndexOf(",");
if (index > 0)
{
strGift = strGift.Substring(0, index);
}
jsonWriter.WritePropertyName(@"gift");
jsonWriter.WriteValue(strGift);
jsonWriter.WritePropertyName(@"customer_comment");
jsonWriter.WriteValue(mainBid.CustomerComment);
jsonWriter.WritePropertyName(@"service_name");
jsonWriter.WriteValue(mainBid.ServiceName);
jsonWriter.WritePropertyName(@"service_id");
jsonWriter.WriteValue(mainBid.ServiceId);
jsonWriter.WriteEndObject();
}
else
{
RespondError(Response, HttpStatusCode.BadRequest, "bid-expiry-date");
}
}
}
}
}
catch (Exception) { }
}
public void saveJson(JsonTextWriter writer)
{
//添加modbusmaster节点
ModbusMasterManage master = masterManage;
if (master.modbusMastrList.Count > 0)
{
writer.WritePropertyName("mbserial_master");
writer.WriteStartObject(); //添加{ master节点
writer.WritePropertyName("number");
writer.WriteValue(masterManage.modbusMastrList.Count); //number
writer.WritePropertyName("time_uint");
writer.WriteValue("ms"); //时间单位
int index = 0;
writer.WritePropertyName("conf");
writer.WriteStartArray(); //[ master节点下conf数组
for (int i = 0; i < masterManage.modbusMastrList.Count; i++) //遍历所有Client的集合
{
ModbusMasterData data = masterManage.modbusMastrList.ElementAt(i);
writer.WriteStartObject();//{ master节点下device
writer.WritePropertyName("port");
if (data.transformChannel == "COM1")
{
writer.WriteValue("ser_port7");
}
else if (data.transformChannel == "COM2")
{
writer.WriteValue("ser_port1");
}
else if (data.transformChannel == "COM3")
{
writer.WriteValue("ser_port0");
}
else if (data.transformChannel == "COM4")
{
writer.WriteValue("ser_port2");
}
else if (data.transformChannel == "COM5")
{
writer.WriteValue("ser_port3");
}
else if (data.transformChannel == "COM6")
{
writer.WriteValue("ser_port8");
}
else
{
writer.WriteValue("");
}
writer.WritePropertyName("response_timeout");
writer.WriteValue(data.responseTimeout);
writer.WritePropertyName("packet_interval");
writer.WriteValue(data.packet_interval);
string mode = null;
if (data.transformMode == 0)
{
mode = "rtu";
}
else if (data.transformMode == 1)
{
mode = "ascii";
}
writer.WritePropertyName("mode");
writer.WriteValue(mode);
writer.WritePropertyName("dev_namestr");
writer.WriteValue("mbserial" + "_master" + data.ID);
writer.WritePropertyName("slave");
writer.WriteStartObject();//{ slave节点 从设备信息
writer.WritePropertyName("num");
writer.WriteValue(data.modbusDeviceList.Count);
if (i > 0)
{
index = i * masterManage.modbusMastrList[i - 1].modbusDeviceList.Count;
}
writer.WritePropertyName("conf");
writer.WriteStartArray(); //[ slave节点conf
for (int j = 0; j < data.modbusDeviceList.Count; j++) //循环添加每个设备的各参数至
{
DeviceData dataDev = data.modbusDeviceList.ElementAt(j);
writer.WriteStartObject();//{ conf数组下节点，从设备信息
writer.WritePropertyName("slave_id");
try
{
int sid = Convert.ToInt32(dataDev.slaveAddr);
}
catch
{
return;
}
writer.WriteValue(Convert.ToInt32(dataDev.slaveAddr));
writer.WritePropertyName("timeout_cnt_max");
writer.WriteValue(dataDev.permitTimeoutCount);
writer.WritePropertyName("retry_interval");
writer.WriteValue(dataDev.reconnectInterval);
writer.WritePropertyName("io_range");
writer.WriteStartObject(); //{ conf数组下 iorange
writer.WritePropertyName("start");
writer.WriteValue(dataDev.curDeviceAddr); //io范围这块上位机设计方案中在master和client中并没有提到，需要确认
writer.WritePropertyName("bytes");
writer.WriteValue(dataDev.curDeviceLength);
writer.WriteEndObject();//} conf数组下 iorange
writer.WritePropertyName("restart_offset");
writer.WriteValue(0);
writer.WritePropertyName("channel_cfg");
writer.WriteStartObject();//{ channel_cfg节点
writer.WritePropertyName("num");
writer.WriteValue(dataDev.modbusChannelList.Count);
writer.WritePropertyName("conf");
writer.WriteStartArray(); //[ channel_cfg节点下conf数组
for (int k = 0; k < dataDev.modbusChannelList.Count; k++) //循环添加通道至子设备节点下
{
ChannelData dataChannel = dataDev.modbusChannelList.ElementAt(k);
writer.WriteStartObject();//{ channel_cfg节点下conf数组中channel信息
writer.WritePropertyName("channel_id");
writer.WriteValue(dataChannel.ID);
writer.WritePropertyName("channel" + dataChannel.ID);
writer.WriteValue(dataChannel.nameChannel);
writer.WritePropertyName("msg_type");
writer.WriteValue(dataChannel.msgType);
writer.WritePropertyName("trig_mode");//trig_mode的含义？？
writer.WriteValue(dataChannel.trig_mode);
writer.WritePropertyName("polling_time");
writer.WriteValue(dataChannel.pollingTime);
writer.WritePropertyName("offset");//偏移这块和我们上位机草图设计有一些出入，需要确认
writer.WriteValue(dataChannel.readOffset);
writer.WritePropertyName("quantity");
writer.WriteValue(dataChannel.readLength);
writer.WritePropertyName("io_offset");
writer.WriteValue(dataChannel.curChannelAddr + 3 - dataDev.curDeviceAddr);
writer.WritePropertyName("io_bytes");
writer.WriteValue(dataChannel.curChannelLength - 3);
writer.WritePropertyName("trigger_offset");
writer.WriteValue(dataChannel.curChannelAddr - dataDev.curDeviceAddr);
writer.WritePropertyName("error_offset");
writer.WriteValue(dataChannel.curChannelAddr + 1 - dataDev.curDeviceAddr);
writer.WritePropertyName("direction"); //direction参数的含义？？
writer.WriteValue("in");
writer.WriteEndObject(); //} channel_cfg节点下conf数组中channel信息
}
writer.WriteEndArray(); //] channel_cfg节点下conf数组
writer.WriteEndObject(); //} channel_cfg节点
writer.WriteEndObject(); //} conf数组下节点，从设备信息
}
writer.WriteEndArray(); //] slave节点conf
writer.WriteEndObject(); //} slave节点 从设备信息
writer.WriteEndObject(); //} client节点下device
}
writer.WriteEndArray(); //] client节点下conf数组
writer.WriteEndObject(); //添加} master节点
}
}
public static void SerializeMessage(JsonTextWriter writer, ServiceType type, object message)
{
Require.NotNull(writer, "writer");
Require.NotNull(type, "type");
Require.NotNull(message, "message");
writer.WriteStartObject();
foreach (var field in type.Fields.Values)
{
if (
field.ShouldSerializeMethod != null &&
!field.ShouldSerializeMethod(message)
)
continue;
writer.WritePropertyName(field.Tag.ToString(CultureInfo.InvariantCulture));
object value = field.Getter(message);
if (value == null)
{
writer.WriteNull();
}
else if (field.CollectionType != null)
{
writer.WriteStartArray();
foreach (object item in (IEnumerable)value)
{
if (field.ServiceType != null && !field.ServiceType.Type.IsEnum)
SerializeMessage(writer, field.ServiceType, item);
else
writer.WriteValue(item);
}
writer.WriteEndArray();
}
else
{
if (field.ServiceType != null && !field.ServiceType.Type.IsEnum)
SerializeMessage(writer, field.ServiceType, value);
else
writer.WriteValue(value);
}
}
writer.WriteEndObject();
}
internal void Write(JsonTextWriter jsonWriter)
{
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyValue("index", Index);
if (unknown.Count != 0)
{
jsonWriter.WritePropertyName("unknown");
jsonWriter.WriteStartObject();
foreach (var el in unknown)
{
jsonWriter.WritePropertyValue(Encoders.Hex.EncodeData(el.Key), Encoders.Hex.EncodeData(el.Value));
}
jsonWriter.WriteEndObject();
}
jsonWriter.WritePropertyName("partial_signatures");
jsonWriter.WriteStartObject();
foreach (var sig in partial_sigs)
{
jsonWriter.WritePropertyValue(sig.Key.ToString(), Encoders.Hex.EncodeData(sig.Value.ToBytes()));
}
jsonWriter.WriteEndObject();
if (SighashType is SigHash s)
{
jsonWriter.WritePropertyValue("sighash", GetName(s));
}
if (this.FinalScriptSig != null)
{
jsonWriter.WritePropertyValue("final_script_sig", FinalScriptSig.ToString());
}
if (this.FinalScriptWitness != null)
{
jsonWriter.WritePropertyValue("final_script_witness", FinalScriptWitness.ToString());
}
if (this.redeem_script != null)
{
jsonWriter.WritePropertyValue("redeem_script", redeem_script.ToString());
}
if (this.witness_script != null)
{
jsonWriter.WritePropertyValue("witness_script", witness_script.ToString());
}
if (this.NonWitnessUtxo != null)
{
jsonWriter.WritePropertyName("non_witness_utxo");
jsonWriter.WriteStartObject();
var formatter = new RPC.BlockExplorerFormatter();
formatter.WriteTransaction2(jsonWriter, NonWitnessUtxo);
jsonWriter.WriteEndObject();
}
if (this.WitnessUtxo != null)
{
jsonWriter.WritePropertyName("witness_utxo");
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyValue("value", WitnessUtxo.Value.ToString(false, false));
jsonWriter.WritePropertyValue("scriptPubKey", WitnessUtxo.ScriptPubKey.ToString());
jsonWriter.WriteEndObject();
}
jsonWriter.WriteBIP32Derivations(this.hd_keypaths);
jsonWriter.WriteEndObject();
}
public static string ToJson(this Person p)
{
StringWriter sw = new StringWriter();
JsonTextWriter writer = new JsonTextWriter(sw);
// {
writer.WriteStartObject();
// "name" : "Jerry"
writer.WritePropertyName("name");
writer.WriteValue(p.Name);
// "likes": ["Comedy", "Superman"]
writer.WritePropertyName("likes");
writer.WriteStartArray();
foreach (string like in p.Likes)
{
writer.WriteValue(like);
}
writer.WriteEndArray();
// }
writer.WriteEndObject();
return sw.ToString();
}
public static DataListFormat RunCoverageAndReturnJSON(this ICoverageDataObject coverageData, ITestCoverageCatalog testCoverageCatalog, ITestCatalog testCatalog, IResourceCatalog catalog, Guid workspaceGuid, Dev2JsonSerializer serializer, out string executePayload)
{
var warewolfWorkflowReports = RunListOfCoverage(coverageData, testCoverageCatalog, testCatalog, workspaceGuid, catalog);
var allTestResults = warewolfWorkflowReports.AllTestResults;
var allCoverageReports = warewolfWorkflowReports.AllCoverageReports;
var formatter = DataListFormat.CreateFormat("JSON", EmitionTypes.JSON, "application/json");
var objArray = allCoverageReports
.Select(o =>
{
var name = o.Resource.ResourceName;
if (o.Resource is IFilePathResource filePath)
{
name = filePath.Path;
}
return(new JObject
{
{ "ResourceID", o.Resource.ResourceID },
{ "Name", name },
{ "Reports", new JArray(o.Reports.Select(o1 => o1.BuildTestResultJSONForWebRequest())) }
});
});
var resultCoverageSummaryWriter = new StringWriter();
using (var writer = new JsonTextWriter(resultCoverageSummaryWriter))
{
var totalNodes = warewolfWorkflowReports.TotalWorkflowNodesCount;
var coveredNodes = warewolfWorkflowReports.TotalWorkflowNodesCoveredCount;
var notCoveredNodes = totalNodes - coveredNodes;
writer.WriteStartObject();
writer.WritePropertyName("TotalNodes");
writer.WriteValue(totalNodes);
writer.WritePropertyName("CoveredNodes");
writer.WriteValue(coveredNodes);
writer.WritePropertyName("NotCoveredNodes");
writer.WriteValue(notCoveredNodes);
writer.WritePropertyName("TotalCoverage");
writer.WriteValueAsync(warewolfWorkflowReports.TotalWorkflowNodesCoveredPercentage);
writer.WriteEndObject();
}
var resultSummaryWriter = new StringWriter();
var reportName = coverageData.ReportName;
if (!string.IsNullOrEmpty(reportName) && reportName != "*")
{
using (var writer = new JsonTextWriter(resultSummaryWriter))
{
allTestResults.SetupResultSummaryJSON(writer);
}
}
else
{
using (var writer = new JsonTextWriter(resultSummaryWriter))
{
allTestResults.SetupResultSummaryJSON(writer);
}
}
var obj = new JObject
{
{ "StartTime", warewolfWorkflowReports.StartTime },
{ "EndTime", warewolfWorkflowReports.EndTime },
{ "CoverageSummary", JToken.Parse(resultCoverageSummaryWriter.ToString()) },
{ "TestSummary", JToken.Parse(resultSummaryWriter.ToString()) },
{ "TestResults", new JArray(objArray) },
};
executePayload = serializer.Serialize(obj);
return(formatter);
}
public ActionResult Sources()
{
return authenticatedAction(new String[] { "UT", "UR" }, () => {
var result = makeJSONResult();
using (JsonTextWriter w = new JsonTextWriter()) {
w.WriteStartArray();
foreach (IssueSourceLvl1 i in db.IssueSourceLvl1s.WAOBTL()) {
w.writeSharedJSONMembers(i);
w.writeSharedJSONProlog();
foreach (IssueSourceLvl2 i2 in db.IssueSourceLvl2s.Where(ti2 => ti2.parentCode == i.code).WAOBTL()) {
w.writeSharedJSONMembers(i2);
w.writeSharedJSONProlog();
foreach (IssueSourceLvl3 i3 in db.IssueSourceLvl3s
.Where(ti3 => ti3.grandparentCode == i.code)
.Where(ti3 => ti3.parentCode == i2.code)
.WAOBTL()) {
w.writeSharedJSONMembers(i3);
w.WriteEndObject();
}
w.writeSharedJSONEpilog();
}
w.writeSharedJSONEpilog();
}
w.WriteEndArray();
result.Content = w.ToString();
}
logger.Debug("TreesController.Sources accessed.");
return result;
});
}
