public async Task HandleScriptCall(string data)
{
// run script call handling on separate task to free up UI
await Task.Run(async() =>
{
var info = JsonConverter.Deserialize <InvokeInfoModel>(data);
if (info != null)
{
if (info.Type == "title")
{
string title = JsonConverter.Deserialize <string>(info.Parameters);
TitleChanged?.Invoke(this, title);
}
else if (info.Type == "api")
{
var result = await ResolveCall(info.Id, info.Parameters);
await EndApiCall(info, result);
}
else if (info.CallbackId != null)
{
string message = $"Invalid invoke type \"{info.Type ?? "<null>"}\".";
await EndApiCall(info, ApiResultModel.FromError(message));
}
}
});
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var templateVariablesConverter = new ValueConverter <List <TemplateVariable>, String>(
model => _json.Serialize(model.ToDictionary(x => x.VarName)),
value => _json.Deserialize <Dictionary <string, TemplateVariable> >(value).Values.ToList());
var templateVariablesComparer = new ValueComparer <List <TemplateVariable> >(
(l, r) => _json.Serialize(l) == _json.Serialize(r),
v => v == null ? 0 : _json.Serialize(v).GetHashCode(),
v => _json.Deserialize <List <TemplateVariable> >(_json.Serialize(v)));
modelBuilder.Entity <BannerTemplateEntity>(builder =>
{
builder.Property(x => x.Variables)
.HasConversion(templateVariablesConverter, templateVariablesComparer);
});
//modelBuilder.Entity<BannerTemplateEntity>(builder =>
//{
// builder.Property(x => x.Variables)
// .HasConversion<TemplateVariableConverter, JsonComparer<List<TemplateVariable>>>();
//});
modelBuilder.Entity <BannerEntity>(builder =>
{
builder.Property(x => x.VariableOptions)
.HasConversion <VariableOptionListConverter, JsonComparer <List <VariableOption> > >();
});
}
public void DeserializeList(List <int> list)
{
var serialized = JsonConvert.SerializeObject(list);
var deserialized = _converter.Deserialize(serialized);
for (var i = 0; i < list.Count; i++)
{
deserialized[i].Should().Be(list[i]);
}
}
public async Task <PageModel> FetchShowsAsync(int pageNumber)
{
var response = await _client.GetAsync(string.Format(SHOWS_API_ENDPOINT, pageNumber));
var showsData = _json.Deserialize <List <ShowData> >(response);
var showsModel = _mapper.MapCollection <ShowData, ShowModel>(showsData).ToList();
var result = new PageModel {
Id = pageNumber, Shows = showsModel
};
await _repository.SaveAsync(_mapper.Map <TvMazePage>(result));
return(result);
}
public ItemLevelCacheHit GetCacheItem(string cacheKey)
{
// Check if the item is in the cache.
var cacheItem = mOutputCacheStorageProvider.GetCacheItem(cacheKey);
if (cacheItem?.Output == null)
{
return(null);
}
var serializedItem = mHttpContextAccessor.Current().Request.ContentEncoding.GetString(cacheItem.Output);
var itemLevelCacheItem = mJsonConverter.Deserialize <ItemLevelCacheItem>(serializedItem);
if (itemLevelCacheItem == null)
{
return(null);
}
return(new ItemLevelCacheHit()
{
CacheItem = cacheItem.ToCacheItemModel(),
ItemLevelCacheItem = itemLevelCacheItem,
IsInGracePeriod = cacheItem.IsInGracePeriod(mClock.UtcNow)
});
}
public TElement[] Deserialize(ref JsonTokenizer tokenizer)
{
var buffer = new LocalList <TElement>();
while (tokenizer.MoveNext())
{
var token = tokenizer.Current;
var tokenType = token.TokenType;
// ReSharper disable once ConvertIfStatementToSwitchStatement
if (tokenType == JsonTokenType.Null)
{
return(null);
}
if (tokenType == JsonTokenType.ArrayStart)
{
continue;
}
if (tokenType == JsonTokenType.ArrayEnd)
{
break;
}
var element = _elementConverter.Deserialize(ref tokenizer);
buffer.Add(element);
}
return(buffer.ToArray());
}
/// <summary>
/// Register worker for accepting jobs as sync.
/// </summary>
/// <typeparam name="TData">Type of data to working on it.</typeparam>
/// <param name="worker">Worker instance for registering it.</param>
/// <returns>Returns true if registered successfully, otherwise returns false.</returns>
public bool Register <TData>(IWorker <TData> worker) where TData : class
{
this.ValidateWorker(worker);
try
{
// Receive
var result = _messageQueue.Receive(
worker.JobName,
body => worker.Work(_jsonConverter.Deserialize <TData>(body)));
// Log, if could not be registerd.
if (!result)
{
_logger.LogError($"Worker {worker.JobName} could not be registered.");
return(false);
}
}
catch (Exception ex)
{
_logger.LogError(
new EventId(),
ex,
$"Worker {worker.JobName} registration failed. {ex.Message}");
throw ex;
}
_logger.LogInformation($"Worker {worker.JobName} successfully registered.");
return(true);
}
protected override DriverResult Editor(ContentPart part, MediaGalleryField field, IUpdateModel updater, dynamic shapeHelper)
{
var model = new MediaGalleryFieldViewModel();
updater.TryUpdateModel(model, GetPrefix(field, part), null, null);
var settings = field.PartFieldDefinition.Settings.GetModel <MediaGalleryFieldSettings>();
if (String.IsNullOrEmpty(model.SelectedItems))
{
field.SelectedItems = "[]";
}
else
{
field.SelectedItems = model.SelectedItems;
}
var allItems = _jsonConverter.Deserialize <MediaGalleryItem[]>(field.SelectedItems);
if (settings.Required && allItems.Length == 0)
{
updater.AddModelError("SelectedItems", T("The field {0} is mandatory", field.Name.CamelFriendly()));
}
if (!settings.Multiple && allItems.Length > 1)
{
updater.AddModelError("SelectedItems", T("The field {0} doesn't accept multiple media items", field.Name.CamelFriendly()));
}
return(Editor(part, field, shapeHelper));
}
public ItemLevelCachePartHandler(IJsonConverter jsonConverter, ICacheService cacheService, IContentManager contentManager, IShapeDisplay shapeDisplay, IItemLevelCacheService itemLevelCacheService, IEnumerable <ICompositeCacheKeyProvider> compositeCacheKeyProviders)
{
mCacheService = cacheService;
mContentManager = contentManager;
mShapeDisplay = shapeDisplay;
mItemLevelCacheService = itemLevelCacheService;
mCompositeCacheKeyProviderList = compositeCacheKeyProviders;
OnInitializing <ItemLevelCachePart>((context, part) =>
{
// This is required to initialize the settings for new content items.
InitializeSettings(part);
});
OnLoading <ItemLevelCachePart>((context, part) =>
{
// This is required to initialize the settings for existing content items.
if (part.SerializedItemLevelCacheSettings != null)
{
part.ItemLevelCacheSettings = jsonConverter.Deserialize <Dictionary <string, ItemLevelCacheSettings> >(part.SerializedItemLevelCacheSettings);
}
InitializeSettings(part);
});
OnPublished <ItemLevelCachePart>((context, part) => Invalidate(part));
}
public ActionResult Save(int id)
{
Response.AddHeader("Access-Control-Allow-Origin", "*");
if (!User.Identity.IsAuthenticated)
{
return(new HttpUnauthorizedResult());
}
var part = _orchardServices.ContentManager.Get(id).As <PipelineConfigurationPart>();
if (part == null)
{
return(new HttpNotFoundResult());
}
if (!_orchardServices.Authorizer.Authorize(global::Orchard.Core.Contents.Permissions.ViewContent, part))
{
return(new HttpUnauthorizedResult());
}
var process = _processService.Resolve(part, part.EditorMode, "json");
process.Load(part.Configuration, _query);
if (!string.IsNullOrEmpty(Request.Form["data"]))
{
var data = _jsonConverter.Deserialize(Request.Form["data"]);
Response.ContentType = "application/json";
var inputFields = process.Entities[0].Fields.Where(f => f.Input).ToArray();
var inputFieldNames = inputFields.Select(f => f.Name).ToArray();
foreach (var item in data.rows)
{
var row = new CfgRow(inputFieldNames);
for (var i = 0; i < inputFields.Length; i++)
{
var field = inputFields[i];
try {
var value = field.Convert(item[i].Value);
row[field.Name] = value;
} catch (Exception) {
process.Log.Add(new LogEntry(LogLevel.Error, null, "Trouble converting field {0}'s value {1} to data type {2}.", field.Alias, item[i].Value, field.Type));
return(new ContentResult {
Content = process.Serialize()
});
}
}
process.Entities[0].Rows.Add(row);
}
var runner = _orchardServices.WorkContext.Resolve <IRunTimeExecute>();
runner.Execute(process);
process.Status = process.Log.Any(l => l.Level == "error") ? (short)500 : (short)200;
return(new ContentResult {
Content = process.Serialize()
});
}
return(new HttpStatusCodeResult(500));
}
public static PropertyBuilder <T> HasJsonConversion <T>(this PropertyBuilder <T> propertyBuilder,
IJsonConverter json)
{
var converter = new ValueConverter <T, String>(
v => json.Serialize(v),
v => json.Deserialize <T>(v));
var comparer = new ValueComparer <T>(
(l, r) => json.Serialize(l) == json.Serialize(r),
v => v == null ? 0 : json.Serialize(v).GetHashCode(),
v => json.Deserialize <T>(json.Serialize(v)));
propertyBuilder.HasConversion(converter);
propertyBuilder.Metadata.SetValueConverter(converter);
propertyBuilder.Metadata.SetValueComparer(comparer);
return(propertyBuilder);
}
protected TElement DeserializeElement(JsonTokenizer tokenizer)
{
var token = tokenizer.Current;
var tokenType = token.TokenType;
return(tokenType != JsonTokenType.Null
? _elementConverter.Deserialize(tokenizer)
: default !);
public TNullable?Deserialize(ref JsonTokenizer tokenizer)
{
var token = tokenizer.Current;
if (token.TokenType == JsonTokenType.Null)
{
return(null);
}
return(_valueConverter.Deserialize(ref tokenizer));
}
/// <summary>
/// Initialization
/// </summary>
/// <param name="param">Param witch come from MainPageEntryViewModel</param>
/// <returns>Asynchronous result</returns>
public async Task Init(string param)
{
IsFlightsExist = true;
_dataOfFlights = _jsonConverter.Deserialize <DataOfFlights>(param);
_favoriteList = _fileStore.Load <ObservableCollection <Favorite> >(Defines.FAVORITE_LIST_FILE_NAME);
_favoriteList = _favoriteList ?? new ObservableCollection <Favorite>();
await ShowFlightsAsync();
IsFlightsExist = FlightsList.Any() ? true : false;
}
public static T Deserialize <T>(this IJsonConverter <T> converter, string json, StringBuilder?sb = null)
{
using var tokenizer = new JsonTokenizer(json, sb ?? new StringBuilder());
if (converter.IsPrimitive)
{
tokenizer.MoveNext();
}
return(converter.Deserialize(tokenizer));
}
private IEnumerable <CustomerOverview> GetAccounts(bool getFromOtherApp = false)
{
var value = getFromOtherApp
? preferences.GetFromOtherApp(nameSpace, key, null)
: preferences.Get(nameSpace, key, null);
return(value != null
? jsonConverter.Deserialize(value)
: new List <CustomerOverview>());
}
public Task <T> Get <T>(string url)
{
using (var client = new System.Net.Http.HttpClient())
{
var response = await client.GetAsync(url);
var json = await response.Content.ReadAsStringAsync();
return(jsonConverter.Deserialize <T>(json));
}
}
public T Get <T>(string cacheItemKey)
{
var regionKey = GetRegionKeyCore(
cacheItemKey: cacheItemKey,
regionName: _regionName
);
var getCacheObject = GetCore(regionKey: regionKey);
var getCacheItem = _jsonConverter.Deserialize <T>((string)getCacheObject);
return(getCacheItem);
}
/// <summary>
/// Load data from file
/// </summary>
/// <typeparam name="T">Type of data</typeparam>
/// <param name="fileName">File's name</param>
/// <returns>Data from file</returns>
public T Load <T>(string fileName)
{
string txt;
T result = default(T);
if (_fileStore.TryReadTextFile(fileName, out txt))
{
return(_jsonConverter.Deserialize <T>(txt));
}
return(result);
}
public T LoadInternal <T>(Guid id)
{
GetOrCreateTable(typeof(T));
using (var command = _conn.CreateCommand())
{
command.CommandType = CommandType.Text;
command.CommandText = String.Format(@"SELECT body FROM {0} WHERE id = :id LIMIT 1;", _tableInfo.TableNameWithSchema(typeof(T)));
command.Parameters.AddWithValue(":id", id);
using (var reader = command.ExecuteReader())
{
if (reader.Read())
{
return(_jsonConverter.Deserialize <T>(reader.GetString(0)));
}
return(default(T));
}
}
}
protected override DriverResult Editor(ReCaptchaPart part, IUpdateModel updater, dynamic shapeHelper)
{
var workContext = _workContextAccessor.GetContext();
var settings = workContext.CurrentSite.As <ReCaptchaSettingsPart>();
// don't display the part in the admin
if (AdminFilter.IsApplied(workContext.HttpContext.Request.RequestContext))
{
return(null);
}
if (settings.TrustAuthenticatedUsers && workContext.CurrentUser != null)
{
return(null);
}
var context = workContext.HttpContext;
try {
var result = ExecuteValidateRequest(
settings.PrivateKey,
context.Request.ServerVariables["REMOTE_ADDR"],
context.Request.Form["g-recaptcha-response"]
);
ReCaptchaPartResponseModel responseModel = _jsonConverter.Deserialize <ReCaptchaPartResponseModel>(result);
if (!responseModel.Success)
{
foreach (var errorCode in responseModel.ErrorCodes)
{
if (errorCode == "missing-input-response")
{
updater.AddModelError("", T("Please prove that you are not a bot."));
_notifier.Error(T("Please prove that you are not a bot."));
}
else
{
Logger.Information("An error occurred while submitting a reCaptcha: " + errorCode);
updater.AddModelError("", T("An error occurred while submitting a reCaptcha."));
_notifier.Error(T("An error occurred while submitting a reCaptcha."));
}
}
}
}
catch (Exception e) {
Logger.Error(e, "An unexcepted error occurred while submitting a reCaptcha.");
updater.AddModelError("", T("There was an error while validating the Captcha."));
_notifier.Error(T("There was an error while validating the Captcha."));
}
return(Editor(part, shapeHelper));
}
protected override bool OnResolvingFile(IFileSystem fileSystem, IPathResolver pathResolver, string fileName, out string searchPath, out string resolvedFileName)
{
if (pathResolver.ResolvePath(fileSystem, fileName, out searchPath, out resolvedFileName))
{
return(true);
}
// try resolve bytecode file
if (pathResolver.ResolvePath(fileSystem, fileName + ".js.bytes", out searchPath, out resolvedFileName))
{
return(true);
}
if (pathResolver.ResolvePath(fileSystem, fileName + ".js", out searchPath, out resolvedFileName))
{
return(true);
}
if (pathResolver.ResolvePath(fileSystem, PathUtils.Combine(fileName, "index.js"), out searchPath, out resolvedFileName))
{
return(true);
}
if (_jsonConv != null && pathResolver.ResolvePath(fileSystem, PathUtils.Combine(fileName, "package.json"), out searchPath, out resolvedFileName))
{
var packageData = fileSystem.ReadAllText(resolvedFileName);
if (packageData != null)
{
var packageConfig = _jsonConv.Deserialize(packageData, typeof(PackageConfig)) as PackageConfig;
if (packageConfig != null)
{
var main = PathUtils.Combine(searchPath, fileName, packageConfig.main);
if (!main.EndsWith(".js"))
{
main += ".js";
}
main = PathUtils.ExtractPath(main, '/');
if (fileSystem.Exists(main))
{
resolvedFileName = main;
return(true);
}
}
}
}
resolvedFileName = null;
return(false);
}
/// <summary>
/// The method gets data about flights from service
/// </summary>
/// <param name="date">Date of flight</param>
/// <param name="from">Location from</param>
/// <param name="to">Location to</param>
/// <returns></returns>
public async Task <List <FlyInfo> > GetFlightAsync(string date, string from, string to)
{
var uri = "https://api.rasp.yandex.net/v1.0/search/?apikey=e07ef310-dbe4-49cf-985f-1d5738c1ebc7&format=json&transport_types=plane&system=iata&from=" + from + "&to=" + to + "&lang=en&page=1&date=" + date;
var response = await _httpService.GetRequestAsync(uri);
if (response == null)
{
return(null);
}
var flightInfo = _jsonConverter.Deserialize <FlightInfo>(response);
var flyInfo = new List <FlyInfo>();
flyInfo.AddRange(flightInfo.Threads.Select(CreateFlyInfo));
return(flyInfo);
}
async Task <EventualConsistentEvent[]> Get(IEnumerable <EventData> data)
{
var tasks = data.Select(async eventData =>
{
var customConverter = CreateConverter(eventData.EventName);
// TODO: don't call Type.GetType() and get event's Type from some cached context?
// TODO: review code of this class and dependent classes (EventConverter etc)
var @event = customConverter == null
? (IEvent)_jsonConverter.Deserialize(eventData.Payload, Type.GetType(eventData.EventName))
: await customConverter.ConvertBack(eventData.Id, eventData.Payload);
return(new EventualConsistentEvent(@event, eventData.HandlerName));
});
return(await TaskEx.OneAtATime(tasks));
}
public void Deserialize(Boo[] array)
{
var serialized = JsonConvert.SerializeObject(array);
var deserialized = _converter.Deserialize(serialized);
for (var i = 0; i < array.Length; i++)
{
deserialized[i].Should().BeEquivalentTo(array[i]);
}
}
/// <summary>
/// The method witch get iatas by specific country
/// </summary>
/// <param name="city">The name of city</param>
/// <returns>List of iatas</returns>
public async Task <List <string> > GetIataAsync(string city)
{
var uri = "http://flybaseapi.azurewebsites.net/odata/code_iata('" + city + "')";
var response = await _httpService.GetRequestAsync(uri);
if (response != null)
{
var airportInfo = _jsonConverter.Deserialize <AirportInfo>(response);
var iata = new List <string>();
foreach (var item in airportInfo.value)
{
iata.Add(item.Iata);
}
return(iata);
}
return(null);
}
/// <summary>
/// The method witch get cities by specific country
/// </summary>
/// <param name="country">The name of country</param>
/// <returns>List of cities</returns>
public async Task <List <string> > GetCitiesAsync(string country)
{
var uri = "http://flybaseapi.azurewebsites.net/odata/country('" + country + "')";
var response = await _httpService.GetRequestAsync(uri);
if (response != null)
{
var airportInfo = _jsonConverter.Deserialize <AirportInfo>(response);
var cities = new List <string>();
foreach (var item in airportInfo.value)
{
cities.Add(item.City);
}
cities.Sort();
return(cities.Distinct().ToList());
}
return(null);
}
public override string GetBisData(WFTaskEntity taskEntity, string dataId, string serviceId, EAccessMessageType messageType)
{
//从tasksetting获取配置的远程对象代码，调取远方模型进行预算，返回结果
string jsonData = "{}";
if (!string.IsNullOrWhiteSpace(taskEntity.Setting))
{
var finisid = this._WfFinsDal.GetIdByDataIdAndFlowId(dataId, taskEntity.Flowid);
var tinsid = this._WftinsDal.GetIdByFinsIdAndTaskId(finisid, taskEntity.ID);
var settingModel = _jsonConverter.Deserialize <ObjectSettingModel>(taskEntity.Setting);
if (settingModel != null)
{
jsonData = _IAppAccessService.GetModelTaskBisdata(serviceId, dataId, settingModel.ObjectCode).GetAwaiter().GetResult();
}
_WfTdataDal.Add(taskEntity.Flowid, finisid, taskEntity.ID, tinsid, jsonData);
}
return(jsonData);
}
public LuceneSettingsPartHandler(IJsonConverter jsonConverter)
{
T = NullLocalizer.Instance;
Filters.Add(new ActivatingFilter <LuceneSettingsPart>("Site"));
OnActivated <LuceneSettingsPart>((context, part) => {
part.LuceneAnalyzerSelectorMappingsField.Loader(() => {
return(string.IsNullOrEmpty(part.LuceneAnalyzerSelectorMappingsSerialized)
? new List <LuceneAnalyzerSelectorMapping>()
: jsonConverter.Deserialize <List <LuceneAnalyzerSelectorMapping> >(part.LuceneAnalyzerSelectorMappingsSerialized));
});
part.LuceneAnalyzerSelectorMappingsField.Setter((value) => {
part.LuceneAnalyzerSelectorMappingsSerialized = value == null ? "[]" : jsonConverter.Serialize(value);
return(value);
});
});
}
public override bool RunTask(WFTaskEntity taskEntity, WFFinsEntity fins, WFTinsEntity tinsEntity, WFTEventEntity enventEntity)
{
// 根据tasksetting 节点的配置信息读取要发送到的远端地址
//可以是多个地址
if (!string.IsNullOrWhiteSpace(taskEntity.Setting))
{
var list = _jsonConverter.Deserialize <List <SendHttpModel> >(taskEntity.Setting);
if (list != null)
{
Dictionary <string, string> dicPostdata = null;
foreach (var item in list)
{
//Console.WriteLine($"发送数据到远端{item.Url}");
dicPostdata = new Dictionary <string, string>();
dicPostdata.Add("callbackTag", enventEntity.ID);
dicPostdata.Add("customTag", item.CustomTag);
dicPostdata.Add("dataId", enventEntity.Dataid);
var content = new FormUrlEncodedContent(dicPostdata);
var httpClient = _httpClientFactory.CreateClient();
try
{
var response = httpClient.PostAsync(item.Url, content).GetAwaiter().GetResult();
if (response.IsSuccessStatusCode)
{
response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
}
else
{
var a = "";
}
}
catch (HttpRequestException ex)
{
throw new HttpRequestException($"{ex.Message}，RunTask url：{item.Url} content:{_jsonConverter.Serialize(dicPostdata) }");
}
}
return(false);
}
}
return(true);
}
public WatchablePartHandler(
IRepository<WatchablePartRecord> repository,
IJsonConverter jsonConverter)
{
Filters.Add(StorageFilter.For(repository));
OnActivated<WatchablePart>((ctx, part) =>
{
part.WatcherIdsField.Loader(() =>
{
var seed = string.IsNullOrEmpty(part.WatcherIdsSerialized) ? Enumerable.Empty<int>() : jsonConverter.Deserialize<IEnumerable<int>>(part.WatcherIdsSerialized);
var collection = new ObservableCollection<int>(seed);
collection.CollectionChanged += (sender, e) =>
{
part.WatcherIdsSerialized = jsonConverter.Serialize((IEnumerable<int>)collection);
};
return collection;
});
});
}
public NotificationsUserPartHandler(IJsonConverter jsonConverter, Lazy<INotificationsToUserDispatcher> notificationDispatcherLazy)
{
Filters.Add(new ActivatingFilter<NotificationsUserPart>("User"));
OnActivated<NotificationsUserPart>((context, part) =>
{
part.RecentNotificationEntriesField.Loader(() =>
{
var serializedEntries = part.Retrieve<string>("RecentNotificationEntriesSerialized");
if (string.IsNullOrEmpty(serializedEntries)) return Enumerable.Empty<NotificationUserEntry>();
return jsonConverter.Deserialize<IEnumerable<NotificationUserEntry>>(serializedEntries);
});
part.RecentNotificationEntriesField.Setter(entries =>
{
Argument.ThrowIfNull(entries, "entries");
part.Store<string>("RecentNotificationEntriesSerialized", jsonConverter.Serialize(entries));
return entries;
});
});
}
