public static T DeserializeFromBytes <T>(this IStringSerializer serializer, byte[] data, Encoding encoding = null)
{
var encoder = encoding ?? Encoding.UTF8;
var str = encoder.GetString(data, 0, data.Length);
return(serializer.Deserialize <T>(str));
}
public static KnownPublicKeys Load(IDataStore store, IStringSerializer serializer)
{
if (store == null)
{
throw new ArgumentNullException("store");
}
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
string json = String.Empty;
using (FileLock fileLock = New <FileLocker>().Acquire(store))
{
if (store.IsAvailable)
{
using (StreamReader reader = new StreamReader(store.OpenRead(), Encoding.UTF8))
{
json = reader.ReadToEnd();
}
}
}
KnownPublicKeys knownPublicKeys = serializer.Deserialize <KnownPublicKeys>(json);
if (knownPublicKeys == null)
{
knownPublicKeys = new KnownPublicKeys();
}
knownPublicKeys._store = store;
knownPublicKeys._serializer = serializer;
return(knownPublicKeys);
}
public static byte[] GetSerializedBytes(this IStringSerializer serializer, object obj, Encoding encoding = null)
{
var encoder = encoding ?? Encoding.UTF8;
var str = serializer.Serialize(obj);
return(encoder.GetBytes(str));
}
private System.IO.MemoryStream Generacion(string Titulo, String nombreCalendario, DateTime fechayHoraInicio, Int32 duracionEnMinutos, string ubicacion)
{
DDay.iCal.iCalendar iCal = new DDay.iCal.iCalendar();
// Create the event, and add it to the iCalendar
Event evt = iCal.Create <Event>();
// Set information about the event
evt.Start = new iCalDateTime(fechayHoraInicio);
evt.End = evt.Start.AddMinutes(duracionEnMinutos); // This also sets the duration
evt.Description = String.Format("Agenda del día {0} a las {1}",
fechayHoraInicio.ToString("dd 'de' MMM 'de' yyyy"),
fechayHoraInicio.ToString("HH:MM")
);
evt.Location = ubicacion;
evt.Summary = Titulo;
ISerializationContext ctx = new SerializationContext();
ISerializerFactory factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory();
// Get a serializer for our object
IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer;
string output = serializer.SerializeToString(iCal);
var bytes = Encoding.UTF8.GetBytes(output);
//return File(bytes, contentType, DownloadFileName);
System.IO.MemoryStream data = new System.IO.MemoryStream(bytes);
return(data);
}
/// <summary>
/// Deserializes from bytes.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="data">The data.</param>
/// <param name="type">The type.</param>
/// <param name="encoding">The encoding.</param>
/// <returns>System.Object.</returns>
public static object DeserializeFromBytes(this IStringSerializer serializer, byte[] data, Type type, Encoding encoding = null)
{
var encoder = encoding ?? Encoding.UTF8;
var str = encoder.GetString(data, 0, data.Length);
return(serializer.Deserialize(str, type));
}
public ActionResult ICalendar(string shortcut, Guid hallID, string accessToken)
{
var iCal = new iCalendar();
var studio = _context.Photostudios.Single(x => x.Shortcut == shortcut);
var hall = studio.Halls.Single(x => x.ID == hallID);
foreach (var @event in hall.Calendar.Events)
{
var evt = iCal.Create <DDay.iCal.Event>();
// Set information about the event
evt.Start = new iCalDateTime(@event.Start);
evt.End = new iCalDateTime(@event.End); // This also sets the duration
evt.Description = @event.Description;
evt.Location = hall.Photostudio.Adress;
evt.Summary = "18 hour event summary";
evt.UID = @event.ID.ToString();
}
// Create a serialization context and serializer factory.
// These will be used to build the serializer for our object.
ISerializationContext ctx = new SerializationContext();
ISerializerFactory factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory();
// Get a serializer for our object
IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer;
string output = serializer.SerializeToString(iCal);
var contentType = "text/calendar";
var bytes = Encoding.UTF8.GetBytes(output);
return(File(bytes, contentType, hallID + ".ics"));
}
protected override void Context()
{
_serializationManager = A.Fake <IStringSerializer>();
_defaultApplicationSettings = A.Fake <IApplicationSettings>();
_pkSimConfiguration = A.Fake <IPKSimConfiguration>();
sut = new ApplicationSettingsPersistor(_serializationManager, _defaultApplicationSettings, _pkSimConfiguration);
}
public override string SerializeToString(object obj)
{
IPeriodList rdt = obj as IPeriodList;
ISerializerFactory factory = GetService <ISerializerFactory>();
if (rdt != null && factory != null)
{
IStringSerializer dtSerializer = factory.Build(typeof(IDateTime), SerializationContext) as IStringSerializer;
IStringSerializer periodSerializer = factory.Build(typeof(IPeriod), SerializationContext) as IStringSerializer;
if (dtSerializer != null && periodSerializer != null)
{
List <string> parts = new List <string>();
foreach (IPeriod p in rdt)
{
if (p.EndTime != null)
{
parts.Add(periodSerializer.SerializeToString(p));
}
else if (p.StartTime != null)
{
parts.Add(dtSerializer.SerializeToString(p.StartTime));
}
}
return(Encode(rdt, string.Join(",", parts.ToArray())));
}
}
return(null);
}
public UserSettingsPersistor(IStringSerializer stringSerializer, IUserSettings defaultUserSettings,
IPKSimConfiguration configuration)
{
_stringSerializer = stringSerializer;
_defaultUserSettings = defaultUserSettings;
_configuration = configuration;
}
public CalDavRepository(ICalDavDataAccess calDavDataAccess, IStringSerializer calendarSerializer, EntityType entityType, IDateTimeRangeProvider dateTimeRangeProvider)
{
_calDavDataAccess = calDavDataAccess;
_calendarSerializer = calendarSerializer;
_entityType = entityType;
_dateTimeRangeProvider = dateTimeRangeProvider;
}
public ActionResult Calendar()
{
DDay.iCal.iCalendar iCal = new DDay.iCal.iCalendar();
// Create the event, and add it to the iCalendar
Event evt = iCal.Create <Event>();
// Set information about the event
evt.Start = iCalDateTime.Today.AddHours(8);
evt.End = evt.Start.AddHours(18); // This also sets the duration
evt.Description = "The event description";
evt.Location = "Event location";
evt.Summary = "18 hour event summary";
// Set information about the second event
evt = iCal.Create <Event>();
evt.Start = iCalDateTime.Today.AddDays(5);
evt.End = evt.Start.AddDays(1);
evt.IsAllDay = true;
evt.Summary = "All-day event";
// Create a serialization context and serializer factory.
// These will be used to build the serializer for our object.
ISerializationContext ctx = new SerializationContext();
ISerializerFactory factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory();
// Get a serializer for our object
IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer;
string output = serializer.SerializeToString(iCal);
var contentType = "text/calendar";
var bytes = Encoding.UTF8.GetBytes(output);
return(File(bytes, contentType, "calendar.ics"));
}
public static bool CanSerializeString <T>(this IStringSerializer serializer, T item)
{
var text = serializer.Serialize(item);
var obj = serializer.Deserialize <T>(text);
return(obj.Equals(item));
}
private static IICalendar DeserializeCalendar(string iCalData, IStringSerializer calendarSerializer)
{
using (var reader = new StringReader(iCalData))
{
var calendarCollection = (iCalendarCollection)calendarSerializer.Deserialize(reader);
return(calendarCollection[0]);
}
}
public LabelQuery(IStringSerializer stringSerializer, string queryText, string owner, string repository, string pageId)
{
this.stringSerializer = stringSerializer;
this.queryText = queryText;
this.owner = owner;
this.repository = repository;
this.pageId = pageId;
}
public LocalStatusWriter(
IFileManager fileManager,
IStringSerializer <EncounterContentStatus> contentStatusSerializer,
IStringSerializer <KeyValuePair <int, EncounterBasicStatus> > basicStatusSerializer)
{
FileManager = fileManager;
ContentStatusSerializer = contentStatusSerializer;
BasicStatusSerializer = basicStatusSerializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="HybridWebView"/> class.
/// </summary>
/// <remarks>HybridWebView will use either <see cref="IJsonSerializer"/> configured
/// with IoC or if missing it will use <see cref="SystemJsonSerializer"/> by default.</remarks>
public HybridWebView()
{
if (!Resolver.IsSet || (this.jsonSerializer = Resolver.Resolve <IJsonSerializer>()) == null)
{
this.jsonSerializer = new SystemJsonSerializer();
}
this.registeredActions = new Dictionary <string, Action <string> >();
}
/// <summary>
/// Initializes a new instance of the <see cref="HybridWebView"/> class.
/// </summary>
/// <remarks>HybridWebView will use either <see cref="IJsonSerializer"/> configured
/// with IoC or if missing it will use <see cref="SystemJsonSerializer"/> by default.</remarks>
public HybridWebView()
{
if (!Resolver.IsSet || (this.jsonSerializer = Resolver.Resolve<IJsonSerializer>()) == null)
{
this.jsonSerializer = new SystemJsonSerializer();
}
this.registeredActions = new Dictionary<string, Action<string>>();
}
public CrossProjectQueries(
ILogger <BasicQueries <T> > logger,
IStoragePathResolver <T> pathResolver,
IStringSerializer <T> serializer,
IStoragePathOptionsResolver storageOptionsResolver
) : base(logger, pathResolver, serializer)
{
this.storageOptionsResolver = storageOptionsResolver;
}
public override object Deserialize(TextReader tr)
{
string value = tr.ReadToEnd();
ITrigger t = CreateAndAssociate() as ITrigger;
if (t != null)
{
// Push the trigger onto the serialization stack
SerializationContext.Push(t);
try
{
// Decode the value as needed
value = Decode(t, value);
// Set the trigger relation
if (t.Parameters.ContainsKey("RELATED") &&
t.Parameters.Get("RELATED").Equals("END"))
{
t.Related = TriggerRelation.End;
}
ISerializerFactory factory = GetService <ISerializerFactory>();
if (factory != null)
{
Type valueType = t.GetValueType() ?? typeof(TimeSpan);
IStringSerializer serializer = factory.Build(valueType, SerializationContext) as IStringSerializer;
if (serializer != null)
{
StringReader reader = new StringReader(value);
object obj = serializer.Deserialize(reader);
reader.Dispose();
if (obj != null)
{
if (obj is IDateTime)
{
t.DateTime = (IDateTime)obj;
}
else
{
t.Duration = (TimeSpan)obj;
}
return(t);
}
}
}
}
finally
{
// Pop the trigger off the serialization stack
SerializationContext.Pop();
}
}
return(null);
}
public override string SerializeToString(object obj)
{
ICalendarComponent c = obj as ICalendarComponent;
if (c != null)
{
StringBuilder sb = new StringBuilder();
sb.Append(TextUtil.WrapLines("BEGIN:" + c.Name.ToUpper()));
// Get a serializer factory
ISerializerFactory sf = GetService <ISerializerFactory>();
// Sort the calendar properties in alphabetical order before
// serializing them!
List <ICalendarProperty> properties = new List <ICalendarProperty>(c.Properties);
// FIXME: remove this try/catch
try
{
properties.Sort(PropertySorter);
}
catch (Exception e)
{
throw;
}
// Serialize properties
foreach (ICalendarProperty p in properties)
{
// Get a serializer for each property.
IStringSerializer serializer = sf.Build(p.GetType(), SerializationContext) as IStringSerializer;
if (serializer != null)
{
sb.Append(serializer.SerializeToString(p));
}
}
// Serialize child objects
if (sf != null)
{
foreach (ICalendarObject child in c.Children)
{
// Get a serializer for each child object.
IStringSerializer serializer = sf.Build(child.GetType(), SerializationContext) as IStringSerializer;
if (serializer != null)
{
sb.Append(serializer.SerializeToString(child));
}
}
}
sb.Append(TextUtil.WrapLines("END:" + c.Name.ToUpper()));
return(sb.ToString());
}
return(null);
}
public byte[] ICalSerializeToBytes(iCalendar iCal, string filename)
{
ISerializationContext ctx = new SerializationContext();
ISerializerFactory factory = new SerializerFactory();
IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer;
string output = serializer.SerializeToString(iCal);
return(Encoding.UTF8.GetBytes(output));
}
public MessageForwardingService(
NotNullable<IStringSerializer> messageSerializer,
NotNullable<IServiceEvents> hostMediator,
NotNullable<IMessageForwarderFactory> messageForwarderFactory)
{
_messageSerializer = messageSerializer.Value;
_messageForwarderFactory = messageForwarderFactory.Value;
_forwarders = new List<IMessageForwarder>();
_hostMediator = hostMediator.Value;
}
public void TestDeserializeWithEnglishUsCulture()
{
IStringSerializer serializer = New <IStringSerializer>();
string json = "{\r\n \"messageCulture\": \"en-US\",\r\n \"customMessage\": \"A message\"\r\n}".Replace("\r\n", Environment.NewLine);
CustomMessageParameters parameters = serializer.Deserialize <CustomMessageParameters>(json);
Assert.That(parameters.MessageCulture.ToString(), Is.EqualTo("en-US"));
Assert.That(parameters.CustomMessage, Is.EqualTo("A message"));
}
public TemplateTaskQuery(ITemplateDatabase templateDatabase, IStringSerializer stringSerializer,
IObjectIdResetter objectIdResetter, IPKSimConfiguration pkSimConfiguration, ICoreUserSettings userSettings, ITemplateDatabaseConverter templateDatabaseConverter)
{
_objectIdResetter = objectIdResetter;
_pkSimConfiguration = pkSimConfiguration;
_userSettings = userSettings;
_templateDatabaseConverter = templateDatabaseConverter;
_templateDatabase = templateDatabase;
_stringSerializer = stringSerializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="HybridWebView" /> class.
/// </summary>
/// <remarks>HybridWebView will use either <see cref="IJsonSerializer" /> configured
/// with IoC or if missing it will use <see cref="SystemJsonSerializer" /> by default.</remarks>
public HybridWebView()
{
if (!Resolver.IsSet || (_jsonSerializer = Resolver.Resolve <IJsonSerializer>()) == null)
{
_jsonSerializer = new SystemJsonSerializer();
}
_registeredActions = new Dictionary <string, Action <string> >();
_registeredFunctions = new Dictionary <string, Func <string, object[]> >();
}
public override string SerializeToString(object obj)
{
IStringSerializer serializer = GetMappedSerializer();
if (serializer != null)
{
return(serializer.SerializeToString(obj));
}
return(null);
}
/// <summary>
/// Serializes to stream.
/// </summary>
/// <param name="obj">Object to serialize.</param>
/// <param name="stream">Stream to serialize to.</param>
public static void SerializeToStream(this IStringSerializer serializer, object obj, Stream stream)
{
var streamWriter = new StreamWriter(stream)
{
AutoFlush = true
};
var str = serializer.Serialize(obj);
streamWriter.Write(str);
}
protected override void Context()
{
_userSettings = A.Fake <IUserSettings>();
_defaultUserSettings = A.Fake <IUserSettings>();
_serializationManager = A.Fake <IStringSerializer>();
_pkSimConfiguration = A.Fake <IPKSimConfiguration>();
A.CallTo(() => _pkSimConfiguration.UserSettingsFilePath).Returns("blah");
_validUserConfigXml = "<UserConfig/>";
A.CallTo(() => _serializationManager.Serialize(_userSettings)).Returns(_validUserConfigXml);
sut = new UserSettingsPersistor(_serializationManager, _defaultUserSettings, _pkSimConfiguration);
}
protected void SerializeValue(ISerializerFactory sf, ICalendarProperty prop, Type valueType, object v, StringBuilder result)
{
// Get a serializer to serialize the property's value.
// If we can't serialize the property's value, the next step is worthless anyway.
IStringSerializer valueSerializer = sf.Build(valueType, SerializationContext) as IStringSerializer;
if (valueSerializer != null)
{
// Iterate through each value to be serialized,
// and give it a property (with parameters).
// FIXME: this isn't always the way this is accomplished.
// Multiple values can often be serialized within the
// same property. How should we fix this?
// NOTE:
// We Serialize the property's value first, as during
// serialization it may modify our parameters.
// FIXME: the "parameter modification" operation should
// be separated from serialization. Perhaps something
// like PreSerialize(), etc.
string value = valueSerializer.SerializeToString(v);
// Get the list of parameters we'll be serializing
ICalendarParameterCollection parameterList = prop.Parameters;
if (v is ICalendarDataType)
{
parameterList = ((ICalendarDataType)v).Parameters;
}
StringBuilder sb = new StringBuilder(prop.Name);
if (parameterList.Any())
{
// Get a serializer for parameters
IStringSerializer parameterSerializer = sf.Build(typeof(ICalendarParameter), SerializationContext) as IStringSerializer;
if (parameterSerializer != null)
{
// Serialize each parameter
List <string> parameters = new List <string>();
foreach (ICalendarParameter param in parameterList)
{
parameters.Add(parameterSerializer.SerializeToString(param));
}
// Separate parameters with semicolons
sb.Append(";");
sb.Append(string.Join(";", parameters.ToArray()));
}
}
sb.Append(":");
sb.Append(value);
result.Append(TextUtil.WrapLines(sb.ToString()));
}
}
public AzureTableCacheClient(string ConnectionString, string tableName = "Cache")
{
connectionString = ConnectionString;
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
table = tableClient.GetTableReference(tableName);
table.CreateIfNotExists();
serializer = new JsonStringSerializer();
}
public void TestSerializeWithEnglishUsCulture()
{
IStringSerializer serializer = New <IStringSerializer>();
CustomMessageParameters parameters;
string json;
parameters = new CustomMessageParameters(CultureInfo.CreateSpecificCulture("en-US"), "A message");
json = serializer.Serialize(parameters);
Assert.That(json, Is.EqualTo("{\r\n \"messageCulture\": \"en-US\",\r\n \"customMessage\": \"A message\"\r\n}".Replace("\r\n", Environment.NewLine)));
}
public void TestCrossFrameworkPclCultureInfoSerialization()
{
IStringSerializer serializer = New <IStringSerializer>();
CustomMessageParameters parameters;
string json;
parameters = new CustomMessageParameters(CultureInfo.CreateSpecificCulture("en-US"), "A message");
json = serializer.Serialize(parameters.MessageCulture);
Assert.That(json, Is.EqualTo("\"en-US\""));
}
/// <summary>
/// Initializes a new instance of the <see cref="HybridWebView" /> class.
/// </summary>
/// <exception cref="Exception">Exception when there is no <see cref="IJsonSerializer"/> implementation registered.</exception>
/// <remarks>HybridWebView will use <see cref="IJsonSerializer" /> configured
/// with <see cref="Resolver"/> or <see cref="DependencyService"/>. System JSON serializer was removed due to Xamarin
/// requirement of having a business license or higher.</remarks>
public HybridWebView()
{
if (!Resolver.IsSet || (this.jsonSerializer = Resolver.Resolve<IJsonSerializer>() ?? DependencyService.Get<IJsonSerializer>()) == null)
{
#if BUSINESS_LICENSE
_jsonSerializer = new SystemJsonSerializer();
#else
throw new Exception("HybridWebView requires IJsonSerializer implementation to be registered.");
#endif
}
this.registeredActions = new Dictionary<string, Action<string>>();
this.registeredFunctions = new Dictionary<string, Func<string, object[]>>();
}
/// <summary>
/// Initializes a new instance of the <see cref="UserAuthModelUnitOfWorkFactory"/> class.
/// </summary>
/// <param name="stringSerializer">The string serializer.</param>
public UserAuthModelUnitOfWorkFactory(IStringSerializer stringSerializer)
{
serializer = stringSerializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonRestServices"/> class with the specified
/// logger, retry logic, URI builder, and string serializer.
/// </summary>
/// <param name="logger">The logger to use for requests. Specify <c>null</c> if requests do not need to be logged.</param>
/// <param name="retryLogic">The retry logic to use for REST operations.</param>
/// <param name="urlBuilder">The URL builder to use for constructing URLs with query parameters.</param>
/// <param name="stringSerializer">The string serializer to use for requests from this service.</param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="retryLogic"/> is <c>null</c>.
/// <para>-or-</para>
/// <para>If <paramref name="urlBuilder"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para>If <paramref name="stringSerializer"/> is <c>null</c>.</para>
/// </exception>
public JsonRestServices(IRequestLogger logger, IRetryLogic<Response, HttpStatusCode> retryLogic, IUrlBuilder urlBuilder, IStringSerializer stringSerializer)
: base(stringSerializer, logger, retryLogic, urlBuilder)
{
}
/// <param name="serializer"><see cref="IStringSerializer"/> instance used by <see cref="ILogBase"/> implementation
/// to serialize objects to the log.</param>
public LogMessageGenerator(IStringSerializer serializer)
{
this.serializer = serializer;
}
/// <summary>
/// Initializes a new instance of the <see cref="HybridWebView"/> class.
/// </summary>
/// <param name="jsonSerializer">
/// The JSON serializer.
/// </param>
public HybridWebView(IJsonSerializer jsonSerializer)
{
this.jsonSerializer = jsonSerializer;
this.registeredActions = new Dictionary<string, Action<string>>();
}
