public void BasicTypes()
{
var data = new BasicTypesBag
{
Bool = true,
Byte = 100,
Bytes = new byte[] { 1, 2, 60 },
Char = '鬱',
DateTime = DateTime.Parse("2017-08-20 20:34:56"),
Decimal = 23567890.56m,
Double = 234.56546342,
Float = 65.2344f,
Guid = Guid.NewGuid(),
Int = 55232,
Long = 63465463456345634,
SByte = -120,
Short = 4231,
String = "lorem ipsum",
TimeSpan = TimeSpan.FromMinutes(43),
UInt = 2323423423,
ULong = 2345234232345423452,
UShort = 15340
};
JsonConvert.Serialize(data).ShouldBeEquivalentTo(Newton.SerializeObject(data));
}
public async Task Delete(Passenger passengerIn)
{
passengerIn.Enabled = false;
_passengers.ReplaceOne(passenger => passenger.Id == passengerIn.Id, passengerIn);
await _producer.WriteMessage(_kafkaTopics.Delete, JsonConvert.SerializeObject(passengerIn));
}
public void ShouldQueueOneSmsForOneOrMoreExpiringDrafts(
int expiringDraftCount, MessageTypes expectedMessageType)
{
// Arrange.
var candidate = new CandidateBuilder(Guid.NewGuid())
.EnableAllCommunications()
.Build();
AddCandidate(candidate);
var expiringDrafts = new ExpiringApprenticeshipApplicationDraftsBuilder()
.WithExpiringDrafts(expiringDraftCount)
.Build();
var json = JsonConvert.SerializeObject(expiringDrafts);
var communicationRequest = new CommunicationRequestBuilder(MessageTypes.DailyDigest, candidate.EntityId)
.WithToken(CommunicationTokens.ExpiringDrafts, json)
.WithToken(CommunicationTokens.ApplicationStatusAlerts, null)
.Build();
// Act.
Command.Handle(communicationRequest);
// Assert.
ShouldQueueSms(expectedMessageType, 1);
}
public static void SendMail(string[] toEmails, string subject, string templateName, JObject model, string fromEmail, string[] attachments)
{
// dynamic input from inbound JSON
dynamic json = model;
string jsonAsString = JsonConvert.SerializeObject(json);
List <Attachment> mailAttachments = null;
if (attachments != null)
{
mailAttachments = (from attachment in attachments where !string.IsNullOrEmpty(attachment) select new Attachment(attachment)).ToList();
}
if (toEmails != null && toEmails.Any())
{
toEmails.ToList().ForEach(email =>
{
var request = new SendMail
{
To = email,
Subject = subject,
TemplateName = templateName,
ModelInJsonAsString = jsonAsString,
From = fromEmail,
};
SendMail(request, mailAttachments);
});
}
}
public static void Save(string fileName, object value)
{
using (var sw = new System.IO.StreamWriter(fileName))
{
sw.Write(JC.SerializeObject(value));
}
}
public Chart GetChart(ValCurs valCurs, string minVal, string title)
{
if (valCurs?.Record != null)
{
return new Chart
{
YValues = JsonConvert.SerializeObject(
valCurs.Record.Select(valCursRecord => valCursRecord.Value).ToList()
),
XLabels = JsonConvert.SerializeObject(
valCurs.Record.Select(valCursRecord => valCursRecord.Date).ToList()
),
MinYValues = minVal,
Title = title
}
}
;
return(new Chart
{
YValues = "[\"0,0\"]",
XLabels = "[]",
MinYValues = minVal,
Title = title
});
}
}
private async Task <ReportStrategyResult> GetProviderApplicationsAsync(long ukprn, DateTime fromDate, DateTime toDate)
{
var collection = GetCollection <BsonDocument>();
var queryJson = QueryFormat
.Replace(QueryUkprn, ukprn.ToString())
.Replace(QueryFromDate, fromDate.ToString("o"))
.Replace(QueryToDate, toDate.ToString("o"));
var bson = MongoDB.Bson.Serialization.BsonSerializer.Deserialize <BsonDocument[]>(queryJson);
var results = await RetryPolicy.ExecuteAsync(_ =>
collection.Aggregate <BsonDocument>(bson).ToListAsync(),
new Context(nameof(GetProviderApplicationsAsync)));
await ProcessResultsAsync(results);
_logger.LogInformation($"Report parameters ukprn:{ukprn} fromDate:{fromDate} toDate:{toDate} returned {results.Count} results");
var dotNetFriendlyResults = results.Select(BsonTypeMapper.MapToDotNetValue);
var data = JsonConvert.SerializeObject(dotNetFriendlyResults);
var headers = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("Date", _timeProvider.Now.ToUkTime().ToString("dd/MM/yyyy HH:mm:ss")),
new KeyValuePair <string, string>("Total_Number_Of_Applications", results.Count.ToString())
};
return(new ReportStrategyResult(headers, data));
}
public async Task Invoke(HttpContext httpContext)
{
try
{
await _next(httpContext);
}
catch (Exception ex)
{
string message;
if (ex is BusinessLogicException)
{
message = ex.Message;
}
else
{
throw;
}
Log.Error(ex.ToString());
httpContext.Response.Clear();
httpContext.Response.StatusCode = 400;
httpContext.Response.ContentType = "application/json; charset=utf-8";
httpContext.Response.Headers.Add("Access-Control-Allow-Origin", "*");
string json = JsonConvert.SerializeObject(new { message = message });
await httpContext.Response.WriteAsync(json);
}
}
public void ByteArray()
{
var data = Encoding.UTF8.GetBytes("sample data for binary serialization.");
_writer.Write(data);
_sw.ToString().ShouldBeEquivalentTo(Newton.SerializeObject(data));
}
public string serialize(object objectToSerialize, bool suppressApexObjectNulls)
{
var settings = new JsonSerializerSettings();
settings.NullValueHandling = suppressApexObjectNulls ? NullValueHandling.Ignore : NullValueHandling.Include;
return(JsonConvert.SerializeObject(objectToSerialize, settings));
}
public IActionResult Index()
{
#if DEBUG
if (_first_req)
{
_first_req = false;
Auth.Login(HttpContext, "*****@*****.**", "pcdcss", db);
return(Redirect("/"));
}
#endif
var list = db.Uploads
.Find(u => u.featured)
.Select(u =>
{
var m = db.Material.FindAll().First();
return(new FeaturedModel()
{
upload = u,
material = m,
menor_preco = m.PrecoPeca(u)
});
})
.ToList()
.Shuffle()
.ToList();
ViewBag.json_featured = JSON.SerializeObject(list);
return(View(list));
}
public void ShouldHandleCandidateDailyDigestContainingOneOrMoreExpiringDraft()
{
// Arrange.
var candidate = new CandidateBuilder(Guid.NewGuid())
.EnableAllCommunications()
.Build();
AddCandidate(candidate);
var expiringDrafts = new ExpiringApprenticeshipApplicationDraftsBuilder()
.WithExpiringDrafts(1)
.Build();
var json = JsonConvert.SerializeObject(expiringDrafts);
var communicationRequest = new CommunicationRequestBuilder(MessageTypes.DailyDigest, candidate.EntityId)
.WithToken(CommunicationTokens.ExpiringDrafts, json)
.WithToken(CommunicationTokens.ApplicationStatusAlerts, null)
.Build();
// Act.
var canHandle = Command.CanHandle(communicationRequest);
// Assert.
canHandle.Should().BeTrue();
}
public ActionResult Create(Event incomingevent)
{
try
{
string eventasstring = JsonConvert.SerializeObject(incomingevent);
if (UniversalFunctions.ContainsSpecialChar(eventasstring))
{
ModelState.AddModelError("Cannot contain semi-colons", "Cannot contain semi-colons");
}
ModelState.Remove("NumberOfVolunteersNeeded");
ModelState.Remove("DateOfEvent");
ModelState.Remove("Duration");
if (ModelState.IsValid)
{
incomingevent._id = Guid.NewGuid().ToString();
incomingevent.DateOfEvent = incomingevent.DateOfEvent.AddHours(5);
eventManager.AddEventToDB(incomingevent);
return(RedirectToAction("Index"));
}
else
{
ViewBag.containsspecialchar = UniversalFunctions.ContainsSpecialChar(eventasstring);
return(View());
}
}
catch
{
return(RedirectToAction("Localserver", "Home"));
}
}
//Return last test data base on customer id
public string PercentageResult(string customerId)
{
var returnData = new List <Tuple <string, string, decimal, decimal, decimal, decimal> >();
if (string.IsNullOrEmpty(customerId))
{
return(JsonConvert.SerializeObject(returnData));
}
try
{
if (customerId == "TOFFSTECH" && CurrentAccount.Type.Equals("Toffstech_Admin"))
{
var domainList = hijackingDomainService.GetAll().Select(p => (p.Protocol + p.Domain)).Distinct().ToList();
var queryData = hijackingTestResultService.GetAllForAdminOnly();
returnData = PercentagesCalculation(domainList, queryData).OrderByDescending(p => p.Item5).ToList();
}
else
{
var domainList = hijackingDomainService.GetAllDomainByCustomerId(customerId).Select(p => (p.Protocol + p.Domain)).Distinct().ToList();
var queryData = hijackingTestResultService.GetAllForUser(domainList);
returnData = PercentagesCalculation(domainList, queryData).OrderByDescending(p => p.Item5).ToList();
}
}
catch (Exception ex)
{
log.Error(ex);
}
return(JsonConvert.SerializeObject(returnData));
}
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 <string> Get(string id)
{
var notes = await _repository.GetSingleRecord <PlayerStatistics>(id);
//notes.
return(JsonConvert.SerializeObject(notes));
}
public ActionResult Create(Sponsor incomingsponsor)
{
try
{
string sponsorasstring = JsonConvert.SerializeObject(incomingsponsor);
if (UniversalFunctions.ContainsSpecialChar(sponsorasstring))
{
ModelState.AddModelError("Cannot contain semi-colons", "Cannot contain semi-colons");
}
ModelState.Remove("Contract.RegistrationDate");
ModelState.Remove("Contract.ExpirationDate");
ModelState.Remove("Sponsorship.Date");
if (ModelState.IsValid)
{
incomingsponsor._id = Guid.NewGuid().ToString();
incomingsponsor.Contract.RegistrationDate = incomingsponsor.Contract.RegistrationDate.AddHours(5);
incomingsponsor.Contract.ExpirationDate = incomingsponsor.Contract.ExpirationDate.AddHours(5);
sponsorManager.AddSponsorToDB(incomingsponsor);
return(RedirectToAction("Index"));
}
else
{
ViewBag.containsspecialchar = UniversalFunctions.ContainsSpecialChar(sponsorasstring);
return(View());
}
}
catch
{
return(RedirectToAction("Localserver", "Home"));
}
}
public async Task <IActionResult> LogIn([FromBody] AuthDataModel data)
{
try
{
this.logger.LogInformation($"LogIn: {JsonConvert.SerializeObject(data)}");
var authToken =
await this.authService.ValidateAndLoginAsync(data.Login, data.Pass, data.IpAddress, data.City);
this.logger.LogInformation($"LogIn.Ok");
return(Ok(authToken));
}
catch (AuthenticationException ex)
{
this.logger.LogError($"LogIn.AuthenticationException: {ex.Message}");
return(BadRequest("Provided credentials are invalid."));
}
catch (ArgumentNullException ex)
{
this.logger.LogError($"LogIn.ArgumentNullException: {ex.Message}");
return(BadRequest("Incorect parameters values."));
}
catch (Exception ex)
{
this.logger.LogError($"LogIn.Exception: {ex.Message}");
throw;
}
}
public override string getTestList()
{
System.Diagnostics.Debug.WriteLine("从数据库获取有成绩的试卷列表...");
var cols = mcon.GetCollectionNames();
var tmpList = new List <String>();
#region 搜索在mongodb有试卷分数的试卷key
foreach (var i in cols)
{
if (i.StartsWith("Score:"))
{
var tmp = i.Remove(0, 6);
tmpList.Add(tmp);
}
}
#endregion
#region 获取搜索结果的试卷名称
for (var k = 0; k < tmpList.Count; k++)
{
foreach (DictionaryEntry j in DbBasic.testHT)
{
if (tmpList[k] == j.Value.ToString())
{
tmpList[k] = j.Key as String;
continue;
}
}
}
#endregion
return(JsonConvert.SerializeObject(tmpList));
}
public void given_a_valid_postInitialProcessDocumentRequest_when_postInitialProcessDocument_controller_method_is_called_then_the_controller_returns_correct_json_response()
{
//arange
PostInitialProcessDocumentRequest requestObject = MatProcessDataHelper.CreatePostInitialProcessDocumentRequestObject();
_mockValidatorPost.Setup(v => v.Validate(It.IsAny <PostInitialProcessDocumentRequest>())).Returns(new FV.ValidationResult()); //set up mock validation to return Validation with no errors.
var expectedResponse = new PostInitialProcessDocumentResponse(requestObject, requestObject.processRef, DateTime.Now);
_mockUsecase.Setup(g => g.ExecutePost(It.IsAny <PostInitialProcessDocumentRequest>())).Returns(expectedResponse);
////act
var actualResponse = _processDataController.PostInitialProcessDocument(requestObject);
var result = (ObjectResult)actualResponse;
var resultContent = (PostInitialProcessDocumentResponse)result.Value;
////assert
Assert.NotNull(actualResponse);
Assert.NotNull(result);
Assert.IsInstanceOf <PostInitialProcessDocumentResponse>(resultContent);
Assert.NotNull(resultContent);
Assert.AreEqual(expectedResponse.ProcessRef, resultContent.ProcessRef);
Assert.AreEqual(expectedResponse.GeneratedAt, resultContent.GeneratedAt);
Assert.AreEqual(expectedResponse.Request.processRef, resultContent.Request.processRef);
Assert.AreEqual(JsonConvert.SerializeObject(expectedResponse), JsonConvert.SerializeObject(resultContent));
}
public async Task <IActionResult> Edit(int id, [Bind("PageId,AddedDate,Title,Content,Description,UrlName")] Page page)
{
if (id != page.PageId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var query = _apiUrl + id;
var pageAsString = JSerializer.SerializeObject(page);
StringContent theContent = new StringContent(pageAsString, System.Text.Encoding.UTF8, "application/json");
await _httpClient.PutAsync(query, theContent);
}
catch (DbUpdateConcurrencyException)
{
if (!PageExists(page.PageId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(page));
}
private void LoadExcelDataNew(object sender, Chromium.Remote.Event.CfrV8HandlerExecuteEventArgs e)
{
try
{
if (e.Arguments.Length > 0)
{
var id = e.Arguments[0].ToString();
List <Dictionary <string, object> > result = new List <Dictionary <string, object> >();
var is2007 = false;
if (FileHashRel[id].ToLower().IndexOf("xlsx") != -1)
{
is2007 = true;
}
var stream = File.OpenRead(FileHashRel[id]);
NPOIData svr = new NPOIData();
if (string.IsNullOrEmpty(CurrentRuleList[id].RefStart))
{
CurrentRuleList[id].RefStart = "1";
}
var list = svr.getSheetInfo(stream, is2007, CurrentRuleList[id].RefStart, "");
e.SetReturnValue(JSON.SerializeObject(list));
}
}
catch (Exception ex)
{
ExecScript("alert('" + ex.Message + "')");
}
//Task.Factory.StartNew(ProcessExcelData);
}
private void ProcessRefresh()
{
ImportService newsvr = new ImportService();
var result = newsvr.GetDBData(CurrentRule);
ExecScript("ImportController.setData('" + JSON.SerializeObject(result) + "')");
}
public void Dispose()
{
var tokenFormats = Tokens.AllTokens.ToDictionary(k => k.Key, t => t.Value.Format);
_settings.Add(SettingNames.Instance.TokenFormats.Name, JsonConvert.SerializeObject(tokenFormats));
_settings.Save();
_commandsPreviewSettings?.Dispose();
}
private void GetHelpInfo(object sender, Chromium.Remote.Event.CfrV8HandlerExecuteEventArgs e)
{
if (e.Arguments.Length > 0)
{
var HelpID = e.Arguments[0].ToString();
e.SetReturnValue(JSON.SerializeObject(service.GetHelpInfo(HelpID)));
}
}
public void ProperEmail_SerializesCorrectly_UsingNewtonsoftJson(string address)
{
var emailAddress = new EmailAddress(address);
var serialized = NewtonsoftSerializer.SerializeObject(emailAddress);
Assert.Equal($"\"{address}\"", serialized);
}
public async Task <ActionResult <WeatherForecast> > PostWeatherForecast(WeatherForecast weatherForecast)
{
_service.Create(weatherForecast);
await _hubContext.Clients.All.SendAsync("SendMessage", JsonConvert.SerializeObject(weatherForecast));
return(CreatedAtRoute("GetObs", new { id = weatherForecast.Id.ToString() }, weatherForecast));
}
/// <summary>
/// Returns a raw without quatations
/// </summary>
/// <param name="helper"></param>
/// <param name="target"></param>
/// <param name="text"></param>
/// <returns></returns>
public static MvcHtmlString EnumTypeToJavascript <T>(this HtmlHelper helper)
{
var ths = Types.GetUnionCaseNames <T>();
var thsjs = JsonConvert.SerializeObject(ths);
var res = helper.Raw(thsjs);
return(MvcHtmlString.Create(thsjs));
}
public void ProperPhoneNumber_SerializesCorrectly_UsingNewtonsoftJson(string number, string expectedNumber)
{
var phoneNumber = new PhoneNumber(number);
var serialized = NewtonsoftSerializer.SerializeObject(phoneNumber);
Assert.Equal($"\"{expectedNumber}\"", serialized);
}
public void CanSerializeToGuid_WithNewtonsoftJsonProvider()
{
var foo = NewtonsoftJsonGuidId.New();
var serializedFoo = NewtonsoftJsonSerializer.SerializeObject(foo);
var serializedGuid = NewtonsoftJsonSerializer.SerializeObject(foo.Value);
Assert.Equal(serializedFoo, serializedGuid);
}