public async Task WriteReadWriteAsync()
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter jsonWriter = new JsonTextWriter(sw)
{
Formatting = Formatting.Indented
})
{
await jsonWriter.WriteStartArrayAsync();
await jsonWriter.WriteValueAsync(true);
await jsonWriter.WriteStartObjectAsync();
await jsonWriter.WritePropertyNameAsync("integer");
await jsonWriter.WriteValueAsync(99);
await jsonWriter.WritePropertyNameAsync("string");
await jsonWriter.WriteValueAsync("how now brown cow?");
await jsonWriter.WritePropertyNameAsync("array");
await jsonWriter.WriteStartArrayAsync();
for (int i = 0; i < 5; i++)
{
await jsonWriter.WriteValueAsync(i);
}
await jsonWriter.WriteStartObjectAsync();
await jsonWriter.WritePropertyNameAsync("decimal");
await jsonWriter.WriteValueAsync(990.00990099m);
await jsonWriter.WriteEndObjectAsync();
await jsonWriter.WriteValueAsync(5);
await jsonWriter.WriteEndArrayAsync();
await jsonWriter.WriteEndObjectAsync();
await jsonWriter.WriteValueAsync("This is a string.");
await jsonWriter.WriteNullAsync();
await jsonWriter.WriteNullAsync();
await jsonWriter.WriteEndArrayAsync();
}
string json = sb.ToString();
JsonSerializer serializer = new JsonSerializer();
object jsonObject = serializer.Deserialize(new JsonTextReader(new StringReader(json)));
sb = new StringBuilder();
sw = new StringWriter(sb);
using (JsonWriter jsonWriter = new JsonTextWriter(sw)
{
Formatting = Formatting.Indented
})
{
serializer.Serialize(jsonWriter, jsonObject);
}
Assert.AreEqual(json, sb.ToString());
}
public async Task DoExportAsync(Stream outStream, ExportImportOptions options, Action <ExportImportProgressInfo> progressCallback, ICancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var progressInfo = new ExportImportProgressInfo();
using (var sw = new StreamWriter(outStream, Encoding.UTF8))
using (var writer = new JsonTextWriter(sw))
{
await writer.WriteStartObjectAsync();
//Export menu link list
var menuLinkLists = await _menuService.GetAllLinkListsAsync();
var linkLists = menuLinkLists as IList <MenuLinkList> ?? menuLinkLists.ToList();
await writer.WritePropertyNameAsync("MenuLinkLists");
await writer.WriteStartArrayAsync();
for (var skip = 0; skip < linkLists.Count; skip += _batchSize)
{
progressInfo.Description = $"{skip} of {linkLists.Count} menu link lists have been loaded";
progressCallback(progressInfo);
foreach (var list in linkLists.Skip(skip).Take(_batchSize).ToList())
{
_jsonSerializer.Serialize(writer, list);
}
await writer.FlushAsync();
progressInfo.Description = $"{ Math.Min(linkLists.Count, skip + _batchSize) } of { linkLists.Count } menu link lists exported";
progressCallback(progressInfo);
}
await writer.WriteEndArrayAsync();
if (options.HandleBinaryData)
{
await writer.WritePropertyNameAsync("CmsContent");
await writer.WriteStartArrayAsync();
var result = await _blobContentStorageProvider.SearchAsync(string.Empty, null);
foreach (var blobFolder in result.Results.Where(x => _exportedFolders.Contains(x.Name)))
{
var contentFolder = new ContentFolder
{
Url = blobFolder.RelativeUrl
};
await ReadContentFoldersRecursiveAsync(contentFolder, progressCallback);
_jsonSerializer.Serialize(writer, contentFolder);
}
await writer.FlushAsync();
progressInfo.Description = $"{ result.TotalCount } cms content exported";
progressCallback(progressInfo);
await writer.WriteEndArrayAsync();
}
await writer.WriteEndObjectAsync();
await writer.FlushAsync();
}
}
private async Task ExportPlatformEntriesInternalAsync(ZipArchive zipArchive, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback, ICancellationToken cancellationToken)
{
var progressInfo = new ExportImportProgressInfo();
var serializer = GetJsonSerializer();
//Create part for platform entries
var platformEntiriesPart = zipArchive.CreateEntry(PlatformZipEntryName, CompressionLevel.Optimal);
using (var partStream = platformEntiriesPart.Open())
{
using (var sw = new StreamWriter(partStream, Encoding.UTF8))
using (var writer = new JsonTextWriter(sw))
{
await writer.WriteStartObjectAsync();
if (manifest.HandleSecurity)
{
progressInfo.Description = "Roles exporting...";
progressCallback(progressInfo);
cancellationToken.ThrowIfCancellationRequested();
await writer.WritePropertyNameAsync("Roles");
await writer.WriteStartArrayAsync();
var roles = _roleManager.Roles.ToList();
if (_roleManager.SupportsRoleClaims)
{
var permissions = _permissionsProvider.GetAllPermissions().ToArray();
foreach (var role in roles)
{
role.Permissions = (await _roleManager.GetClaimsAsync(role)).Join(permissions, c => c.Value, p => p.Name, (c, p) => p).ToArray();
serializer.Serialize(writer, role);
}
writer.Flush();
progressInfo.Description = $"{ roles.Count } roles exported";
progressCallback(progressInfo);
}
await writer.WriteEndArrayAsync();
cancellationToken.ThrowIfCancellationRequested();
await writer.WritePropertyNameAsync("Users");
await writer.WriteStartArrayAsync();
var usersResult = _userManager.Users.ToArray();
progressInfo.Description = $"Security: {usersResult.Length} users exporting...";
progressCallback(progressInfo);
var userExported = 0;
foreach (var user in usersResult)
{
var userExt = await _userManager.FindByIdAsync(user.Id);
if (userExt != null)
{
serializer.Serialize(writer, userExt);
userExported++;
}
}
await writer.FlushAsync();
progressInfo.Description = $"{ userExported } of { usersResult.Length } users exported";
progressCallback(progressInfo);
await writer.WriteEndArrayAsync();
}
if (manifest.HandleSettings)
{
cancellationToken.ThrowIfCancellationRequested();
await writer.WritePropertyNameAsync("Settings");
await writer.WriteStartArrayAsync();
progressInfo.Description = "Settings: selected modules settings exporting...";
progressCallback(progressInfo);
foreach (var module in manifest.Modules)
{
var moduleSettings = await _settingsManager.GetObjectSettingsAsync(_settingsManager.AllRegisteredSettings.Where(x => x.ModuleId == module.Id).Select(x => x.Name));
//Export only settings with set values
foreach (var setting in moduleSettings.Where(x => x.ItHasValues))
{
serializer.Serialize(writer, setting);
}
await writer.FlushAsync();
}
progressInfo.Description = $"Settings of modules exported";
progressCallback(progressInfo);
await writer.WriteEndArrayAsync();
}
cancellationToken.ThrowIfCancellationRequested();
await writer.WritePropertyNameAsync("DynamicProperties");
await writer.WriteStartArrayAsync();
progressInfo.Description = "Dynamic properties: load properties...";
progressCallback(progressInfo);
var dynamicProperties = (await _dynamicPropertySearchService.SearchDynamicPropertiesAsync(new DynamicPropertySearchCriteria {
Take = int.MaxValue
})).Results;
foreach (var dynamicProperty in dynamicProperties)
{
serializer.Serialize(writer, dynamicProperty);
}
progressInfo.Description = $"Dynamic properties exported";
progressCallback(progressInfo);
await writer.WriteEndArrayAsync();
cancellationToken.ThrowIfCancellationRequested();
await writer.WritePropertyNameAsync("DynamicPropertyDictionaryItems");
await writer.WriteStartArrayAsync();
progressInfo.Description = "Dynamic properties Dictionary Items: load properties...";
progressCallback(progressInfo);
var dynamicPropertyDictionaryItems = (await _dynamicPropertySearchService.SearchDictionaryItemsAsync(new DynamicPropertyDictionaryItemSearchCriteria {
Take = int.MaxValue
})).Results;
foreach (var dynamicPropertyDictionaryItem in dynamicPropertyDictionaryItems)
{
serializer.Serialize(writer, dynamicPropertyDictionaryItem);
}
progressInfo.Description = $"Dynamic properties dictionary items exported";
progressCallback(progressInfo);
await writer.WriteEndArrayAsync();
await writer.WriteEndObjectAsync();
await writer.FlushAsync();
}
}
}
private async Task <string> SerializeJsonNetManualAsync(TestClass c, Formatting formatting)
{
StringWriter sw = new StringWriter();
JsonTextWriter writer = new JsonTextWriter(sw);
writer.Formatting = formatting;
await writer.WriteStartObjectAsync();
await writer.WritePropertyNameAsync("strings");
await writer.WriteStartArrayAsync();
foreach (string s in c.strings)
{
await writer.WriteValueAsync(s);
}
await writer.WriteEndArrayAsync();
await writer.WritePropertyNameAsync("dictionary");
await writer.WriteStartObjectAsync();
foreach (KeyValuePair <string, int> keyValuePair in c.dictionary)
{
await writer.WritePropertyNameAsync(keyValuePair.Key);
await writer.WriteValueAsync(keyValuePair.Value);
}
await writer.WriteEndObjectAsync();
await writer.WritePropertyNameAsync("Name");
await writer.WriteValueAsync(c.Name);
await writer.WritePropertyNameAsync("Now");
await writer.WriteValueAsync(c.Now);
await writer.WritePropertyNameAsync("BigNumber");
await writer.WriteValueAsync(c.BigNumber);
await writer.WritePropertyNameAsync("Address1");
await writer.WriteStartObjectAsync();
await writer.WritePropertyNameAsync("Street");
await writer.WriteValueAsync(c.BigNumber);
await writer.WritePropertyNameAsync("Street");
await writer.WriteValueAsync(c.BigNumber);
await writer.WritePropertyNameAsync("Street");
await writer.WriteValueAsync(c.BigNumber);
await writer.WriteEndObjectAsync();
await writer.WritePropertyNameAsync("Addresses");
await writer.WriteStartArrayAsync();
foreach (Address address in c.Addresses)
{
await writer.WriteStartObjectAsync();
await writer.WritePropertyNameAsync("Street");
await writer.WriteValueAsync(address.Street);
await writer.WritePropertyNameAsync("Phone");
await writer.WriteValueAsync(address.Phone);
await writer.WritePropertyNameAsync("Entered");
await writer.WriteValueAsync(address.Entered);
await writer.WriteEndObjectAsync();
}
await writer.WriteEndArrayAsync();
await writer.WriteEndObjectAsync();
await writer.FlushAsync();
return(sw.ToString());
}
public async Task WriteAsync(IEnumerable <StreamEvent> events, CancellationToken cancellationToken = default)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
const int requires400Mb = 419_430_400;
using (var content = _manager.GetStream(nameof(LegacyStreamArchiveWriter), requires400Mb))
{
using (var archive = new ZipArchive(content, ZipArchiveMode.Create, true))
{
var entry = archive.CreateEntry("streams.json", CompressionLevel.Optimal);
using (var entryStream = entry.Open())
using (var writer = new JsonTextWriter(new StreamWriter(entryStream)))
{
await writer.WriteStartArrayAsync(cancellationToken);
using (var enumerator = events.GetEnumerator())
{
if (enumerator.MoveNext())
{
var stream = enumerator.Current.Stream;
await WriteBeginStream(stream, writer, cancellationToken);
await WriteEvent(enumerator.Current.Event, writer, cancellationToken);
while (enumerator.MoveNext())
{
// next
if (stream != enumerator.Current.Stream)
{
await WriteEndStream(writer);
stream = enumerator.Current.Stream;
await WriteBeginStream(stream, writer, cancellationToken);
}
await WriteEvent(enumerator.Current.Event, writer, cancellationToken);
}
await WriteEndStream(writer);
}
}
await writer.WriteEndArrayAsync(cancellationToken);
await writer.FlushAsync(cancellationToken);
}
}
content.Position = 0;
await _client.CreateBlobAsync(
new BlobName("import-streams.zip"),
Metadata.None,
ContentType.Parse("application/zip"),
content,
cancellationToken);
}
}
private static async Task ReturnSearchResult(SearchResult result, HttpContext ctx)
{
var ct = ctx.RequestAborted;
ctx.Response.StatusCode = (int)HttpStatusCode.OK;
ctx.Response.ContentType = "application/json";
using (var writer = new JsonTextWriter(new StreamWriter(ctx.Response.Body)))
{
await writer.WriteStartObjectAsync(ct).ConfigureAwait(false);
await writer.WritePropertyNameAsync("totalCount", ct).ConfigureAwait(false);
await writer.WriteValueAsync(result.Total, ct).ConfigureAwait(false);
await writer.WritePropertyNameAsync("elapsed", ct).ConfigureAwait(false);
await writer.WriteValueAsync(result.Elapsed, ct).ConfigureAwait(false);
await writer.WritePropertyNameAsync("results", ct).ConfigureAwait(false);
await writer.WriteStartArrayAsync(ct).ConfigureAwait(false);
foreach (var document in result)
{
if (ct.IsCancellationRequested)
{
return;
}
var obj = document.GroupBy(x => x.Key);
await writer.WriteStartObjectAsync(ct).ConfigureAwait(false);
foreach (var p in obj)
{
await writer.WritePropertyNameAsync(p.Key, ct).ConfigureAwait(false);
var values = p.ToArray();
if (values.Length == 0)
{
await writer.WriteNullAsync(ct).ConfigureAwait(false);
}
else if (values.Length == 1)
{
await writer.WriteValueAsync(values[0].Value, ct).ConfigureAwait(false);
}
else
{
await writer.WriteStartArrayAsync(ct).ConfigureAwait(false);
foreach (var v in values)
{
await writer.WriteValueAsync(v.Value, ct).ConfigureAwait(false);
}
await writer.WriteEndArrayAsync(ct).ConfigureAwait(false);
}
}
await writer.WriteEndObjectAsync(ct).ConfigureAwait(false);
}
await writer.WriteEndArrayAsync(ct).ConfigureAwait(false);
await writer.WriteEndObjectAsync(ct).ConfigureAwait(false);
}
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "{datasetname}")] HttpRequest req,
string datasetname,
ILogger log, ExecutionContext context)
{
var baseconfig = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
var configOptions = new ConfigurationOptions();
baseconfig.Bind("AzureTableSchema", configOptions);
if (configOptions.Environment == null || configOptions.Environment == "")
{
configOptions.Environment = baseconfig["ASPNETCORE_ENVIRONMENT"];
}
if (configOptions.ConnectionString == null || configOptions.ConnectionString == "")
{
log.LogError($"ConnectionString is not specified");
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("{ 'error': 'service misconfiguration' }")
});
}
Configuration configuration = new Configuration(configOptions);
string datasetconfigStr = null;
try
{
datasetconfigStr = await configuration.GetConfigurationAsync(datasetname);
} catch (Exception e)
{
log.LogError(e, $"Unable to query config string with key '{datasetname}'");
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("{ 'error': 'dataset not found' }")
});
}
if (datasetconfigStr == null)
{
log.LogError($"Unable to find config string with key '{datasetname}'");
return(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent("{ 'error': 'dataset not found' }")
});
}
AzureTableSchema schema = null;
try
{
schema = JsonConvert.DeserializeObject <AzureTableSchema>(datasetconfigStr, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Include
});
} catch (Exception e)
{
log.LogError(e, $"Unable to deserialize config string with key '{datasetname}'");
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent("{ 'error': 'service misconfiguration' }")
});
}
// starting with result.
var result = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new PushStreamContent(async(outputStream, httpContext, transportContext) =>
{
// Add query parameters passby
// https://benjii.me/2017/04/parse-modify-query-strings-asp-net-core/
var uri = new Uri(schema.SourceUrl);
var baseUri = uri.GetComponents(UriComponents.Scheme | UriComponents.Host | UriComponents.Port | UriComponents.Path, UriFormat.UriEscaped);
var query = QueryHelpers.ParseQuery(uri.Query);
var qb = new QueryBuilder();
foreach (var item in query)
{
qb.Add(item.Key, item.Value.AsEnumerable());
}
List <string> allowedParameters = new List <string>()
{
"$filter", "$orderby", "$select", "$skip", "$top"
};
foreach (var item in req.Query)
{
if (allowedParameters.Contains(item.Key) && !query.ContainsKey(item.Key)) // do not allow to overwrite existing values
{
qb.Add(item.Key, item.Value.AsEnumerable());
}
}
var targetUrl = baseUri + qb.ToQueryString();
//HttpRequestMessage r = new HttpRequestMessage(HttpMethod.Get, schema.SourceUrl);
HttpRequestMessage r = new HttpRequestMessage(HttpMethod.Get, targetUrl);
r.Headers.Add("Accept", "application / json; odata = nometadata");
// TODO: Add request query string parameters to request
var response = await httpClient.SendAsync(r);
var serializer = new JsonSerializer();
//var ss = new StringBuilder();
bool inValueArray = false;
string lastPropertyName = "";
using (var sr = new StreamReader(await response.Content.ReadAsStreamAsync(), new UTF8Encoding(), false))
using (var jsonTextReader = new JsonTextReader(sr))
using (JsonWriter writer = new JsonTextWriter(new StreamWriter(outputStream, new UTF8Encoding(), 512, false)))
{
while (jsonTextReader.Read())
{
if (!inValueArray)
{
if (jsonTextReader.TokenType == JsonToken.PropertyName)
{
lastPropertyName = jsonTextReader.Value.ToString();
}
else if (jsonTextReader.TokenType == JsonToken.StartArray && lastPropertyName == "value")
{
inValueArray = true;
// write object beginning and such..
await writer.WriteStartObjectAsync();
await writer.WritePropertyNameAsync("value");
await writer.WriteStartArrayAsync();
}
}
else
{
if (jsonTextReader.TokenType == JsonToken.StartObject) // read entire object
{
JObject obj = JObject.Load(jsonTextReader);
// add missing columns
if (schema.AddMissing)
{
foreach (var item in schema.Columns)
{
if (!obj.ContainsKey(item.Key))
{
obj.Add(item.Key, item.Value.Default);
}
}
}
// remove unspecified columns
if (schema.RemoveUnspecified)
{
var props = obj.Properties().Select(a => a.Name).ToList();
foreach (var item in props)
{
if (!schema.Columns.ContainsKey(item))
{
obj.Remove(item);
}
}
}
var objstr = JsonConvert.SerializeObject(obj,
new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Include,
Formatting = Formatting.None
}
);
log.LogInformation(objstr);
await writer.WriteRawValueAsync(objstr);
await writer.FlushAsync();
}
else if (jsonTextReader.TokenType == JsonToken.EndArray)
{
await writer.WriteEndArrayAsync();
await writer.WriteEndObjectAsync();
inValueArray = false;
}
}
}
}
outputStream.Close();
}),
};
result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = $"{datasetname}.json"
};
return(result);
}
public static Func <RequestDelegate, RequestDelegate> Create(
Index index,
string identityField,
Func <string, IEnumerable <KeyValuePair <string, string> > > transform)
{
return(next => async ctx =>
{
if (ctx.Request.Path.HasValue)
{
var id = ctx.Request.Path.Value.Substring(1);
if ("GET".Equals(ctx.Request.Method, StringComparison.OrdinalIgnoreCase))
{
var obj = index.GetByTerm(identityField, id);
if (obj == null)
{
await next(ctx).ConfigureAwait(false);
return;
}
var ct = ctx.RequestAborted;
ctx.Response.StatusCode = (int)HttpStatusCode.OK;
ctx.Response.ContentType = "application/json";
using (var writer = new JsonTextWriter(new StreamWriter(ctx.Response.Body)))
{
await writer.WriteStartObjectAsync(ct).ConfigureAwait(false);
foreach (var p in obj.GroupBy(x => x.Key))
{
await writer.WritePropertyNameAsync(p.Key, ct).ConfigureAwait(false);
var values = p.ToArray();
if (values.Length == 0)
{
await writer.WriteNullAsync(ct).ConfigureAwait(false);
}
else if (values.Length == 1)
{
await writer.WriteValueAsync(values[0].Value, ct).ConfigureAwait(false);
}
else
{
await writer.WriteStartArrayAsync(ct).ConfigureAwait(false);
foreach (var v in values)
{
await writer.WriteValueAsync(v.Value, ct).ConfigureAwait(false);
}
await writer.WriteEndArrayAsync(ct).ConfigureAwait(false);
}
}
await writer.WriteEndObjectAsync(ct).ConfigureAwait(false);
}
}
else if ("PUT".Equals(ctx.Request.Method, StringComparison.OrdinalIgnoreCase))
{
var stream = new StreamReader(ctx.Request.Body);
var json = await stream.ReadToEndAsync().ConfigureAwait(false);
index.UpdateByTerm(identityField, id, transform(json));
ctx.Response.StatusCode = (int)HttpStatusCode.OK;
}
else if ("POST".Equals(ctx.Request.Method, StringComparison.OrdinalIgnoreCase))
{
if (index.GetByTerm(identityField, id) != null)
{
ctx.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
var stream = new StreamReader(ctx.Request.Body);
var json = await stream.ReadToEndAsync().ConfigureAwait(false);
index.LoadDocuments(new[] { transform(json) });
ctx.Response.StatusCode = (int)HttpStatusCode.Created;
}
else if ("DELETE".Equals(ctx.Request.Method, StringComparison.OrdinalIgnoreCase))
{
index.DeleteByTerm(identityField, id);
}
else
{
ctx.Response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
ctx.Response.ContentType = "application/json";
ctx.Response.Headers["Allow"] = "GET,PUT,POST,DELETE";
await ctx.Response.WriteAsync("\"Method Not Allowed\"", ctx.RequestAborted).ConfigureAwait(false);
return;
}
}
else
{
await next(ctx).ConfigureAwait(false);
}
});
}
public async Task DoExportAsync(Stream backupStream, Action <ExportImportProgressInfo> progressCallback,
ICancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var progressInfo = new ExportImportProgressInfo("Starting data export");
progressCallback(progressInfo);
using (var streamWriter = new StreamWriter(backupStream, Encoding.UTF8))
using (var jsonTextWriter = new JsonTextWriter(streamWriter))
{
await jsonTextWriter.WriteStartObjectAsync();
var paymentPlanSearchResponse = await _paymentPlanSearchService.SearchPlansAsync(new PaymentPlanSearchCriteria { Take = 0 });
await jsonTextWriter.WritePropertyNameAsync("PaymentPlans");
await jsonTextWriter.WriteStartArrayAsync();
for (var skip = 0; skip < paymentPlanSearchResponse.TotalCount; skip += BatchSize)
{
cancellationToken.ThrowIfCancellationRequested();
paymentPlanSearchResponse = await _paymentPlanSearchService.SearchPlansAsync(new PaymentPlanSearchCriteria
{
Skip = skip,
Take = BatchSize
});
progressInfo.Description = string.Format("{0} of {1} payment plans loading", Math.Min(skip + BatchSize, paymentPlanSearchResponse.TotalCount), paymentPlanSearchResponse.TotalCount);
progressCallback(progressInfo);
foreach (var paymentPlan in paymentPlanSearchResponse.Results)
{
_jsonSerializer.Serialize(jsonTextWriter, paymentPlan);
}
}
await jsonTextWriter.WriteEndArrayAsync();
var searchResponse = await _subscriptionSearchService.SearchSubscriptionsAsync(new SubscriptionSearchCriteria
{
Take = 0,
ResponseGroup = SubscriptionResponseGroup.Default.ToString()
});
await jsonTextWriter.WritePropertyNameAsync("Subscriptions");
await jsonTextWriter.WriteStartArrayAsync();
for (var skip = 0; skip < searchResponse.TotalCount; skip += BatchSize)
{
cancellationToken.ThrowIfCancellationRequested();
searchResponse = await _subscriptionSearchService.SearchSubscriptionsAsync(new SubscriptionSearchCriteria
{
Skip = skip,
Take = BatchSize,
ResponseGroup = SubscriptionResponseGroup.Default.ToString()
});
progressInfo.Description = string.Format("{0} of {1} subscriptions loading", Math.Min(skip + BatchSize, searchResponse.TotalCount), searchResponse.TotalCount);
progressCallback(progressInfo);
foreach (var subscription in searchResponse.Results)
{
_jsonSerializer.Serialize(jsonTextWriter, subscription);
}
}
await jsonTextWriter.WriteEndArrayAsync();
await jsonTextWriter.WriteEndObjectAsync();
await jsonTextWriter.FlushAsync();
}
}
/// <summary>
/// Write rows to GeoJson stream
/// </summary>
/// <param name="rows">transformalize rows</param>
public void Write(IEnumerable <IRow> rows)
{
var textWriter = new StreamWriter(_stream);
var jw = new JsonTextWriter(textWriter);
jw.WriteStartObjectAsync().ConfigureAwait(false); //root
jw.WritePropertyNameAsync("type").ConfigureAwait(false);
jw.WriteValueAsync("FeatureCollection").ConfigureAwait(false);
jw.WritePropertyNameAsync("features").ConfigureAwait(false);
jw.WriteStartArrayAsync().ConfigureAwait(false); //features
foreach (var row in rows)
{
jw.WriteStartObjectAsync().ConfigureAwait(false); //feature
jw.WritePropertyNameAsync("type").ConfigureAwait(false);
jw.WriteValueAsync("Feature").ConfigureAwait(false);
jw.WritePropertyNameAsync("geometry").ConfigureAwait(false);
jw.WriteStartObjectAsync().ConfigureAwait(false); //geometry
jw.WritePropertyNameAsync("type").ConfigureAwait(false);
jw.WriteValueAsync("Point").ConfigureAwait(false);
jw.WritePropertyNameAsync("coordinates").ConfigureAwait(false);
jw.WriteStartArrayAsync().ConfigureAwait(false);
jw.WriteValueAsync(row[_longitudeField]).ConfigureAwait(false);
jw.WriteValueAsync(row[_latitudeField]).ConfigureAwait(false);
jw.WriteEndArrayAsync().ConfigureAwait(false);
jw.WriteEndObjectAsync().ConfigureAwait(false); //geometry
jw.WritePropertyNameAsync("properties").ConfigureAwait(false);
jw.WriteStartObjectAsync().ConfigureAwait(false); //properties
jw.WritePropertyNameAsync("description").ConfigureAwait(false);
if (_hasDescription)
{
jw.WriteValueAsync(row[_descriptionField]).ConfigureAwait(false);
}
else
{
jw.WriteValueAsync("add geojson-description to output").ConfigureAwait(false);
}
if (_hasBatchValue)
{
jw.WritePropertyNameAsync("batch-value").ConfigureAwait(false);
jw.WriteValueAsync(row[_batchField]).ConfigureAwait(false);
}
if (_hasColor)
{
jw.WritePropertyNameAsync("marker-color").ConfigureAwait(false);
jw.WriteValueAsync(row[_colorField]).ConfigureAwait(false);
}
if (_hasSymbol)
{
var symbol = row[_symbolField].ToString();
jw.WritePropertyNameAsync("marker-symbol").ConfigureAwait(false);
jw.WriteValueAsync(symbol).ConfigureAwait(false);
}
jw.WriteEndObjectAsync().ConfigureAwait(false); //properties
jw.WriteEndObjectAsync().ConfigureAwait(false); //feature
_context.Entity.Inserts++;
jw.FlushAsync().ConfigureAwait(false);
}
jw.WriteEndArrayAsync().ConfigureAwait(false); //features
jw.WriteEndObjectAsync().ConfigureAwait(false); //root
jw.FlushAsync().ConfigureAwait(false);
}
/// <summary>
/// Write rows to as GeoJson to a stream
/// </summary>
/// <param name="rows"></param>
public void Write(IEnumerable <IRow> rows)
{
var textWriter = new StreamWriter(_stream);
var jw = new JsonTextWriter(textWriter);
jw.WriteStartObjectAsync().ConfigureAwait(false); //root
jw.WritePropertyNameAsync("type").ConfigureAwait(false);
jw.WriteValueAsync("FeatureCollection").ConfigureAwait(false);
jw.WritePropertyNameAsync("features").ConfigureAwait(false);
jw.WriteStartArrayAsync().ConfigureAwait(false); //features
var tableBuilder = new StringBuilder();
foreach (var row in rows)
{
jw.WriteStartObjectAsync().ConfigureAwait(false); //feature
jw.WritePropertyNameAsync("type").ConfigureAwait(false);
jw.WriteValueAsync("Feature").ConfigureAwait(false);
jw.WritePropertyNameAsync("geometry").ConfigureAwait(false);
jw.WriteStartObjectAsync().ConfigureAwait(false); //geometry
jw.WritePropertyNameAsync("type").ConfigureAwait(false);
jw.WriteValueAsync("Point").ConfigureAwait(false);
jw.WritePropertyNameAsync("coordinates").ConfigureAwait(false);
jw.WriteStartArrayAsync().ConfigureAwait(false);
jw.WriteValueAsync(row[_longitudeField]).ConfigureAwait(false);
jw.WriteValueAsync(row[_latitudeField]).ConfigureAwait(false);
jw.WriteEndArrayAsync().ConfigureAwait(false);
jw.WriteEndObjectAsync().ConfigureAwait(false); //geometry
jw.WritePropertyNameAsync("properties").ConfigureAwait(false);
jw.WriteStartObjectAsync().ConfigureAwait(false); //properties
foreach (var field in _propertyFields)
{
jw.WritePropertyNameAsync(field.Label).ConfigureAwait(false);
jw.WriteValueAsync(field.Format == string.Empty ? row[field] : string.Format(string.Concat("{0:", field.Format, "}"), row[field])).ConfigureAwait(false);
}
jw.WritePropertyNameAsync("description").ConfigureAwait(false);
tableBuilder.Clear();
tableBuilder.AppendLine("<table class=\"table table-striped table-condensed\">");
foreach (var field in _propertyFields.Where(f => f.Alias != "BatchValue"))
{
tableBuilder.AppendLine("<tr>");
tableBuilder.AppendLine("<td><strong>");
tableBuilder.AppendLine(field.Label);
tableBuilder.AppendLine(":</strong></td>");
tableBuilder.AppendLine("<td>");
tableBuilder.AppendLine(field.Raw ? row[field].ToString() : System.Security.SecurityElement.Escape(row[field].ToString()));
tableBuilder.AppendLine("</td>");
tableBuilder.AppendLine("</tr>");
}
tableBuilder.AppendLine("</table>");
jw.WriteValueAsync(tableBuilder.ToString()).ConfigureAwait(false);
if (_hasStyle)
{
if (_colorField != null)
{
jw.WritePropertyNameAsync("marker-color").ConfigureAwait(false);
var color = row[_colorField].ToString().TrimStart('#').Right(6);
jw.WriteValueAsync("#" + (color.Length == 6 ? color : "0080ff")).ConfigureAwait(false);
}
if (_sizeField != null)
{
jw.WritePropertyNameAsync("marker-size").ConfigureAwait(false);
var size = row[_sizeField].ToString().ToLower();
if (_sizes.Contains(size))
{
jw.WriteValueAsync(size).ConfigureAwait(false);
}
else
{
jw.WriteValueAsync(_scales.ContainsKey(size) ? _scales[size] : "medium").ConfigureAwait(false);
}
}
if (_symbolField != null)
{
var symbol = row[_symbolField].ToString();
if (symbol.StartsWith("http"))
{
symbol = "marker";
}
jw.WritePropertyNameAsync("marker-symbol").ConfigureAwait(false);
jw.WriteValueAsync(symbol).ConfigureAwait(false);
}
}
jw.WriteEndObjectAsync().ConfigureAwait(false); //properties
jw.WriteEndObjectAsync().ConfigureAwait(false); //feature
_context.Entity.Inserts++;
jw.FlushAsync().ConfigureAwait(false);
}
jw.WriteEndArrayAsync().ConfigureAwait(false); //features
jw.WriteEndObjectAsync().ConfigureAwait(false); //root
jw.FlushAsync().ConfigureAwait(false);
}
