public void Deserialize_ShouldBeAbleToHandle_NullDateTimeValues()
{
var response = new RestResponse { Content = "[{\"closed_at\":null}]" };
var serializer = new CustomJsonSerializer();
var issues = serializer.Deserialize<List<Issue>>(response);
Assert.IsNull(issues[0].ClosedAt);
}
//[Description("https://bitbucket.org/Readify/neo4jclient/issue/89")]
public void ShouldSerializeCustomTypeThatHasTypeConverterUsingTypeConverterBasedJsonConverter()
{
//Arrange
var serializer = new CustomJsonSerializer
{
JsonConverters = new[] { new TypeConverterBasedJsonConverter() }
};
var model = new TestModelB
{
CustomValue = new TestValueB
{
A = 'o',
B = 'p'
}
};
//Act
var rawResult = serializer.Serialize(model);
//Assert
const string expectedRawOutput =
"{\r\n \"CustomValue\": \"op\"\r\n}";
Assert.Equal(expectedRawOutput, rawResult);
}
static async Task Main(string[] args)
{
const int MAX_NUMBER_REQUEST = 800;
const string BEARER_KEY = "Bearer {replace with you bearer token from your tweeter dev account}";
const int MAX_RESULTS_PER_REQUEST = 99;
//parameters
var NewestDate = DateTime.Parse("2021-05-14T07:00:33Z");
var OldestDate = DateTime.Parse("2020-12-28T07:00:33Z");
var searchKeys = "doge bitcoin";
var username = "******";
var httpClient = new CustomHttpClient();
var serializer = new CustomJsonSerializer();
var tweeterSearch = new TweetSearch(MAX_NUMBER_REQUEST, MAX_RESULTS_PER_REQUEST, BEARER_KEY, httpClient, serializer);
Console.WriteLine("Process started. Please wait..");
var final_result = await tweeterSearch.GetAllRelevantTweets(username, NewestDate, OldestDate, searchKeys);
Console.WriteLine("------------------------------------------------------------------------");
foreach (var tweet in final_result)
{
Console.WriteLine(string.Format("{0} ({1})\r\n", tweet.text, tweet.created_At));
}
}
public void ShouldSerializeCustomValueWithCustomJsonConverter()
{
//Arrange
var serializer = new CustomJsonSerializer
{
JsonConverters = new [] { new TestValueAConverter() }
};
var model = new TestModelA
{
CustomValue = new TestValueA
{
A = 'o',
B = 'p'
}
};
//Act
var rawResult = serializer.Serialize(model);
//Assert
const string expectedRawOutput =
"{\r\n \"CustomValue\": \"op\"\r\n}";
Assert.AreEqual(expectedRawOutput, rawResult);
}
//[Description("https://bitbucket.org/Readify/neo4jclient/issue/89")]
public void ShouldSerializeCustomValueWithCustomJsonConverter()
{
//Arrange
var serializer = new CustomJsonSerializer
{
JsonConverters = new [] { new TestValueAConverter() }
};
var model = new TestModelA
{
CustomValue = new TestValueA
{
A = 'o',
B = 'p'
}
};
//Act
var rawResult = serializer.Serialize(model);
//Assert
string expectedRawOutput =
$"{{{Environment.NewLine} \"CustomValue\": \"op\"{Environment.NewLine}}}";
Assert.Equal(expectedRawOutput, rawResult);
}
public AppBootstrapper(Action <ConfigurableBootstrapperConfigurator> configuration, bool enableViewSupportWhichMakesTheUnitTestsReallySlow = false) : base(with => {
if (enableViewSupportWhichMakesTheUnitTestsReallySlow)
{
// Do not use view support if it is not needed. Makes the unit tests much slower.
with.ViewLocationProvider <FileSystemViewLocationProvider>();
with.ViewFactory <TestingViewFactory>();
}
configuration(with);
}) {
JsonSerializer = new CustomJsonSerializer();
InternalConfiguration.Serializers.Clear();
InternalConfiguration.Serializers.Add(JsonSerializer.GetType());
BeforeRequest.AddItemToEndOfPipeline(context => {
if (AuthenticatedUser == null)
{
context.CurrentUser = null;
}
else
{
var userIdentity = new VoterIdentity(AuthenticatedUser);
context.CurrentUser = userIdentity;
}
return(null);
});
OnError = OnError
+ ErrorPipelines.HandleModelBindingException()
+ ErrorPipelines.HandleRequestValidationException()
+ ErrorPipelines.HandleSecurityException();
}
private static void OcrService_BatchComplete(object sender, OcrBatch batch)
{
//Console.WriteLine("Batch {0} completed", batch.JobIdentifier);
// publish result to outgoing queue/exchange
var messageBatch = new RecogniseBatchCourtesyAmountResponse
{
jobIdentifier = batch.JobIdentifier,
voucher = batch.Vouchers.Select(v => new RecogniseCourtesyAmountResponse
{
documentReferenceNumber = v.Id,
capturedAmount = v.AmountResult.Result ?? "0",
amountConfidenceLevel = v.AmountResult.Score ?? "0",
amountRegionOfInterest = new RegionOfInterest
{
height = v.AmountResult.Location.Height,
left = v.AmountResult.Location.Left,
top = v.AmountResult.Location.Top,
width = v.AmountResult.Location.Width
}
}).ToArray()
};
//MessageBus.Publish(messageBatch, RoutingKey);
//Queue.PublishToExchange(OutboundExchangeName, batch.JobIdentifier, RoutingKey, CustomJsonSerializer.MessageToBytes(messageBatch));
Exchange.SendMessage(CustomJsonSerializer.MessageToBytes(messageBatch), RoutingKey, batch.JobIdentifier);
}
public void CamelCaseListTest()
{
//setup
var model = new List <CamelModel>
{
new CamelModel
{
FirstName = "first",
DateOfBirth = new DateTime(1980, 4, 1),
Gender = Gender.Male
},
new CamelModel
{
FirstName = "second",
DateOfBirth = new DateTime(1981, 4, 1),
Gender = Gender.Female
}
};
var serializer = new CustomJsonSerializer();
serializer.JsonContractResolver = new CamelCasePropertyNamesContractResolver();
var st = serializer.Serialize(model);
//act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters, resolver: (DefaultContractResolver)serializer.JsonContractResolver);
var output = deserializer.Deserialize <List <CamelModel> >(st);
//assert
AssertCamelModel(model[0], output[0]);
AssertCamelModel(model[1], output[1]);
}
public void JsonSerializerWithEnumConverterShouldConvertEnumToStringValues()
{
// Arrange
var testClass = new TestFoo
{
Gender = Gender.Female,
GenderNullable = Gender.Male
};
var serializer = new CustomJsonSerializer
{
JsonConverters = new JsonConverter[]
{
new EnumValueConverter(),
new NullableEnumValueConverter()
}
};
const string expected = "{\r\n \"Gender\": \"Female\",\r\n \"GenderNullable\": \"Male\"\r\n}";
// Act
var result = serializer.Serialize(testClass);
// Assert
Assert.Equal(expected, result);
}
public virtual void Consumer_ReceiveMessage(IBasicGetResult message)
{
ContinueProcessing = false;
if (message == null)
{
return; // queue is empty
}
Message = CustomJsonSerializer.BytesToMessage <T>(message.Body);
CorrelationId = message.BasicProperties.CorrelationId;
RoutingKey = message.RoutingKey;
if (message.Body.Count() == 0)
{
Log.Error(
"SubscriberBase: Consumer_ReceiveMessage(message) - message.Body contains no data for message id {0}",
message.BasicProperties.MessageId);
}
if (Message != null)
{
ContinueProcessing = true;
return;
}
if (message.Body.Count() > 0)
{
Log.Error("SubscriberBase: Consumer_ReceiveMessage(message) - message.Body contains data which is not compatible with {0} for message id {1}", typeof(T).ToString(), message.BasicProperties.MessageId);
}
InvalidExchange.SendMessage(message.Body, InvalidRoutingKey, "");
}
public void CamelCaseListTest()
{
//setup
var model = new List<CamelModel>
{
new CamelModel
{
FirstName = "first",
DateOfBirth = new DateTime(1980, 4, 1),
Gender = Gender.Male
},
new CamelModel
{
FirstName = "second",
DateOfBirth = new DateTime(1981, 4, 1),
Gender = Gender.Female
}
};
var serializer = new CustomJsonSerializer();
serializer.JsonContractResolver = new CamelCasePropertyNamesContractResolver();
var st = serializer.Serialize(model);
//act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters, resolver: (DefaultContractResolver)serializer.JsonContractResolver);
var output = deserializer.Deserialize<List<CamelModel>>(st);
//assert
AssertCamelModel(model[0], output[0]);
AssertCamelModel(model[1], output[1]);
}
public async Task <string> React(PublicId userId, PublicId toId, ReactionType type)
{
var reaction = (ActivityObject)Activator.CreateInstance(CustomJsonSerializer.TypeOf(type.ToString()));
reaction.actor = new List <BaseObject> {
new Common.Person {
PublicId = userId,
}
}.ToCollection();
var target = await _activityContent.Get(toId, userId);
if (target != null)
{
reaction.target = new List <BaseObject> {
target
}.ToCollection();
var res = await _activityStream.Post("outbox", reaction);
return(reaction.id);
}
else
{
return(null);
}
}
/// <summary>
/// Executes a specified action proxy from an addon.
/// </summary>
/// <param name="actionProxy">The <see cref="ActionProxy"/> to execute.</param>
/// <param name="timeout">The action execution timeout (in milliseconds).</param>
/// <returns>The response from the Agent upon executing the action proxy.</returns>
public ActionExecutionResponse ExecuteProxy(ActionProxy actionProxy, int timeout)
{
RestRequest sendActionProxyRequest = new RestRequest(Endpoints.EXECUTE_ACTION_PROXY, Method.POST);
sendActionProxyRequest.RequestFormat = DataFormat.Json;
string json = CustomJsonSerializer.ToJson(actionProxy.ProxyDescriptor, this.serializerSettings);
sendActionProxyRequest.AddJsonBody(json);
if (timeout > 0)
{
// Since action proxy execution can take a while, you can override the default timeout.
this.client.Timeout = timeout;
}
IRestResponse sendActionProxyResponse = this.client.Execute(sendActionProxyRequest);
if (sendActionProxyResponse.StatusCode.Equals(HttpStatusCode.NotFound))
{
string errorMessage = $"Action {actionProxy.ProxyDescriptor.ClassName} in addon {actionProxy.ProxyDescriptor.Guid} is not installed for your account.";
Logger.Error(errorMessage);
throw new AddonNotInstalledException(errorMessage);
}
// Reset the client timeout to the RestSharp default.
this.client.Timeout = this.defaultRestClientTimeoutInMilliseconds;
return(CustomJsonSerializer.FromJson <ActionExecutionResponse>(sendActionProxyResponse.Content, this.serializerSettings));
}
/// <summary>
/// Retrieves the version of the Agent currently in use.
/// </summary>
/// <returns>An instance of the <see cref="Version"/> class containing the Agent version.</returns>
private Version GetAgentVersion()
{
RestRequest getAgentStatusRequest = new RestRequest(Endpoints.STATUS, Method.GET);
IRestResponse getAgentStatusResponse = this.client.Execute(getAgentStatusRequest);
if (getAgentStatusResponse.ErrorException != null)
{
string errorMessage = $"An error occurred connecting to the Agent. Is your Agent running at {this.remoteAddress}?";
Logger.Error(errorMessage);
throw new AgentConnectException(errorMessage);
}
if ((int)getAgentStatusResponse.StatusCode >= 400)
{
throw new AgentConnectException($"Failed to get Agent status: {getAgentStatusResponse.ErrorMessage}");
}
AgentStatusResponse agentStatusResponse = CustomJsonSerializer.FromJson <AgentStatusResponse>(getAgentStatusResponse.Content, this.serializerSettings);
Logger.Info($"Current Agent version is {agentStatusResponse.Tag}");
return(new Version(agentStatusResponse.Tag));
}
/// <summary>
/// Starts a new session with the Agent.
/// </summary>
/// <param name="reportSettings">Settings (project name, job name) to be included in the report.</param>
/// <param name="capabilities">Additional options to be applied to the driver instance.</param>
private void StartSession(ReportSettings reportSettings, DriverOptions capabilities)
{
RestRequest startSessionRequest = new RestRequest(Endpoints.DEVELOPMENT_SESSION, Method.POST);
startSessionRequest.RequestFormat = DataFormat.Json;
string json = CustomJsonSerializer.ToJson(new SessionRequest(reportSettings, capabilities), this.serializerSettings);
startSessionRequest.AddJsonBody(json);
IRestResponse startSessionResponse = this.client.Execute(startSessionRequest);
if (startSessionResponse.ErrorException != null)
{
string errorMessage = $"An error occurred connecting to the Agent. Is your Agent running at {this.remoteAddress}?";
Logger.Error(errorMessage);
throw new AgentConnectException(errorMessage);
}
if ((int)startSessionResponse.StatusCode >= 400)
{
this.HandleSessionStartFailure(startSessionResponse);
return;
}
this.StartSdkSession(startSessionResponse, capabilities);
// Only retrieve the Agent version when it has not yet been set
if (this.agentVersion == null)
{
this.agentVersion = this.GetAgentVersion();
}
}
private void LogIn()
{
List <Person> persons;
if (!File.Exists(usersFile))
{
MessageBox.Show("Oooops...Something was wrong!");
return;
}
using (CustomJsonSerializer <List <Person> > serializer = new CustomJsonSerializer <List <Person> >())
{
persons = serializer.DeserializeFromFile(usersFile);
}
if (!persons.Any(p => p.AccountNumber == loginBox.Text && p.Password == passwordBox.Text))
{
MessageBox.Show("Incorrect login or password!");
return;
}
currentPerson = persons.Find(p => p.AccountNumber == loginBox.Text);
loginBox.Enabled = false;
passwordBox.Enabled = false;
signInButton.Enabled = false;
signUpButton.Enabled = false;
InitializeChainFromStore();
}
/// <summary>
/// Overriding the base method to handle reports at batches.
/// While there are reports in the queue - collect up to 10 reports and send them at batch.
/// </summary>
/// <exception>FailedReportException if cannot send report to the agent more than <see cref="MaxReportFailureAttempts"/> attempts.</exception>
protected override void HandleReport()
{
// LinkedList to store the reports batch before sending them.
LinkedList <Report> batchReports = new LinkedList <Report>();
// Extract and remove up to 10 items or till queue is empty from queue - without blocking it.
while (this.ReportItems.Count > 0 && batchReports.Count < this.maxBatchSize)
{
QueueItem item;
// Get the first item in the queue without blocking it.
bool taken = this.ReportItems.TryTake(out item);
if (taken && item != null && item.Report != null)
{
batchReports.AddLast(item.Report);
}
}
if (batchReports.Count == 0)
{
return;
}
// Build REST request.
RestRequest sendReportsBatchRequest = new RestRequest(Endpoints.REPORT_BATCH, Method.POST);
sendReportsBatchRequest.RequestFormat = DataFormat.Json;
string json = CustomJsonSerializer.ToJson(batchReports, this.serializerSettings);
sendReportsBatchRequest.AddJsonBody(json);
this.SendReport(sendReportsBatchRequest);
}
/// <summary>
/// Invoke a synchronous service with the specified payload. The method call block until the method return.
/// </summary>
/// <typeparam name="TI">The payload type.</typeparam>
/// <typeparam name="TO">The return type.</typeparam>
/// <param name="serviceName">The name of the service, as configured in Argilla.Node.ServiceName.</param>
/// <param name="payload">The payload used for invoke the service.</param>
/// <returns></returns>
public static TO Invoke <TI, TO>(string serviceName, TI payload)
{
TO outputValue = default;
PayloadSync payloadSync = new PayloadSync()
{
Payload = payload
};
string json = CustomJsonSerializer.Serialize(payloadSync);
Exception lastException = null;
try
{
Endpoint endpoint = GetFreeEndpoint(serviceName);
string jsonResult = HttpHelper.Post(endpoint.EndpointSync, json);
outputValue = CustomJsonSerializer.Deserialize <TO>(jsonResult);
lastException = null;
}
catch (Exception ex)
{
logger.Error(ex.Message);
ResolveResponse resolveResponse = Resolve(serviceName);
foreach (Endpoint endpoint in resolveResponse.Endpoints)
{
try
{
string jsonResult = HttpHelper.Post(endpoint.EndpointSync, json);
outputValue = CustomJsonSerializer.Deserialize <TO>(jsonResult);
lastException = null;
break;
}
catch (Exception e)
{
lastException = e;
}
}
}
if (lastException != null)
{
logger.Error(lastException, lastException.Message);
throw lastException;
}
logger.Debug(String.Format("Output value: {0}", outputValue));
return(outputValue);
}
/// <summary>
/// Initializes a new instance of the <see cref="AgentClient"/> class.
/// </summary>
/// <param name="remoteAddress">The remote address where the Agent is running.</param>
/// <param name="token">The development token used to authenticate with the Agent.</param>
/// <param name="capabilities">Requested driver options for the browser session.</param>
/// <param name="reportSettings">Contains the project and job name to report to TestProject.</param>
/// <param name="disableReports">Set to true to disable all reporting to TestProject, false otherwise.</param>
/// <param name="compatibleVersion">Minimum Agent version that supports the requested feature. Can be used to check Agent compatibility.</param>
private AgentClient(Uri remoteAddress, string token, DriverOptions capabilities, ReportSettings reportSettings, bool disableReports, Version compatibleVersion = null)
{
this.remoteAddress = this.InferRemoteAddress(remoteAddress);
ReportSettings sessionReportSettings = disableReports ? null : this.InferReportSettings(reportSettings);
this.reportSettings = sessionReportSettings;
if (token != null)
{
this.token = token;
}
else if (Environment.GetEnvironmentVariable(this.tpDevToken) != null)
{
this.token = Environment.GetEnvironmentVariable(this.tpDevToken);
}
else
{
throw new InvalidTokenException("No token has been provided.");
}
this.client = new RestClient(this.remoteAddress);
this.client.AddDefaultHeader("Authorization", this.token);
this.serializerSettings = CustomJsonSerializer.Populate(new JsonSerializerSettings());
// Check that Agent version supports the requested feature.
if (compatibleVersion != null)
{
Logger.Trace($"Checking if the Agent version is {compatibleVersion} at minimum");
agentVersion = this.GetAgentVersion();
if (agentVersion.CompareTo(compatibleVersion) < 0)
{
throw new AgentConnectException($"Current Agent version {agentVersion} does not support the requested feature," +
$" should be at least {compatibleVersion}");
}
}
this.reportsQueue = new ReportsQueue(this.client);
this.StartSession(sessionReportSettings, capabilities);
// Verify the agent version supports local report generation
this.VerifyIfLocalReportsIsSupported(reportSettings.ReportType);
// Show local report path only when executing on local agents.
if (this.client.BaseUrl.IsLocal())
{
Logger.Info($"Execution Report: {this.sessionResponse.LocalReport}");
}
if (!string.IsNullOrWhiteSpace(this.sessionResponse.LocalReportUrl))
{
Logger.Info($"Execution Report Link: {this.sessionResponse.LocalReportUrl}");
}
}
public async Task <BaseObject> Get(PublicId id, PublicId viewerId)
{
var target = (BaseObject)Activator.CreateInstance(CustomJsonSerializer.TypeOf(id.Type));
target.PublicId = id;
await BindSqlContent(target);
return(target);
}
/// <summary>
/// Converts action parameters to a format understood by the Agent.
/// </summary>
/// <param name="actionProxy">The <see cref="ActionProxy"/> for which the parameters should be formatted.</param>
/// <returns>A formatted set of action parameters.</returns>
private Dictionary <string, object> FormatParameters(ActionProxy actionProxy)
{
string actionProxyAsJson = CustomJsonSerializer.ToJson(actionProxy, CustomJsonSerializer.Populate(new JsonSerializerSettings()));
Dictionary <string, object> actionParameters = JsonConvert.DeserializeObject <Dictionary <string, object> >(actionProxyAsJson);
actionParameters.Remove("proxyDescriptor");
return(actionParameters);
}
public RegisterResponse Unregister(RegisterRequest registerRequest)
{
string resolverBaseAddress = ArgillaSettings.Current.Resolver.BaseAddress.EndsWith("/") ? ArgillaSettings.Current.Resolver.BaseAddress : ArgillaSettings.Current.Resolver.BaseAddress + "/";
string resolverAddress = resolverBaseAddress + "unregister";
string json = CustomJsonSerializer.Serialize(registerRequest);
logger.Debug(String.Format("Registration request: {0}", json));
string result = HttpHelper.Post(resolverAddress, json);
return(CustomJsonSerializer.Deserialize <RegisterResponse>(result));
}
/// <summary>
/// Sends a <see cref="StepReport"/> to the Agent.
/// </summary>
/// <param name="stepReport">The payload object containing the step details to be reported.</param>
public void ReportStep(StepReport stepReport)
{
RestRequest sendStepReportRequest = new RestRequest(Endpoints.REPORT_STEP, Method.POST);
sendStepReportRequest.RequestFormat = DataFormat.Json;
string json = CustomJsonSerializer.ToJson(stepReport, this.serializerSettings);
sendStepReportRequest.AddJsonBody(json);
this.reportsQueue.Submit(sendStepReportRequest, stepReport);
}
private void UpdateChainInfo()
{
var files = Directory.GetFiles(folderUsersData);
foreach (var file in files)
{
using (CustomJsonSerializer <Chain> serializer = new CustomJsonSerializer <Chain>())
{
serializer.SerializeToFile(Chain, file);
}
}
}
static JiraRestClient()
{
JsConfig.DateHandler = JsonDateHandler.ISO8601;
#if DEBUG
Debug = true;
#endif
CustomJsonSerializer.RegisterAllClasses();
ServiceClientBase.HttpWebRequestFilter = HttpWebRequestFilter;
ServiceClientBase.HttpWebResponseFilter = HttpWebResponseFilter;
}
public BusBootstrapper(
IWindsorContainer container,
string connectionString,
string prefix,
IMessagesTracker messagesTracker)
{
this._container = container;
this._connectionString = connectionString;
CustomSerializer = new CustomJsonSerializer();
Prefix = prefix;
MessagesTracker = messagesTracker;
}
/// <summary>
/// Reports a WebDriver command to TestProject.
/// </summary>
/// <param name="driverCommandReport">Payload object containing command information and execution result.</param>
public void ReportDriverCommand(DriverCommandReport driverCommandReport)
{
RestRequest sendDriverCommandRequest = new RestRequest(Endpoints.REPORT_COMMAND, Method.POST);
sendDriverCommandRequest.RequestFormat = DataFormat.Json;
string json = CustomJsonSerializer.ToJson(driverCommandReport, this.serializerSettings);
sendDriverCommandRequest.AddJsonBody(json);
this.reportsQueue.Submit(sendDriverCommandRequest, driverCommandReport);
}
private void InitializeChainFromStore()
{
var path = Path.Combine(folderUsersData, ChainFilePattern());
using (CustomJsonSerializer <Chain> serializer = new CustomJsonSerializer <Chain>())
{
Chain = serializer.DeserializeFromFile(path) ?? new Chain();
while (Chain.Blocks.Count(b => b.Index == 0) > 1)
{
Chain.Blocks.Remove(Chain.Blocks.First(b => b.Index == 0));
}
}
}
private static IRestClient GetClient()
{
var client = new RestClient
{
BaseUrl = new Uri("https://min-api.cryptocompare.com/data/")
};
var settings = new JsonSerializerSettings();
settings.Converters.Add(new NAConverter());
var serializer = new CustomJsonSerializer(settings);
client.AddHandler(serializer.ContentType, serializer);
return(client);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReportsQueueBatch"/> class.
/// </summary>
/// <param name="client">The <see cref="RestClient"/> HTTP client to send reports to the Agent.</param>
public ReportsQueueBatch(RestClient client)
: base(client)
{
this.serializerSettings = CustomJsonSerializer.Populate(new JsonSerializerSettings());
// Override default converter of enum to string since agent is case sensitive.
this.serializerSettings.Converters.Clear();
this.serializerSettings.Converters.Add(new StringEnumConverter());
// Try to get maximum report batch size from env variable.
string tpMaxBatchSizeEnvVal = Environment.GetEnvironmentVariable(TpMaxBatchSizeVariableName);
this.maxBatchSize = (tpMaxBatchSizeEnvVal != null) ? int.Parse(tpMaxBatchSizeEnvVal) : MaxReportsBatchSize;
}
/// <summary>
/// Deserializes from JSON converting all JARRAYS to associative
/// arrays...
/// </summary>
/// <typeparam name="TType"></typeparam>
/// <param name="value"></param>
/// <returns></returns>
public static object DeserializeObject(string value, Type targetType)
{
using (var strReader = new StringReader(value))
{
using (var jsonReader = new CustomJsonTextReader(strReader))
{
var resolver = new CustomContractResolver();
var serializer = new CustomJsonSerializer {
ContractResolver = resolver, ObjectCreationHandling = ObjectCreationHandling.Replace
};
object unserialized = serializer.Deserialize(jsonReader, targetType);
return(unserialized);
}
}
}
public ActionResult Resolve([FromBody] ResolveRequest resolveRequest)
{
securityManager.Verify(new SecurityAssertion()
{
Payload = resolveRequest
});
logger.Info("Resolve: " + CustomJsonSerializer.Serialize(resolveRequest));
ResolveResponse resolveResponse = new ResolveResponse();
resolveResponse.Endpoints = storageManager.Resolve(resolveRequest);
return(new JsonResult(resolveResponse));
}
public void SerializeTimeSpan()
{
// Arrange
var serializer = new CustomJsonSerializer { JsonConverters = GraphClient.DefaultJsonConverters };
var value = new TimeSpan(400, 13, 3, 2,10);
var model = new TimeSpanModel
{
Foo = value
};
// Act
var result = serializer.Serialize(model.Foo);
// Assert
Assert.AreEqual("400.13:03:02.0100000", result.Replace("\"", ""));
}
public void DeserializeGuidWithDefaultJsonConverters()
{
//Arrage
var myGuid = Guid.NewGuid();
var foo = new EnumerableModel { Guids = new List<Guid> { myGuid } };
// Act
var customSerializer = new CustomJsonSerializer{JsonConverters = GraphClient.DefaultJsonConverters};
var testStr = customSerializer.Serialize(foo);
var customDeserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters);
var result = customDeserializer.Deserialize<EnumerableModel>(testStr);
// Assert
Assert.AreEqual(myGuid, result.Guids.First());
}
public void JsonSerializerShouldSerializeTimeZoneInfo()
{
// Arrange
var serializer = new CustomJsonSerializer
{
JsonConverters = GraphClient.DefaultJsonConverters
};
const string ausEasternStandardTime = "AUS Eastern Standard Time";
var timeZoneData = TimeZoneInfo.FindSystemTimeZoneById(ausEasternStandardTime);
// Act
var result = serializer.Serialize(timeZoneData);
// Assert
Assert.AreEqual(ausEasternStandardTime, result.Replace("\"",""));
}
public void JsonSerializerShouldSerializeAllProperties()
{
// Arrange
var testNode = new TestNode { Foo = "foo", Bar = "bar" };
var serializer = new CustomJsonSerializer
{
NullHandling = NullValueHandling.Ignore,
JsonConverters = GraphClient.DefaultJsonConverters
};
// Act
var result = serializer.Serialize(testNode);
const string expectedValue = "{\r\n \"Foo\": \"foo\",\r\n \"Bar\": \"bar\"\r\n}";
// Assert
Assert.AreEqual(expectedValue, result);
}
public void ShouldSerializeDateTimeOffsetInCorrectStringFormat()
{
//Arrange
var serializer = new CustomJsonSerializer { JsonConverters = GraphClient.DefaultJsonConverters };
var model = new DateOffsetModel
{
DateTime = DateTimeOffset.Parse("2012-08-31T00:11:00.3642578+10:00"),
DateTimeNullable = DateTimeOffset.Parse("2012-08-31T00:11:00.3642578+10:00")
};
//Act
var actual = serializer.Serialize(model);
//Assert
const string expected =
"{\r\n \"DateTime\": \"2012-08-31T00:11:00.3642578+10:00\",\r\n \"DateTimeNullable\": \"2012-08-31T00:11:00.3642578+10:00\"\r\n}";
Assert.AreEqual(expected, actual);
}
public void ShouldSerializeDateTimeInCorrectStringFormat(string dateTimeStr)
{
//Arrange
var serializer = new CustomJsonSerializer { JsonConverters = GraphClient.DefaultJsonConverters };
var model = new DateModel
{
DateTime = DateTime.Parse(dateTimeStr, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal),
DateTimeNullable = DateTime.Parse(dateTimeStr, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal)
};
//Act
var actual = serializer.Serialize(model);
//Assert
var expected =
"{\r\n \"DateTime\": \"" + dateTimeStr + "\",\r\n \"DateTimeNullable\": \"" + dateTimeStr + "\"\r\n}";
Assert.AreEqual(expected, actual);
}
public void JsonSerializerShouldSerializeEnumToString()
{
// Arrange
var testNode = new TestNodeWithEnum { Status = TestEnum.Value1 };
var serializer = new CustomJsonSerializer
{
NullHandling = NullValueHandling.Ignore,
JsonConverters = new []{new EnumValueConverter()}
};
// Act
var result = serializer.Serialize(testNode);
const string expectedValue = "{\r\n \"Status\": \"Value1\"\r\n}";
// Assert
Assert.AreEqual(expectedValue, result);
}
public void CamelCaseTest()
{
//setup
var model = new CamelModel
{
FirstName = "first",
DateOfBirth = new DateTime(1980, 4, 1),
Gender = Gender.Male,
S = "short property"
};
var serializer = new CustomJsonSerializer();
serializer.JsonContractResolver = new CamelCasePropertyNamesContractResolver();
var st = serializer.Serialize(model);
//act
var deserializer = new CustomJsonDeserializer(GraphClient.DefaultJsonConverters, resolver: (DefaultContractResolver)serializer.JsonContractResolver);
var output = deserializer.Deserialize<CamelModel>(st);
//assert
AssertCamelModel(model, output);
}
public void ShouldSerializeBuiltInTypeThatHasTypeConverterUsingTypeConverterBasedJsonConverter()
{
//Arrange
var serializer = new CustomJsonSerializer
{
JsonConverters = new[] { new TypeConverterBasedJsonConverter() }
};
var model = new TestModelC
{
MyPoint = new System.Drawing.Point(100, 200)
};
//Act
var rawResult = serializer.Serialize(model);
//Assert
const string expectedRawOutput =
"{\r\n \"MyPoint\": \"100, 200\"\r\n}";
Assert.AreEqual(expectedRawOutput, rawResult);
}
public void ShouldSerializeNullableInt32ToJsonNumberUsingDefaultJsonConverters()
{
// Arrange
var testNode = new NodeWithBuiltInTypes { Foo = 123 };
var serializer = new CustomJsonSerializer
{
NullHandling = NullValueHandling.Ignore,
JsonConverters = GraphClient.DefaultJsonConverters
};
// Act
var result = serializer.Serialize(testNode);
const string expectedValue = "{\r\n \"Foo\": 123\r\n}";
// Assert
Assert.AreEqual(expectedValue, result);
}
/// <summary>
/// Most of the work happens here for generating the hook up script code
/// </summary>
/// <param name="e"></param>
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
// MS AJAX aware script management
ClientScriptProxy scriptProxy = ClientScriptProxy.Current;
// Register resources
RegisterResources(scriptProxy);
string dateFormat = DateFormat;
if (string.IsNullOrEmpty(dateFormat) || dateFormat == "Auto")
{
// Try to create a data format string from culture settings
// this code will fail if culture can't be mapped on server hence the empty try/catch
try
{
dateFormat = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern;
}
catch { }
}
dateFormat = dateFormat.ToLower().Replace("yyyy", "yy");
// Capture and map the various option parameters
StringBuilder sbOptions = new StringBuilder(512);
sbOptions.Append("{");
string onSelect = OnClientSelect;
if (DisplayMode == DatePickerDisplayModes.Button)
sbOptions.Append("showOn: 'button',");
else if (DisplayMode == DatePickerDisplayModes.ImageButton)
{
string img = ButtonImage;
if (img == "WebResource")
img = scriptProxy.GetWebResourceUrl(this, typeof(ControlResources), ControlResources.CALENDAR_ICON_RESOURCE);
else
img = ResolveUrl(ButtonImage);
sbOptions.Append("showOn: 'button', buttonImageOnly: true, buttonImage: '" + img + "',buttonText: 'Select date',");
}
else if (DisplayMode == DatePickerDisplayModes.Inline)
{
// need to store selection in the page somehow for inline since it's
// not tied to a textbox
scriptProxy.RegisterHiddenField(this, ClientID, Text);
onSelect = ClientID + "OnSelect";
}
if (!string.IsNullOrEmpty(onSelect))
sbOptions.Append("onSelect: " + onSelect + ",");
if (DisplayMode != DatePickerDisplayModes.Inline)
{
if (!string.IsNullOrEmpty(OnClientBeforeShow))
sbOptions.Append("beforeShow: function(y,z) { $('#ui-datepicker-div').maxZIndex(); " +
OnClientBeforeShow + "(y,z); },");
else
sbOptions.Append("beforeShow: function() { $('#ui-datepicker-div').maxZIndex(); },");
}
if (MaxDate.HasValue)
sbOptions.Append("maxDate: " + UrlUtils.EncodeJsDate(MaxDate.Value) + ",");
if (MinDate.HasValue)
sbOptions.Append("minDate: " + UrlUtils.EncodeJsDate(MinDate.Value) + ",");
if (ShowButtonPanel)
sbOptions.Append("showButtonPanel: true,");
sbOptions.Append("dateFormat: '" + dateFormat + "'}");
// Write out initilization code for calendar
StringBuilder sbStartupScript = new StringBuilder(400);
sbStartupScript.AppendLine("$( function() {");
if (DisplayMode != DatePickerDisplayModes.Inline)
{
scriptProxy.RegisterClientScriptBlock(Page,
typeof(ControlResources),
"__attachDatePickerInputKeys",
AttachDatePickerKeysScript, true);
sbStartupScript.AppendFormat("var cal = jQuery('#{0}').datepicker({1}).attachDatepickerInputKeys();\r\n",
ClientID, sbOptions);
}
else
{
sbStartupScript.AppendLine("var cal = jQuery('#" + ClientID + "Div').datepicker(" + sbOptions.ToString() + ")");
if (SelectedDate.HasValue && SelectedDate.Value > new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc))
{
CustomJsonSerializer ser = new CustomJsonSerializer();
ser.DateSerializationMode = JsonDateEncodingModes.NewDateExpression;
string jsDate = ser.Serialize(SelectedDate);
sbStartupScript.AppendLine("cal.datepicker('setDate'," + jsDate + ");");
}
else
sbStartupScript.AppendLine("cal.datepicker('setDate',new Date());");
// Assign value to hidden form var on selection
scriptProxy.RegisterStartupScript(this, typeof(ControlResources), UniqueID + "OnSelect",
"function " + ClientID + "OnSelect(dateStr) {\r\n" +
((!string.IsNullOrEmpty(OnClientSelect)) ? OnClientSelect + "(dateStr);\r\n" : "") +
"jQuery('#" + ClientID + "')[0].value = dateStr;\r\n}\r\n", true);
}
sbStartupScript.AppendLine("} );");
scriptProxy.RegisterStartupScript(Page, typeof(ControlResources), "_cal" + UniqueID,
sbStartupScript.ToString(), true);
}
public void ShouldSerializeCustomValueWithCustomJsonConverter()
{
//Arrange
var serializer = new CustomJsonSerializer
{
JsonConverters = new []{new TestValueAConverter()}
};
var model = new TestModelA
{
CustomValue = new TestValueA
{
A = 'o',
B = 'p'
}
};
//Act
var rawResult = serializer.Serialize(model);
//Assert
const string expectedRawOutput =
"{\r\n \"CustomValue\": \"op\"\r\n}";
Assert.AreEqual(expectedRawOutput, rawResult);
}
public void SetUp()
{
_sut = new CustomJsonSerializer();
}
public void JsonSerializerWithEnumConverterShouldConvertEnumToStringValues()
{
// Arrange
var testClass = new TestFoo
{
Gender = Gender.Female,
GenderNullable = Gender.Male
};
var serializer = new CustomJsonSerializer
{
JsonConverters = new JsonConverter[]
{
new EnumValueConverter(),
new NullableEnumValueConverter()
}
};
const string expected = "{\r\n \"Gender\": \"Female\",\r\n \"GenderNullable\": \"Male\"\r\n}";
// Act
var result = serializer.Serialize(testClass);
// Assert
Assert.AreEqual(expected, result);
}
public void ShouldSerializeNullableBoolToJsonBooleanUsingDefaultJsonConverters()
{
// Arrange
var testNode = new NodeWithBuiltInTypes { Bar = true };
var serializer = new CustomJsonSerializer
{
NullHandling = NullValueHandling.Ignore,
JsonConverters = GraphClient.DefaultJsonConverters
};
// Act
var result = serializer.Serialize(testNode);
const string expectedValue = "{\r\n \"Bar\": true\r\n}";
// Assert
Assert.AreEqual(expectedValue, result);
}
