// GET: Pages
public async Task <IActionResult> Index(string title, string prop = "id", bool order = true, int take = 5, int skip = 0)
{
string param = $@"?order={order}&prop={prop}&take={take}&skip={skip}&title={title}";
string query = PagesController._apiUrl + param;
var res = await(await _httpClient.GetAsync(query)).Content.ReadAsStringAsync();
if (res != null)
{
_logger.LogInformation("Page accepted from Rest api");
}
else
{
_logger.LogError("Failed to get page from Rest api");
}
var pages = JSerializer.DeserializeObject <List <Page> >(res);
ViewBag.Order = !order;
ViewBag.Take = 5;
var countJson = await(await _httpClient.GetAsync(_apiUrl + "count")).Content.ReadAsStringAsync();
_logger.LogInformation(countJson);
ViewBag.Count = int.Parse(countJson);
_logger.LogInformation(pages.Count() + "");
return(View(pages.ToList()));
}
public async Task <IReadOnlyCollection <UnconfirmedBitcoinDeposit> > GetUnconfirmedBitcoinDepositsAsync()
{
JToken data = await GetDataAsync("unconfirmed_btc/",
_httpClientFactory.GetClientV1(_credentials, InternalApiKey));
return(JsonConvert.DeserializeObject <List <UnconfirmedBitcoinDeposit> >(data.ToString()));
}
public SiteConfig_Out GetSiteConfig(string input)
{
SiteConfig_Out json = new SiteConfig_Out();
SiteConfig_In model = null;
try
{
model = JsonConvert.DeserializeObject <SiteConfig_In>(input);
string strSql = "select * from TAB_System_SiteConfig where strSiteNumber=@strSiteNumber ";
SqlParameter[] sqlParameters = new SqlParameter[]
{
new SqlParameter("strSiteNumber", model.SiteNumber),
};
DataTable table =
SqlHelper.ExecuteDataset(SqlHelper.ConnString, CommandType.Text, strSql, sqlParameters).Tables[0];
json.data = new List <SiteConfig>();
SiteConfig config = null;
foreach (DataRow dataRow in table.Rows)
{
config = new SiteConfig();
config.strName = dataRow["strName"].ToString();
config.strValue = dataRow["strValue"].ToString();
json.data.Add(config);
}
json.result = "0";
json.resultStr = "获取客户端配置成功";
}
catch (Exception ex)
{
LogClass.logex(ex, "");
throw ex;
}
return(json);
}
private async Task <T> TryGetAsync <T>(string key)
{
try
{
lock (_data)
{
if (_data.TryGetValue(key, out var result))
{
var resp = JsonConvert.DeserializeObject <T>(result);
return(resp);
}
}
//string value = await _redisDatabase.StringGetAsync(key);
//if (!string.IsNullOrEmpty(value))
//{
// return value.DeserializeJson<T>();
//}
}
catch (Exception exception)
{
Console.WriteLine($"Error! key: {key}, T: {typeof(T).Name}");
_log.Error(exception);
}
return(default(T));
}
public async Task <IActionResult> Get()
{
try
{
var queryString = this.Request.QueryString.ToString();
var json = JsonHelper.ConvertQueryToJson(queryString);
if (json == null)
{
this._logger.Log(LogHelper.CreateLog(DateTime.Now, LogType.Fail, "Invalid query", null));
return(this.BadRequest());
}
var filter = JsonConvert.DeserializeObject <ExamFilter>(json);
filter.CreatorUserId = this.GetAuthenticatedUserId();
var exams = await this._repository.GetAllExams(filter);
if (exams == null || !exams.Any())
{
return(this.NoContent());
}
return(new JsonResult(exams));
}
catch (Exception ex)
{
this._logger.Log(LogHelper.CreateLog(DateTime.Now, LogType.Fatal, null, ex));
return(this.BadRequest());
}
}
public ActionResult Edit(string id, Event eventt, string Originalsavedeventstring)
{
try
{
string volasstring = JsonConvert.SerializeObject(eventt);
bool containsspecialchar = false;
if (volasstring.Contains(";"))
{
ModelState.AddModelError("Cannot contain semi-colons", "Cannot contain semi-colons");
containsspecialchar = true;
}
Event Originalsavedvol = JsonConvert.DeserializeObject <Event>(Originalsavedeventstring);
try
{
Event currentsavedevent = eventcollection.Find(x => x.EventID == id).Single();
if (JsonConvert.SerializeObject(Originalsavedvol).Equals(JsonConvert.SerializeObject(currentsavedevent)))
{
ModelState.Remove("NumberOfVolunteersNeeded");
ModelState.Remove("DateOfEvent");
ModelState.Remove("Duration");
if (ModelState.IsValid)
{
var filter = Builders <Event> .Filter.Eq("_id", ObjectId.Parse(id));
var update = Builders <Event> .Update
.Set("NameOfEvent", eventt.NameOfEvent)
.Set("PlaceOfEvent", eventt.PlaceOfEvent)
.Set("DateOfEvent", eventt.DateOfEvent.AddHours(5))
.Set("NumberOfVolunteersNeeded", eventt.NumberOfVolunteersNeeded)
.Set("TypeOfActivities", eventt.TypeOfActivities)
.Set("TypeOfEvent", eventt.TypeOfEvent)
.Set("Duration", eventt.Duration)
;
var result = eventcollection.UpdateOne(filter, update);
return(RedirectToAction("Index"));
}
else
{
ViewBag.originalsavedvol = Originalsavedeventstring;
ViewBag.id = id;
ViewBag.containsspecialchar = containsspecialchar;
return(View());
}
}
else
{
return(View("Volunteerwarning"));
}
}
catch
{
return(RedirectToAction("Index"));
}
}
catch
{
return(RedirectToAction("Localserver", "Home"));
}
}
public async Task Execute(IMongoDatabase db, JToken data, string collectionName)
{
var indexOptions = JsonConvert.DeserializeObject <IndexOptions>(data.ToString());
var collection = db.GetCollection <BsonDocument>(collectionName);
if (indexOptions.Operation == IndexOperations.Drop)
{
await DroppingIndex(collection, indexOptions.IndexProperty.ToLower());
return;
}
var indexes = await collection.Indexes.ListAsync();
if (KeyExists(indexes, indexOptions.Name))
{
await DroppingIndex(collection, indexOptions.Name);
}
await collection.Indexes.CreateOneAsync(indexOptions.IndexKeyDefinition, new CreateIndexOptions
{
Name = indexOptions.Name,
Unique = indexOptions.IsUnique
});
}
public override Vehicle Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var serializer = BsonSerializer.LookupSerializer(typeof(BsonDocument));
var document = serializer.Deserialize(context, args);
var bsonDocument = document.ToBsonDocument();
var result = BsonExtensionMethods.ToJson(bsonDocument);
var jObject = JObject.Parse(result);
jObject.Remove("_id");
var documentWithNoId = jObject.ToString();
//switch (mvnt.GetType().Name)
//{
// case "Tiger":
// //your serialization here
// break;
// case "Zebra":
// //your serialization here
// break;
// default:
// break;
//}
return(JsonConvert.DeserializeObject <Vehicle>(documentWithNoId));
}
public static T Read <T>(string fileName)
{
using (var sr = new System.IO.StreamReader(fileName))
{
return(JC.DeserializeObject <T>(sr.ReadToEnd()));
}
}
public DB_SysConfig_Out GetDBSysConfig(string input)
{
DB_SysConfig_Out json = new DB_SysConfig_Out();
DB_SysConfig_In model = null;
try
{
model = JsonConvert.DeserializeObject <DB_SysConfig_In>(input);
string strSql = " select * from TAB_System_Config where strSection =@strSection and strIdent =@strIdent ";
SqlParameter[] sqlParameters = new SqlParameter[]
{
new SqlParameter("strSection", model.SectionName), new SqlParameter("strIdent", model.Ident),
};
DataTable table =
SqlHelper.ExecuteDataset(SqlHelper.ConnString, CommandType.Text, strSql, sqlParameters).Tables[0];
if (table != null && table.Rows.Count > 0)
{
json.data.strValue = table.Rows[0]["strValue"].ToString();
json.result = "0";
json.resultStr = "获取配置成功";
}
else
{
json.data.strValue = String.Empty;
json.result = "1";
json.resultStr = "获取配置失败";
}
}
catch (Exception ex)
{
LogClass.logex(ex, "");
throw ex;
}
return(json);
}
public JsonResult LiveNordicProductionConsumption()
{
/* Convert to norway's time zone */
var date = DateTime.UtcNow; //.AddHours(-1)
/* Aproximate to latest minute */
date = date.AddSeconds(-DateTime.Now.Second);
var timestamp = date.Ticks - DateTime.Parse("01/01/1970 00:00:00").Ticks;
timestamp = timestamp / 10000;
var url = @"http://driftsdata.statnett.no/restapi/ProductionConsumption/GetLatestDetailedOverview?timestamp={0}";
var furl = string.Format(url, timestamp);
var result = new WebClient().DownloadString(furl);
/* Proper parsing */
result = result.Replace(" ", "").Replace("Â", "");
var ms = Regex.Matches(result, @"""[\d\s]+""");
foreach (var m in ms)
{
var newValue = m.ToString().Replace(" ", "").Replace("\"", "");;
result = result.Replace(m.ToString(), newValue);
}
var obj = JsonConvert.DeserializeObject(result);
return(Json(obj, JsonRequestBehavior.AllowGet));
}
private async Task <UserDto> GetUserAsync(string email)
{
var response = await Client.GetAsync($"user/{email}");
var responseString = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <UserDto>(responseString));
}
public async void GetMakes()
{
HttpClient httpClient = new HttpClient();
var response = await httpClient.GetStringAsync(urlBase + "/api/Makes/GetMakes");
this.makeDTOs = Json.DeserializeObject <List <MakeDTO> >(response);
pickerMakes.ItemsSource = this.makeDTOs.Select(x => x.Name).ToList();
}
private MachineStreamData TryReadEventData(string eventPayload)
{
_logger.LogInformation("Trying to read the data");
var data = JsonConvert.DeserializeObject <MachineStreamData>(eventPayload);
_logger.LogInformation("Read the data");
return(data);
}
public void ProperPhoneNumber_DeserializesCorrectly_UsingNewtonsoftJson(string number)
{
var phoneNumber = new PhoneNumber(number);
var serialized = NewtonsoftSerializer.SerializeObject(phoneNumber);
var deserialized = NewtonsoftSerializer.DeserializeObject <PhoneNumber>(serialized);
Assert.Equal(phoneNumber, deserialized);
}
public void ProperEmail_DeserializesCorrectly_UsingNewtonsoftJson(string address)
{
var email = new EmailAddress(address);
var serialized = NewtonsoftSerializer.SerializeObject(email);
var deserialized = NewtonsoftSerializer.DeserializeObject <EmailAddress>(serialized);
Assert.Equal(email, deserialized);
}
public EventStoreOptions CreateSecured()
{
var json = JC.SerializeObject(this);
var opt = JC.DeserializeObject <EventStoreOptions>(json);
opt.AdminPassword = "******";
opt.OpsPassword = "******";
return(opt);
}
public void CanDeserializeFromGuid_WithNewtonsoftJsonProvider()
{
var value = Guid.NewGuid();
var foo = new NewtonsoftJsonGuidId(value);
var serializedGuid = NewtonsoftJsonSerializer.SerializeObject(value);
var deserializedFoo = NewtonsoftJsonSerializer.DeserializeObject <NewtonsoftJsonGuidId>(serializedGuid);
Assert.Equal(foo, deserializedFoo);
}
public void CanDeserializeFromInt_WithNewtonsoftJsonProvider()
{
var value = 123;
var foo = new NewtonsoftJsonIntId(value);
var serializedInt = NewtonsoftJsonSerializer.SerializeObject(value);
var deserializedFoo = NewtonsoftJsonSerializer.DeserializeObject <NewtonsoftJsonIntId>(serializedInt);
Assert.Equal(foo, deserializedFoo);
}
public void CanDeserializeFromString_WithNewtonsoftJsonProvider()
{
var value = "123";
var foo = new NewtonsoftJsonStringId(value);
var serializedString = NewtonsoftJsonSerializer.SerializeObject(value);
var deserializedFoo = NewtonsoftJsonSerializer.DeserializeObject <NewtonsoftJsonStringId>(serializedString);
Assert.Equal(foo, deserializedFoo);
}
private MultiInputGroup CreateSingleBackendCollum(string name, BackendProperty backendProperty)
{
MultiInputGroup backendMultiInputGroup = new MultiInputGroup();
backendMultiInputGroup.AppendLabel(name, 115 + 80);
TwoStateButtonGroup backendEnabled = backendMultiInputGroup.AppendCustomElement(new TwoStateButtonGroup("Vom Server", "Als Debug", backendProperty.RequestDataFromBackend, !backendProperty.RequestDataFromBackend), false);
StylableTextInput backendPath = backendMultiInputGroup.AppendTextInput("Pfad zur WebAPI", startText: backendProperty.DataSourcePath);
_backendPathTextInputDictionary.Add(name, backendPath);
backendMultiInputGroup.AppendValidation("Einstellungen OK", "Einstellungen sind nicht OK", false);
Button backendSaveSettings = backendMultiInputGroup.AppendCustomElement(new Button(StylingColor.Success, true, text: "Speichern", fontAwesomeIcon: "save"), false);
backendSaveSettings.Click += (sender, args) =>
{
backendPath.SetValidation(false, false);
if (backendEnabled.FirstButtonActive && Uri.IsWellFormedUriString(backendPath.Value, UriKind.Absolute))
{
try
{
if (JsonConvert.DeserializeObject <bool>(new HttpClient().GetAsync(backendPath.Value + "/enabled").EnsureResultSuccessStatusCode().Result.Content.ReadAsStringAsync().Result) == false)
{
//TODO: ich brauche eine Messagebox
backendPath.Value = "Der Server hat diese API verweigert! Pfad:" + backendPath.Value;
throw new Exception(backendPath.Value);
}
backendPath.SetValidation(true, false);
backendProperty.RequestDataFromBackend = backendEnabled.FirstButtonActive;
backendProperty.DataSourcePath = backendPath.Value;
}
catch (Exception e)
{
backendPath.Value = "Der Verbindungsversuch ist fehlgeschlagen! Pfad:" + backendPath.Value;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Beim Versuch die neuen BackendEinstellungen zu Testen ist ein Fehler aufgetreten.");
Console.ResetColor();
Logging.WriteLog("System", "Warn", $"Beim Versuch die Backendeinstellungen für {name} des Servers zu validieren ist es zu folgendem Fehler gekommen:\r\n{e.Message}");
backendPath.SetValidation(false, true);
//TODO: ich brauche eine Messagebox
}
}
else if (backendEnabled.SecondButtonActive)
{
backendPath.SetValidation(true, false);
backendProperty.RequestDataFromBackend = backendEnabled.FirstButtonActive;
}
else
{
backendPath.SetValidation(false, true);
}
};
backendMultiInputGroup.AddStyling(StylingOption.MarginBottom, 2);
return(backendMultiInputGroup);
}
private Dictionary <string, object> ReadParametersFromJson()
{
var parameters = new Dictionary <string, object>();
string rawJsonContent = SynapseAnalyticsClient.ReadJsonFileContent(this.TryResolvePath(ParameterFile));
if (!string.IsNullOrWhiteSpace(rawJsonContent))
{
parameters = JsonConvert.DeserializeObject <Dictionary <string, object> >(rawJsonContent);
}
return(parameters);
}
public virtual T From <T>(string json)
{
try
{
return(JsonConvert.DeserializeObject <T>(json));
}
catch
{
return(SerializerHelper.Default <T>());
}
}
public void ConfigureTestServices(IServiceCollection services)
{
services.AddMvc()
.AddJsonOptions(options =>
{
options.SerializerSettings.Converters.Add(new StringEnumConverter());
options.SerializerSettings.ContractResolver =
new Newtonsoft.Json.Serialization.DefaultContractResolver();
});
var configurationRoot = new ConfigurationBuilder()
.AddEnvironmentVariables()
.Build();
// @atarutin: Workaround to load settings manually since there are troubles with latest
// Lykke.SettingsReader library version and HttpClient instance initialization when
// executing tests with TeamCity
var settingsUrl = configurationRoot[SettingsConfiguratorExtensions.DefaultConfigurationKey];
if (string.IsNullOrEmpty(settingsUrl))
{
throw new InvalidOperationException("SettingsUrl variable is empty");
}
string settingsContent;
if (settingsUrl.StartsWith("http"))
{
using (var httpClient = new HttpClient())
{
settingsContent = httpClient.GetStringAsync(settingsUrl).GetAwaiter().GetResult();
}
}
else
{
using (var reader = File.OpenText(settingsUrl))
{
settingsContent = reader.ReadToEndAsync().GetAwaiter().GetResult();
}
}
var settings = JsonConvert.DeserializeObject <AppSettings>(settingsContent);
services.AddSingleton(settings.CexIoAdapterService);
services.AddEmptyLykkeLogging();
services.AddSwaggerGen(options =>
{
options.DefaultLykkeConfiguration(
_swaggerOptions.ApiVersion,
$"{_swaggerOptions.ApiTitle} Under Test");
});
}
private void LvModels_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
var makeName = lvMakes.SelectedItem.ToString();
var modelName = e.SelectedItem.ToString();
var selectedMake = makeDTOs.FirstOrDefault(x => x.Name == makeName);
var selectedModel = selectedMake.Models.FirstOrDefault(x => x.Name == modelName);
var response = httpClient.GetStringAsync(urlBase + "/api/Features/GetFeaturesByModel?ModelId=" + selectedModel.Id).Result;
var features = Json.DeserializeObject <List <KeyValuePairDTO> >(response);
DisplayAlert($"Features for {modelName}", string.Join(", ", features.Select(x => x.Name).ToList()), "Close");
}
//[Authorize(Policy = Policies.Controller)]
public async Task <ActionResult <WorkflowInstance> > StartWorkflow(string id)
{
string contentReq = null;
using (StreamReader reader = new StreamReader(Request.Body, Encoding.UTF8))
{
contentReq = await reader.ReadToEndAsync();
}
var logTrace = new LogTrace();
AiLogger.LogInfo(logTrace, "Workflow Start: " + contentReq);
object workflowData = contentReq;
string workflowId = null;
if (id.Equals(CompressJobWorkflow.WorkflowId))
{
workflowId = CompressJobWorkflow.WorkflowId;
workflowData = NewtonJsonConvert.DeserializeObject <CompressJobData>(contentReq);
}
else if (id.Equals(WfFileInWorkflow.WorkflowId))
{
workflowId = WfFileInWorkflow.WorkflowId;
workflowData = NewtonJsonConvert.DeserializeObject <WfFileInData>(contentReq);
}
else if (id.Equals(Test01UserWorkflow.WorkflowId))
{
var wfEvent = Newtonsoft.Json.JsonConvert.DeserializeObject <Pdf4meWorkflowEvent>(contentReq);
workflowData = new Pdf4meWorkflowData()
{
WorkflowEvent = wfEvent
};
workflowId = Test01UserWorkflow.WorkflowId;
//workflowData = NewtonJsonConvert.DeserializeObject<WfFileInData>(contentReq);
}
else
{
var wfEvent = Newtonsoft.Json.JsonConvert.DeserializeObject <Pdf4meWorkflowEvent>(contentReq);
workflowData = new Pdf4meWorkflowData()
{
WorkflowEvent = wfEvent
};
workflowId = id;
}
var instanceId = await _workflowController.StartWorkflow(workflowId, workflowData);
var result = await _persistenceProvider.GetWorkflowInstance(instanceId);
return(Created(instanceId, _mapper.Map <WorkflowInstance>(result)));
}
public void Start(ILogger logger)
{
tokenFormats = JsonConvert.DeserializeObject <Dictionary <string, string> >(_settings.Get <string>(SettingNames.Instance.TokenFormats));
Tokens.AllTokensChanged += (sender, args) =>
{
//This isn't ideal place to handle this, but it will do for now
AdjustTokenFormats(Tokens.AllTokens);
};
Started = true;
}
static void Main(string[] args)
{
using (var reader = new StreamReader("hockey-teams.json")) {
string json = reader.ReadToEnd();
List <HockeyTeam> items = JsonConvert.DeserializeObject <List <HockeyTeam> >(json);
foreach (HockeyTeam ht in items)
{
Console.WriteLine(ht.ToString());
}
}
}
public void ParseData(Schema schema)
{
if (Data != null)
{
var jsonString = Data.ToJson(Settings);
contentData = JsonConvert.DeserializeObject <ContentData>(jsonString).ToNameModel(schema, true);
}
else
{
contentData = null;
}
}
public static T As <T>(this BsonDocument obj)
{
if (obj == null)
{
return(default(T));
}
string json = obj.ToJson(new JsonWriterSettings {
OutputMode = JsonOutputMode.Strict
});
return(JsonConvert.DeserializeObject <T>(json));
}