public GroupsHistoryResponseModel GetChannelHistory(string slackApiToken, string channel, DateTime startTime, DateTime endTime, int count)
{
var responseString = "https://slack.com/api/channels.history"
.PostUrlEncodedAsync(
new
{
token = slackApiToken,
channel,
latest = endTime.ToUnixTime(),
oldest = startTime.ToUnixTime(),
count
})
.ReceiveString()
.Result;
var serializer = new JsonSerializer<GroupsHistoryResponseModel>();
var response = serializer.DeserializeFromString(responseString);
if (!response.ok)
{
throw new SlackApiException(response.error);
}
return response;
}
public MembersResponse GetAllMemberInformation()
{
var responseString = "https://slack.com/api/users.list"
.PostUrlEncodedAsync(new { token = ConfigurationManager.AppSettings["BotKey"] })
.ReceiveString().Result;
var serializer = new JsonSerializer<MembersResponse>();
var memberInfo = serializer.DeserializeFromString(responseString);
return memberInfo;
}
public void Can_serialize_and_deserialize_text_email()
{
var serializer = new JsonSerializer<EmailMessage>();
var email = MessageFactory.EmailWithText(1).Single();
var json = serializer.SerializeToString(email);
Assert.IsNotNull(json);
Console.WriteLine(json);
var deserialized = serializer.DeserializeFromString(json);
Assert.IsNotNull(deserialized);
}
public static void Install()
{
JsConfig<Stack<CallerContext>>.RawDeserializeFn = s =>
{
var jsonSerializer = new JsonSerializer<List<CallerContext>>();
var callerContexts = jsonSerializer.DeserializeFromString(s);
callerContexts.Reverse();
return new Stack<CallerContext>(callerContexts);
};
JsConfig.DateHandler = JsonDateHandler.ISO8601;
}
public MemberModel GetMemberInformation(string slackId)
{
var responseString = "https://slack.com/api/users.info"
.PostUrlEncodedAsync(new
{
token = ConfigurationManager.AppSettings["BotKey"],
user = CleanSlackId(slackId)
})
.ReceiveString().Result;
var serializer = new JsonSerializer<UserInfoResponse>();
var memberInfo = serializer.DeserializeFromString(responseString);
return memberInfo.user;
}
public ChannelInfoResponseModel GetChannelInfo(string slackApiToken, string channel)
{
var responseString = "https://slack.com/api/channels.info"
.PostUrlEncodedAsync(
new
{
token = slackApiToken,
channel
})
.ReceiveString()
.Result;
var serializer = new JsonSerializer<ChannelInfoResponseModel>();
var response = serializer.DeserializeFromString(responseString);
return response;
}
public UserInfoResponseModel GetUserInfo(string slackApiToken, string userSlackId)
{
var responseString = "https://slack.com/api/users.info"
.PostUrlEncodedAsync(
new
{
token = slackApiToken,
user = userSlackId
})
.ReceiveString()
.Result;
var serializer = new JsonSerializer<UserInfoResponseModel>();
var response = serializer.DeserializeFromString(responseString);
return response;
}
public ChannelListResponseModel ListChannels(string slackApiToken)
{
var responseString = "https://slack.com/api/channels.list"
.PostUrlEncodedAsync(
new
{
token = slackApiToken,
exclude_archived = 0
})
.ReceiveString()
.Result;
var serializer = new JsonSerializer<ChannelListResponseModel>();
var response = serializer.DeserializeFromString(responseString);
return response;
}
public bool AddReaction(string reaction, string channel, string timestamp)
{
var responseString = "https://slack.com/api/reactions.add"
.PostUrlEncodedAsync(
new
{
token = ConfigurationManager.AppSettings["SlackBotApiToken"],
name = reaction,
channel,
timestamp
})
.ReceiveString()
.Result;
var serializer = new JsonSerializer<ReactionResponseModel>();
var response = serializer.DeserializeFromString(responseString);
return response.ok;
}
public PostMessageResponseModel PostMessage(string slackApiToken, string channel, string text)
{
var responseString = "https://slack.com/api/chat.postMessage"
.PostUrlEncodedAsync(
new
{
token = slackApiToken,
channel,
text,
as_user = true
})
.ReceiveString()
.Result;
var serializer = new JsonSerializer<PostMessageResponseModel>();
var response = serializer.DeserializeFromString(responseString);
return response;
}
public ChatUpdateResponseModel UpdateMessage(string slackApiToken, double messageTimeStamp, string channel, string text)
{
var responseString = "https://slack.com/api/chat.update"
.PostUrlEncodedAsync(
new
{
token = slackApiToken,
ts = messageTimeStamp,
channel,
text
})
.ReceiveString()
.Result;
var serializer = new JsonSerializer<ChatUpdateResponseModel>();
var response = serializer.DeserializeFromString(responseString);
return response;
}
public GroupsListResponseModel ListGroups(string slackApiToken)
{
var responseString = "https://slack.com/api/groups.list"
.PostUrlEncodedAsync(
new
{
token = slackApiToken,
exclude_archived = 0
})
.ReceiveString()
.Result;
var serializer = new JsonSerializer<GroupsListResponseModel>();
var response = serializer.DeserializeFromString(responseString);
if (!response.ok)
{
throw new SlackApiException(response.error);
}
return response;
}
public static string TryGetErrorMessage(object param)
{
var error = param as Error;
if (error == null || error.Exception == null || string.IsNullOrEmpty(error.Exception.Message))
return null;
string msg = null;
if (error.Exception.Message.StartsWith("["))
{
var serializer = new JsonSerializer<List<ErrorInfo>>();
try
{
var errorList = serializer.DeserializeFromString(error.Exception.Message);
var sb = new StringBuilder();
foreach (var errorInfo in errorList)
{
sb.AppendLine(LanguageHelper.GetValue(errorInfo.Message));
}
msg = sb.ToString();
}
catch
{
}
}
else
{
string errMessage = error.Exception.Message;
if (errMessage.StartsWith("\""))
errMessage = errMessage.Replace("\"", "");
msg = LanguageHelper.GetValue(errMessage);
}
if (string.IsNullOrEmpty(msg))
msg = error.Exception.Message;
return msg;
}
static void Main(string[] args)
{
var violations = 0;
const int count = 1000 * 1000;
var json = new List<string>();
var serializer = new JsonSerializer<T>();
for (int i = 0; i < count; i++)
{
var t = new T
{
X = Guid.NewGuid(),
Y = i % 2 == 0 ? 'C' : 'P',
};
json.Add(serializer.SerializeToString(t));
}
var tasks = new List<Task>();
var tasksCount = args.Length > 0 ? int.Parse(args[0]) : 3;
for (int jj = 0; jj < tasksCount; jj++)
{
int j = jj;
tasks.Add(Task.Run(() => {
for (int i = 0; i < count; i++)
{
string s = json[i];
var t = serializer.DeserializeFromString(s);
if (t.Y != (i % 2 == 0 ? 'C' : 'P'))
{
violations++;
Console.WriteLine("Constraint violation index {0} thread {1} expected: {2} received: {3} json: {4}",
i, j, i % 2 == 0 ? 'C' : 'P', t.Y, s);
}
}
}));
}
tasks.ForEach(task => task.Wait());
Console.WriteLine($"There were {violations} viloations, running {tasksCount} Tasks");
}
public GroupsInfoResponseModel GetGroupInfo(string slackApiToken, string channel)
{
var responseString = "https://slack.com/api/groups.info"
.PostUrlEncodedAsync(
new
{
token = slackApiToken,
channel
})
.ReceiveString()
.Result;
var serializer = new JsonSerializer<GroupsInfoResponseModel>();
var response = serializer.DeserializeFromString(responseString);
if (!response.ok)
{
throw new SlackApiException(response.error);
}
return response;
}
public void Can_parse_empty_object_with_leading_whitespace()
{
var serializer = new JsonSerializer<Foo>();
var foo = serializer.DeserializeFromString(" {}");
Assert.That(foo, Is.Not.Null);
Assert.That(foo.Bar, Is.Null);
}
//
// GET: /Movies/
public string Index(string json)
{
var serializer = new JsonSerializer<Movie>();
var movie = serializer.DeserializeFromString(json);
return "Saved";
}
public void DeserializeFromString_NullNullableLocalDateText_ReturnsNull()
{
Assert.Null(JsonSerializer.DeserializeFromString <LocalDate?>(null));
}
public void Deserialize_array_with_null_elements()
{
var json = "[{\"Value\": \"a\"},null,{\"Value\": \"b\"}]";
var o = JsonSerializer.DeserializeFromString <A[]>(json);
}
private static void Main(string[] args)
{
var env = environments["vagrant"];
var localPath = "Z:\\WindowsDev\\Gateway\\";
var remoteFilePath = "/home/tripservice/servicestack/";
var host = env.host;
var user = env.user;
var password = env.password;
var sshPort = env.sshPort;
var monoServer = "http://" + host + "/";
var webServer = "http://" + host + ":8080/";
ssh = new SshExec(host, user, password);
ssh.Connect(sshPort);
Console.WriteLine("Connected");
sftpBase = new Tamir.SharpSsh.Sftp(host, user, password);
sftpBase.OnTransferStart += new FileTransferEvent(sftpBase_OnTransferStart);
sftpBase.OnTransferEnd += new FileTransferEvent(sftpBase_OnTransferEnd);
Console.WriteLine("Trying to Open Connection...");
sftpBase.Connect(sshPort);
Console.WriteLine("Connected Successfully !");
if (fullDeploy)
{
//Remove any old files and upload projects
Console.WriteLine("Uploading projects");
ssh.RunCommand("cd " + remoteFilePath);
ssh.RunCommand("rm -rf " + remoteFilePath + "ServiceStack.* Booking*");
ssh.RunCommand("mkdir -p " + remoteFilePath + "ServiceStack.TripThruGateway/Web");
ssh.RunCommand("mkdir -p " + remoteFilePath + "ServiceStack.TripThruPartnerGateway/Web");
ssh.RunCommand("mkdir -p " + remoteFilePath + "BookingWebsite");
var omittedDirectories = new List <string> {
"packages"
};
UploadDirectory(localPath + "BookingWebsite", remoteFilePath + "BookingWebsite");
UploadDirectory(localPath + "ServiceStack.TripThruGateway/Web", remoteFilePath + "ServiceStack.TripThruGateway/Web");
UploadDirectory(localPath + "ServiceStack.TripThruPartnerGateway/Web", remoteFilePath + "ServiceStack.TripThruPartnerGateway/Web");
ssh.RunCommand("mv " + remoteFilePath + "ServiceStack.TripThruGateway/Web/mono/* " + remoteFilePath +
"ServiceStack.TripThruGateway/Web/bin");
ssh.RunCommand("mv " + remoteFilePath + "ServiceStack.TripThruPartnerGateway/Web/mono/* " +
remoteFilePath + "ServiceStack.TripThruPartnerGateway/Web/bin");
}
var webappNames = new List <string>();
string[] partnerConfigurations = Directory.GetFiles("PartnerConfigurations/", "*.txt");
List <string> partnerscallbackUrlMono = new List <string>();
foreach (var partnerConfiguration in partnerConfigurations)
{
var configuration = JsonSerializer.DeserializeFromString <PartnerConfiguration>(File.ReadAllText(partnerConfiguration));
configuration.TripThruUrlMono = monoServer + configuration.TripThruUrlMono;
configuration.Partner.CallbackUrlMono = monoServer + configuration.Partner.CallbackUrlMono;
configuration.Partner.WebUrl = webServer + configuration.Partner.WebUrl;
string configStr = JsonSerializer.SerializeToString <PartnerConfiguration>(configuration);
File.WriteAllText(partnerConfiguration, configStr);
if (configuration.Enabled)
{
partnerscallbackUrlMono.Add(configuration.Partner.CallbackUrlMono);
var name = configuration.Partner.Name.Replace(" ", "");
Console.WriteLine("Configuring " + name);
webappNames.Add(name);
ssh.RunCommand("cp -a " + remoteFilePath + "ServiceStack.TripThruPartnerGateway/ " + remoteFilePath +
"ServiceStack." + name + "/");
ssh.RunCommand("rm " + remoteFilePath + "ServiceStack." + name + "/Web/PartnerConfiguration.txt");
sftpBase.Put(partnerConfiguration,
remoteFilePath + "ServiceStack." + name + "/Web/PartnerConfiguration.txt");
var bookingwebConfig = new System.IO.StreamWriter("config.txt");
bookingwebConfig.WriteLine("HomeUrl=" + configuration.Partner.WebUrl);
bookingwebConfig.WriteLine("RelativeHomeUrl=" + configuration.Partner.WebUrlRelative);
bookingwebConfig.WriteLine("TripThruUrl=" + configuration.TripThruUrlMono);
bookingwebConfig.WriteLine("TripThruAccessToken=" + "jaosid1201231"); //fixed tripthru access token
bookingwebConfig.WriteLine("PartnerUrl=" + configuration.Partner.CallbackUrlMono);
bookingwebConfig.WriteLine("PartnerAccessToken=" + configuration.Partner.AccessToken);
bookingwebConfig.WriteLine("PartnerName=" + name);
bookingwebConfig.WriteLine("PartnerId=" + configuration.Partner.ClientId);
bookingwebConfig.Flush();
bookingwebConfig.Close();
ssh.RunCommand("rm " + remoteFilePath + "BookingWebsite/inc/tripthru/config.txt");
sftpBase.Put("config.txt", remoteFilePath + "BookingWebsite/inc/tripthru/");
ssh.RunCommand("rm " + remoteFilePath + "BookingWebsite/images/taxi-cars_logo.png");
var x = name + ".png";
var y = remoteFilePath + "BookingWebsite/images/taxi-cars_logo.png";
sftpBase.Put("PartnerConfigurations/" + name + ".png",
remoteFilePath + "BookingWebsite/images/taxi-cars_logo.png");
ssh.RunCommand("rm -rf /var/www/sanfran/Bookings" + name);
ssh.RunCommand("cp -a " + remoteFilePath + "BookingWebsite/ /var/www/sanfran/Bookings" + name);
}
}
if (fullDeploy)
{
//create fast-cgi mono webapp config
var webappConfig = new System.IO.StreamWriter("tripthru.webapp");
webappConfig.WriteLine("<apps>");
webappConfig.Flush();
webappConfig.WriteLine(@"<web-application>
<name>TripThru.TripThruGateway</name>
<vhost>*</vhost>
<vport>80</vport>
<vpath>/TripThru.TripThruGateway</vpath>
<path>/var/www/ServiceStack.TripThruGateway/Web</path>
</web-application>"
);
webappConfig.Flush();
foreach (var webapp in webappNames)
{
webappConfig.WriteLine(@"<web-application>
<name>TripThru.{0}</name>
<vhost>*</vhost>
<vport>80</vport>
<vpath>/TripThru.{0}</vpath>
<path>/var/www/ServiceStack.{0}/Web</path>
</web-application>", webapp
);
webappConfig.Flush();
}
webappConfig.WriteLine("</apps>");
webappConfig.Flush();
webappConfig.Close();
Console.WriteLine("Updating mono webapp config");
ssh.RunCommand("rm /etc/rc.d/init.d/mono-fastcgi/tripthru.webapp");
sftpBase.Put("tripthru.webapp", "/etc/rc.d/init.d/mono-fastcgi/tripthru.webapp");
}
Console.WriteLine("Stopping mono");
ssh.RunCommand("kill -9 $(netstat -tpan |grep \"LISTEN\"|grep :9000|awk -F' ' '{print $7}'|awk -F'/' '{print $1}')");
Console.WriteLine("Updating web folder");
ssh.RunCommand("rm -rf /var/www/ServiceStack.*");
ssh.RunCommand("cp -a " + remoteFilePath + "/ServiceStack.* /var/www/");
Thread startMono = new Thread(
delegate()
{
Console.WriteLine("Starting mono");
ssh.RunCommand("export MONO_OPTIONS=\"--debug\"");
ssh.RunCommand("fastcgi-mono-server4 --appconfigdir /etc/rc.d/init.d/mono-fastcgi /socket=tcp:127.0.0.1:9000 /logfile=/var/log/mono/fastcgi.log &");
});
startMono.Start();
Console.WriteLine("Sleep 8 seconds, waiting for mono to initialize.");
Thread.Sleep(8000);
var client = new System.Net.WebClient();
foreach (string callbackUrlMono in partnerscallbackUrlMono)
{
Console.WriteLine("Sending request to: \n" + @callbackUrlMono.ToString() + "log");
while (true)
{
try
{
var response = client.DownloadString(@callbackUrlMono.ToString() + "log");
var analyzeResponse = JsonSerializer.DeserializeFromString <ResponseRequest>(response);
if (analyzeResponse.ResultCode.Equals("OK"))
{
Console.WriteLine("Correct.");
break;
}
else
{
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
}
}
}
Console.WriteLine("Done!");
startMono.Abort();
sftpBase.Close();
ssh.Close();
}
T IJsonObjectMapper.From <T>(string result)
{
var item = JsonSerializer.DeserializeFromString <T>(result);
return(item);
}
public void DeserializeFromString_WhitespaceNullableIntervalText_Throws()
{
Assert.Throws <IndexOutOfRangeException>(() => JsonSerializer.DeserializeFromString <Interval?>(" \n "));
}
public static JsonArrayObjects Parse(string json)
{
return(JsonSerializer.DeserializeFromString <JsonArrayObjects>(json));
}
public void DeserializeFromString_NullNullableIntervalText_ReturnsNull()
{
Assert.Null(JsonSerializer.DeserializeFromString <Interval?>(null));
}
public void DeserializeFromString_EmptyNullableIntervalText_ReturnsNull()
{
Assert.Null(JsonSerializer.DeserializeFromString <Interval?>(string.Empty));
}
public void DeserializeFromString_BadNullableIntervalText_Throws()
{
Assert.Throws <SerializationException>(() => JsonSerializer.DeserializeFromString <Interval?>("Wrong"));
}
public void DeserializeFromString_WhitespaceNullableLocalDateText_Throws()
{
Assert.Throws <FormatException>(() => JsonSerializer.DeserializeFromString <LocalDate?>(" \r \n "));
}
public void DeserializeFromString_EmptyNullableLocalDateText_ReturnsNull()
{
Assert.Null(JsonSerializer.DeserializeFromString <LocalDate?>(string.Empty));
}
protected void CheckCacheAndRetrieveState()
{
if (LocalCachingEnabled && File.Exists(Settings.Default.LocalCache))
{
var text = File.ReadAllText(Settings.Default.LocalCache);
var serializer = new JsonSerializer<TaskMessage>();
CurrentTask = serializer.DeserializeFromString(text);
State = RedisQueueState.TaskReserved;
}
}
public T As <T>() => JsonSerializer.DeserializeFromString <T>(json);
public void AssertUnescapes(string expected, string given)
{
Assert.AreEqual(expected, JsonSerializer.DeserializeFromString <string>(given));
}
public static T ToJson <T>(this string s)
{
return(JsonSerializer.DeserializeFromString <T>(s));
}
public static T FromJson <T>(this string json)
{
return(JsonSerializer.DeserializeFromString <T>(json));
}
public static T Deserialize <T>(string serializedObject)
{
return(JsonSerializer.DeserializeFromString <T>(serializedObject));
}
/// <summary>
/// 从hash表获取数据
/// </summary>
public T Get <T>(string hashId, string key)
{
string value = Redis.GetValueFromHash(hashId, key);
return(JsonSerializer.DeserializeFromString <T>(value));
}
public void Should_deserialize_enum()
{
Assert.That(JsonSerializer.DeserializeFromString <EnumWithoutFlags>("\"Two\""), Is.EqualTo(EnumWithoutFlags.Two));
}
public void TestFixtureSetUp()
{
var json = "~/AppData/ALFKI.json".MapProjectPath().ReadAllText();
response = JsonSerializer.DeserializeFromString <CustomerDetailsResponse>(json);
}
public void test_rect_different_cultures(string culture)
{
var currentCulture = CultureInfo.GetCultureInfo(culture);
Thread.CurrentThread.CurrentCulture = currentCulture;
Thread.CurrentThread.CurrentUICulture = currentCulture;
var s = new JsonSerializer<Rect>();
var r = new Rect(23, 34, 1024, 768);
var interim = s.SerializeToString(r);
var r2 = s.DeserializeFromString(interim);
Assert.AreEqual(r, r2);
}
public static Json ToJson(this string s)
{
return(JsonSerializer.DeserializeFromString <Json>(s));
}
public static string GetTimeStamp(this SlackMessage message)
{
var serializer = new JsonSerializer<SlackRawMessageModel>();
var rawData = serializer.DeserializeFromString(message.RawData);
return rawData.ts;
}
public static List <T> ToJsonList <T>(this string s)
{
return(JsonSerializer.DeserializeFromString <List <T> >(s));
}
public void Can_parse_empty_dictionary_with_leading_whitespace()
{
var serializer = new JsonSerializer<Dictionary<int, double>>();
Assert.That(serializer.DeserializeFromString(" {}"), Is.Empty);
}
public void JsonDeserializerReturnsTimeSpanFromString()
{
Assert.AreEqual(TimeSpan.Zero, JsonSerializer.DeserializeFromString <TimeSpan>("\"PT0S\""));
Assert.AreEqual(new TimeSpan(1), JsonSerializer.DeserializeFromString <TimeSpan>("\"PT0.0000001S\""));
}
public void Can_parse_empty_hashtable_with_leading_whitespace()
{
var serializer = new JsonSerializer<Hashtable>();
Assert.That(serializer.DeserializeFromString(" {}"), Is.Empty);
}
public void Should_handle_empty_enum()
{
Assert.That(JsonSerializer.DeserializeFromString <EnumWithoutFlags>(""), Is.EqualTo((EnumWithoutFlags)0));
}
public void Can_parse_empty_json_object_with_leading_whitespace()
{
var serializer = new JsonSerializer<JsonObject>();
Assert.That(serializer.DeserializeFromString(" {}"), Is.Empty);
}
public void Should_return_null_instance_for_empty_json()
{
var o = JsonSerializer.DeserializeFromString("", typeof(JsonPrimitives));
Assert.IsNull(o);
}
public void Can_parse_empty_key_value_pair_with_leading_whitespace()
{
var serializer = new JsonSerializer<KeyValuePair<string, string>>();
Assert.That(serializer.DeserializeFromString(" {}"), Is.EqualTo(default(KeyValuePair<string, string>)));
}
public void Can_parse_nonempty_string_dictionary_with_leading_whitespace()
{
var serializer = new JsonSerializer<Dictionary<string, string>>();
var dictionary = serializer.DeserializeFromString(" {\"A\":\"N\",\"B\":\"O\"}");
Assert.That(dictionary.Count, Is.EqualTo(2));
Assert.That(dictionary["A"], Is.EqualTo("N"));
Assert.That(dictionary["B"], Is.EqualTo("O"));
}
public void Can_parse_empty_dictionary_with_leading_whitespace()
{
var serializer = new JsonSerializer <Dictionary <int, double> >();
Assert.That(serializer.DeserializeFromString(" {}"), Is.Empty);
}
public void Can_parse_nonempty_dictionary_with_leading_whitespace()
{
var serializer = new JsonSerializer<Dictionary<int, double>>();
var dictionary = serializer.DeserializeFromString(" {\"1\":2.5,\"2\":5}");
Assert.That(dictionary.Count, Is.EqualTo(2));
Assert.That(dictionary[1], Is.EqualTo(2.5));
Assert.That(dictionary[2], Is.EqualTo(5.0));
}
public void Can_parse_empty_hashtable_with_leading_whitespace()
{
var serializer = new JsonSerializer <Hashtable>();
Assert.That(serializer.DeserializeFromString(" {}"), Is.Empty);
}
public void Can_parse_nonempty_hashtable_with_leading_whitespace()
{
var serializer = new JsonSerializer<Hashtable>();
var hashtable = serializer.DeserializeFromString(" {\"A\":1,\"B\":2}");
Assert.That(hashtable.Count, Is.EqualTo(2));
Assert.That(hashtable["A"].ToString(), Is.EqualTo(1.ToString()));
Assert.That(hashtable["B"].ToString(), Is.EqualTo(2.ToString()));
}
public void Can_parse_empty_json_object_with_leading_whitespace()
{
var serializer = new JsonSerializer <JsonObject>();
Assert.That(serializer.DeserializeFromString(" {}"), Is.Empty);
}
public void Can_parse_nonempty_json_object_with_leading_whitespace()
{
var serializer = new JsonSerializer<JsonObject>();
var jsonObject = serializer.DeserializeFromString(" {\"foo\":\"bar\"}");
Assert.That(jsonObject, Is.Not.Empty);
Assert.That(jsonObject["foo"], Is.EqualTo("bar"));
}
public void Can_parse_empty_key_value_pair_with_leading_whitespace()
{
var serializer = new JsonSerializer <KeyValuePair <string, string> >();
Assert.That(serializer.DeserializeFromString(" {}"), Is.EqualTo(default(KeyValuePair <string, string>)));
}
public void Can_parse_nonempty_key_value_pair_with_leading_whitespace()
{
var serializer = new JsonSerializer<KeyValuePair<string, string>>();
var keyValuePair = serializer.DeserializeFromString(" {\"Key\":\"foo\",\"Value\":\"bar\"}");
Assert.That(keyValuePair, Is.EqualTo(new KeyValuePair<string, string>("foo", "bar")));
}
public static Money Deserialize(string json)
{
var surrogate = JsonSerializer.DeserializeFromString <CanonicalSurrogate>(json);
return(surrogate.ToMoney());
}
public void Can_parse_nonempty_object_with_leading_whitespace()
{
var serializer = new JsonSerializer<Foo>();
var foo = serializer.DeserializeFromString(" {\"Bar\":\"baz\"}");
Assert.That(foo, Is.Not.Null);
Assert.That(foo.Bar, Is.EqualTo("baz"));
}
private static void processJson(CouchbaseClient client)
{
var dict = new Dictionary <string, string>();
Action <string> process = s =>
{
using (StreamReader reader = new StreamReader(@"..\..\Data\" + s + ".json"))
{
string line;
while ((line = reader.ReadLine()) != null)
{
var jsonLine = JsonSerializer.DeserializeFromString(line, typeof(JsonObject));
var jsonDict = jsonLine.ToStringDictionary();
var id = jsonDict["_id"];
//_id is reserved and can't be in JSON document
var idPropAndVal = "\"_id\" : \"" + id + "\", ";
//HACK://This is just data loading code, it's OK, right?
if (s == "breweries")
{
var key = id.Split('_')[0];
dict[key] = id;
}
else if (s == "beers")
{
var bid = jsonDict["breweryId"];
if (dict.ContainsKey(bid))
{
line = line.Replace(bid.ToString(), dict[bid]);
Console.WriteLine(line);
}
else
{
continue;
}
}
client.Store(StoreMode.Set, id, line.Replace(idPropAndVal, ""));
}
}
};
process("breweries");
process("beers");
//using (StreamReader reader = new StreamReader(@"..\..\Data\SampleDocuments.json")) {
// string line;
// while ((line = reader.ReadLine()) != null) {
// var jsonLine = JsonSerializer.DeserializeFromString(line, typeof(JsonObject));
// var id = jsonLine.ToStringDictionary()["_id"];
// //_id is reserved and can't be in JSON document
// var idPropAndVal = "\"_id\" : \"" + id + "\", ";
// client.Remove(id);
// //client.Store(StoreMode.Set, id, line.Replace(idPropAndVal, ""));
// }
//}
}
