void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
// Move past container
if (!reader.Read())
{
throw new XmlException("Error in Deserialization of Dictionary");
}
// reader.ReadStartElement(DictionaryNodeName);
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(Map <TKey, TVal> .ItemNodeName);
reader.ReadStartElement(Map <TKey, TVal> .KeyNodeName);
var key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(Map <TKey, TVal> .ValueNodeName);
var value = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
Add(key, value);
reader.MoveToContent();
}
// reader.ReadEndElement();
reader.ReadEndElement(); // Read End Element to close Read of containing node
}
/// <summary>
/// Returns all the keys in storage.
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <SerializedKey> > LoadKeysAsync()
{
var list = new List <SerializedKey>();
if (!_directory.Exists)
{
_directory.Create();
}
var files = _directory.GetFiles(KeyFilePrefix + "*" + KeyFileExtension);
foreach (var file in files)
{
var id = file.Name.Substring(4);
try
{
using (var reader = new StreamReader(file.OpenRead()))
{
var json = await reader.ReadToEndAsync();
var item = KeySerializer.Deserialize <SerializedKey>(json);
list.Add(item);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error reading file: " + file.Name);
}
}
return(list);
}
void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
if (!reader.Read())
{
throw new System.Xml.XmlException("Error in Deserialization of Dictionary");
}
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
reader.ReadStartElement(ItemNodeName);
reader.ReadStartElement(KeyNodeName);
TKey key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(ValueNodeName);
TVal value = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
Add(key, value);
reader.MoveToContent();
}
reader.ReadEndElement();
}
void IXmlSerializable.ReadXml(XmlReader i_Reader)
{
if (i_Reader.IsEmptyElement)
{
return;
}
// Move past container
if (!i_Reader.Read())
{
throw new XmlException("Error in Deserialization of Dictionary");
}
while (i_Reader.NodeType != XmlNodeType.EndElement)
{
i_Reader.ReadStartElement(k_ItemNodeName);
i_Reader.ReadStartElement(k_KeyNodeName);
TKey key = (TKey)KeySerializer.Deserialize(i_Reader);
i_Reader.ReadEndElement();
i_Reader.ReadStartElement(k_ValueNodeName);
TVal value = (TVal)ValueSerializer.Deserialize(i_Reader);
i_Reader.ReadEndElement();
i_Reader.ReadEndElement();
this.Add(key, value);
i_Reader.MoveToContent();
}
//reader.ReadEndElement();
i_Reader.ReadEndElement(); // Read End Element to close Read of containing node
}
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
if (!reader.Read())
{
throw new XmlException("Error in Deserialization of Dictionary");
}
//HERE IS THE TRICK
if (reader is KnownTypesXmlReader)
{
SetKnownTypes(((KnownTypesXmlReader)reader).ExtraTypes);
}
//reader.ReadStartElement(DictionaryNodeName);
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(ItemNodeName);
reader.ReadStartElement(KeyNodeName);
TKey key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(ValueNodeName);
TVal value = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
this.Add(key, value);
reader.MoveToContent();
}
//reader.ReadEndElement();
reader.ReadEndElement(); // Read End Element to close Read of containing node
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param>
void IXmlSerializable.ReadXml(XmlReader reader)
{
bool wasEmpty = reader.IsEmptyElement;
reader.Read();
if (wasEmpty)
{
return;
}
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(keyItem);
reader.ReadStartElement(keyKey);
var key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(keyValue);
var value = (TValue)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
Add(key, value);
reader.ReadEndElement();
reader.MoveToContent();
}
reader.ReadEndElement();
}
/// <exception cref="ArgumentNullException">any argument is null</exception>
public CipherFormPresenter(ICipherForm cipherForm,
IList <FileSystemEntity> inputFileEntities,
IRsaFactory rsaFactory,
KeySerializer keySerializer,
ICommandsContainer commandsContainer,
IFileUnifier fileUnifier,
IEnvironmentHelper environmentHelper,
IMessageHelper messageHelper,
Options options)
{
Checker.CheckNull(cipherForm, keySerializer, commandsContainer);
this.cipherForm = cipherForm;
this.inputFileEntities = inputFileEntities;
this.rsaFactory = rsaFactory;
this.keySerializer = keySerializer;
this.commandsContainer = commandsContainer;
this.fileUnifier = fileUnifier;
this.environmentHelper = environmentHelper;
this.messageHelper = messageHelper;
this.options = options;
cipherForm.InputFileEntities = inputFileEntities;
cipherForm.TotalLength = GetTotalLength();
cipherForm.OutputFileName = GetOutputFileName();
cipherForm.ZipСompression = options.ZipСompression;
cipherForm.Cipher += cipherForm_Cipher;
cipherForm.CancelCipher += cipherForm_CancelCipher;
cipherForm.OutputFileNameChanged += cipherForm_OutputFileNameChanged;
cipherForm.PublicKeyChanged += cipherForm_PublicKeyChanged;
}
public Task <Message <TKey, TValue> > ProduceAsync(string topic, TKey key, TValue val, DateTime?timestamp = null, int?partition = null, bool blockIfQueueFull = true)
{
var handler = new TypedTaskDeliveryHandlerShim(key, val);
producer.ProduceAsync(topic, KeySerializer?.Serialize(key), ValueSerializer?.Serialize(val), handler, timestamp, partition, blockIfQueueFull);
return(handler.Task);
}
/// <summary>
/// Creates a new instance of <see cref="EntityToSerialize"/>.
/// </summary>
/// <param name="entity">The entity itself.</param>
/// <param name="resourceType">The type of the entity.</param>
/// <param name="resourceSetWrapper">The resource set the entity belongs to.</param>
/// <param name="provider">The wrapper for the current service provider.</param>
/// <param name="absoluteServiceUri">The absolute service URI.</param>
/// <returns>The new instance of <see cref="EntityToSerialize"/></returns>
internal static EntityToSerialize Create(object entity, ResourceType resourceType, ResourceSetWrapper resourceSetWrapper, DataServiceProviderWrapper provider, Uri absoluteServiceUri)
{
Debug.Assert(provider != null, "provider != null");
Debug.Assert(provider.DataService != null, "provider.DataService != null");
Debug.Assert(provider.DataService.Configuration != null, "provider.DataService.Configuration != null");
Debug.Assert(provider.DataService.Configuration.DataServiceBehavior != null,
"provider.DataService.Configuration.DataServiceBehavior != null");
KeySerializer keySerializer = KeySerializer.Create(provider.DataService.Configuration.DataServiceBehavior.GenerateKeyAsSegment);
Func <ResourceProperty, object> getPropertyValue = p =>
{
object keyValue = WebUtil.GetPropertyValue(provider, entity, resourceType, p, null);
if (keyValue == null)
{
throw new InvalidOperationException(Service.Strings.Serializer_NullKeysAreNotSupported(p.Name));
}
return(keyValue);
};
bool includeTypeSegment = resourceSetWrapper.ResourceType != resourceType;
return(Create(entity, resourceType, resourceSetWrapper.Name, includeTypeSegment, getPropertyValue, keySerializer, absoluteServiceUri));
}
/// <summary>Generates an object from its XML representation.</summary>
/// <param name="reader">
/// The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.
/// </param>
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
// Move past container
if (reader.NodeType == XmlNodeType.Element && !reader.Read())
{
throw new XmlException("Error in Deserialization of SerializableDictionary");
}
while (reader.NodeType != XmlNodeType.EndElement)
{
var key = (TKey)KeySerializer.Deserialize(reader);
var value = (TVal)ValueSerializer.Deserialize(reader);
Add(key, value);
reader.MoveToContent();
}
// Move past container
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
else
{
throw new XmlException("Error in Deserialization of SerializableDictionary");
}
}
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
// Move past container
if (!reader.Read())
{
throw new XmlException("Error in Deserialization of Dictionary");
}
//reader.ReadStartElement(DictionaryNodeName);
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement(ItemNodeName);
reader.ReadStartElement(KeyNodeName);
TKey key = (TKey)KeySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement(ValueNodeName);
TVal valor = (TVal)ValueSerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadEndElement();
this.Add(key, valor);
reader.MoveToContent();
}
//reader.ReadEndElement();
reader.ReadEndElement(); // Read End Element to close Read of containing node
//Debug.Log("IXmlSerializable.ReadXml");
}
private void Produce(string topic, TKey key, TValue val, DateTime?timestamp, int partition, bool blockIfQueueFull, IDeliveryHandler <TKey, TValue> deliveryHandler)
{
var handler = new TypedDeliveryHandlerShim(key, val, deliveryHandler);
var keyBytes = KeySerializer?.Serialize(key);
var valBytes = ValueSerializer?.Serialize(val);
producer.Produce(topic, valBytes, 0, valBytes == null ? 0 : valBytes.Length, keyBytes, 0, keyBytes == null ? 0 : keyBytes.Length, timestamp, partition, blockIfQueueFull, handler);
}
/// <summary>Converts an object into its XML representation.</summary>
/// <param name="writer">
/// The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized.
/// </param>
void IXmlSerializable.WriteXml(XmlWriter writer)
{
foreach (KeyValuePair <TKey, TVal> pair in this)
{
KeySerializer.Serialize(writer, pair.Key);
ValueSerializer.Serialize(writer, pair.Value);
}
}
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>
/// An enumerator that can be used to iterate through the collection.
/// </returns>
public IEnumerator <KeyValuePair <TKey, TValue> > GetEnumerator()
{
foreach (var hashKey in RedisDb.HashKeys(RedisKey))
{
var redisValue = RedisDb.HashGet(RedisKey, hashKey);
yield return(new KeyValuePair <TKey, TValue>(KeySerializer.Deserialize <TKey>(hashKey), ValueSerializer.Deserialize <TValue>(redisValue)));
}
}
public virtual async Task <ISet <TItem> > GetValueOrEmptyAsync(TKey key)
{
var setMap = (ISetMap <TKey, TItem>)Map;
var items = await setMap.GetValueOrEmptyAsync(key);
await Scope.AddKeyAsync(Identifier, KeySerializer.Serialize(key)).ConfigureAwait(false);
return(_removeOnEmptySet ? new SetWrapper(key, items, _scope, Identifier, _keySerializer) : items);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="serviceBaseUri">The base URI of the service. This will be used as the base URI for all entity containers.</param>
/// <param name="urlConvention">The specific url convention to use.</param>
internal ODataConventionalUriBuilder(Uri serviceBaseUri, UrlConvention urlConvention)
{
Debug.Assert(serviceBaseUri != null && serviceBaseUri.IsAbsoluteUri, "serviceBaseUri != null && serviceBaseUri.IsAbsoluteUri");
Debug.Assert(urlConvention != null, "urlConvention != null");
this.serviceBaseUri = serviceBaseUri;
this.urlConvention = urlConvention;
this.keySerializer = KeySerializer.Create(this.urlConvention);
}
public void Serialize_should_return_bytes_from_guid()
{
var sut = new KeySerializer <Guid>();
var expectedGuid = Guid.NewGuid();
var result = sut.Serialize(expectedGuid, default);
result.Should().BeEquivalentTo(expectedGuid.ToByteArray());
}
public AesManaged GetAesManaged()
{
if (aesManaged == null)
{
aesManaged = new AesManaged();
aesManaged.IV = KeySerializer.StringToByteArray(IV);
aesManaged.Key = KeySerializer.StringToByteArray(Key);
}
return(aesManaged);
}
public void SetUp()
{
decipherForm = new Mock <IDecipherForm>();
rsaFactory = new Mock <IRsaFactory>();
keySerializer = new KeySerializer(new BigNumberHexSerializer());
environmentHelper = new Mock <IEnvironmentHelper>();
messageHelper = new Mock <IMessageHelper>();
commandsContainer = new Mock <ICommandsContainer>();
fileUnifier = new Mock <IFileUnifier>();
}
public void Init()
{
this.keyProperty1 = new ResourceProperty("Key1", ResourcePropertyKind.Key | ResourcePropertyKind.Primitive, ResourceType.GetPrimitiveResourceType(typeof(string)));
this.keyProperty2 = new ResourceProperty("Key2", ResourcePropertyKind.Key | ResourcePropertyKind.Primitive, ResourceType.GetPrimitiveResourceType(typeof(int)));
this.defaultSerializer = KeySerializer.Create(UrlConvention.CreateWithExplicitValue(false));
this.segmentSerializer = KeySerializer.Create(UrlConvention.CreateWithExplicitValue(true));
this.singleKeyProperty = new[] { this.keyProperty1 };
this.compositeKey = new[] { this.keyProperty1, this.keyProperty2 };
}
public void Init()
{
this.keyProperty1 = new ResourceProperty("Key1", ResourcePropertyKind.Key | ResourcePropertyKind.Primitive, ResourceType.GetPrimitiveResourceType(typeof(string)));
this.keyProperty2 = new ResourceProperty("Key2", ResourcePropertyKind.Key | ResourcePropertyKind.Primitive, ResourceType.GetPrimitiveResourceType(typeof(int)));
this.defaultSerializer = KeySerializer.Create(false);
this.segmentSerializer = KeySerializer.Create(true);
this.singleKeyProperty = new[] { this.keyProperty1 };
this.compositeKey = new[] { this.keyProperty1, this.keyProperty2 };
}
public SerializedKey Protect(RsaKeyContainer key)
{
ProtectWasCalled = true;
return(new SerializedKey
{
Id = key.Id,
KeyType = key.KeyType,
Created = DateTime.UtcNow,
Data = KeySerializer.Serialize(key),
});
}
public void Serialize_should_return_json_bytes_from_class()
{
var sut = new KeySerializer <DummyMessage>();
var message = DummyMessage.New();
var jsonMessage = JsonSerializer.Serialize(message);
var expectedData = Encoding.UTF8.GetBytes(jsonMessage);
var result = sut.Serialize(message, default);
result.Should().BeEquivalentTo(expectedData);
}
/// <summary>
/// Gets or sets the <see cref="TValue"/> with the specified key.
/// </summary>
/// <value>
/// The <see cref="TValue"/>.
/// </value>
/// <param name="key">The key.</param>
/// <returns></returns>
public TValue this[TKey key]
{
get
{
var redisValue = RedisDb.HashGet(RedisKey, KeySerializer.Serialize(key));
return(redisValue.IsNull ? default(TValue) : ValueSerializer.Deserialize <TValue>(redisValue));
}
set
{
Add(key, value);
}
}
/// <summary>
/// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1" /> to an <see cref="T:System.Array" />, starting at a particular <see cref="T:System.Array" /> index.
/// </summary>
/// <param name="array">The one-dimensional <see cref="T:System.Array" /> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1" />. The <see cref="T:System.Array" /> must have zero-based indexing.</param>
/// <param name="arrayIndex">The zero-based index in <paramref name="array" /> at which copying begins.</param>
public void CopyTo(KeyValuePair <TKey, TValue>[] array, int arrayIndex)
{
var values = RedisDb.HashGetAll(RedisKey);
for (var i = 0; i < values.Length; i++)
{
var key = KeySerializer.Deserialize <TKey>(values[i].Name);
var value = ValueSerializer.Deserialize <TValue>(values[i].Value);
array[i + arrayIndex] = new KeyValuePair <TKey, TValue>(key, value);
}
}
public SerializedKey Protect(KeyContainer key)
{
ProtectWasCalled = true;
return(new SerializedKey
{
Id = key.Id,
Algorithm = key.Algorithm,
IsX509Certificate = key.HasX509Certificate,
Created = DateTime.UtcNow,
Data = KeySerializer.Serialize(key),
});
}
void System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter writer)
{
foreach (System.Collections.Generic.KeyValuePair <TKey, TVal> kvp in this)
{
writer.WriteStartElement(ItemNodeName);
writer.WriteStartElement(KeyNodeName);
KeySerializer.Serialize(writer, kvp.Key);
writer.WriteEndElement();
writer.WriteStartElement(ValueNodeName);
ValueSerializer.Serialize(writer, kvp.Value);
writer.WriteEndElement();
writer.WriteEndElement();
}
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
foreach (var kvp in this)
{
writer.WriteStartElement(ItemNodeName);
writer.WriteStartElement(KeyNodeName);
KeySerializer.Serialize(writer, kvp.Key);
writer.WriteEndElement();
writer.WriteStartElement(ValueNodeName);
ValueSerializer.Serialize(writer, kvp.Value);
writer.WriteEndElement();
writer.WriteEndElement();
}
}
void IXmlSerializable.WriteXml(XmlWriter i_Writer)
{
//writer.WriteStartElement(DictionaryNodeName);
foreach (KeyValuePair <TKey, TVal> kvp in this)
{
i_Writer.WriteStartElement(k_ItemNodeName);
i_Writer.WriteStartElement(k_KeyNodeName);
KeySerializer.Serialize(i_Writer, kvp.Key);
i_Writer.WriteEndElement();
i_Writer.WriteStartElement(k_ValueNodeName);
ValueSerializer.Serialize(i_Writer, kvp.Value);
i_Writer.WriteEndElement();
i_Writer.WriteEndElement();
}
}
/// <summary>
/// Persists new key in storage.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public Task StoreKeyAsync(SerializedKey key)
{
if (!_directory.Exists)
{
_directory.Create();
}
var json = KeySerializer.Serialize(key);
var path = Path.Combine(_directory.FullName, KeyFilePrefix + key.Id + KeyFileExtension);
File.WriteAllText(path, json, Encoding.UTF8);
return(Task.CompletedTask);
}
void IXmlSerializable.WriteXml(System.Xml.XmlWriter writer)
{
//writer.WriteStartElement(DictionaryNodeName);
foreach (KeyValuePair <TKey, TVal> kvp in this)
{
writer.WriteStartElement(ItemNodeName);
writer.WriteStartElement(KeyNodeName);
KeySerializer.Serialize(writer, kvp.Key);
writer.WriteEndElement();
writer.WriteStartElement(ValueNodeName);
ValueSerializer.Serialize(writer, kvp.Value);
writer.WriteEndElement();
writer.WriteEndElement();
}
//writer.WriteEndElement();
}
public void Execute()
{
var file = filesView.SelectedFile;
if (!CheckFile(file))
{
throw new InvalidOperationException("Selected file is null or is not rsa.");
}
using (var form = formFactory.CreateDecipherForm()) {
form.InputFileName = file.FullName;
var serializer = new KeySerializer(new BigNumberHexSerializer());
new DecipherFormPresenter(form, rsaFactory, serializer, commandsContainer, file, environmentHelper, messageHelper,
fileUnifier);
form.ShowDialog();
}
}
/// <summary>
/// Creates a new instance of <see cref="EntityToSerialize"/>.
/// </summary>
/// <param name="entity">The entity itself.</param>
/// <param name="resourceType">The type of the entity.</param>
/// <param name="resourceSetName">Name of the resource set the entity belongs to.</param>
/// <param name="includeTypeSegment">if set to <c>true</c> then the type segment should be included in the edit link.</param>
/// <param name="getPropertyValue">The callback to get each property value.</param>
/// <param name="keySerializer">The key serializer to use.</param>
/// <param name="absoluteServiceUri">The absolute service URI.</param>
/// <returns>The new instance of <see cref="EntityToSerialize"/>.</returns>
internal static EntityToSerialize Create(object entity, ResourceType resourceType, string resourceSetName, bool includeTypeSegment, Func<ResourceProperty, object> getPropertyValue, KeySerializer keySerializer, Uri absoluteServiceUri)
{
Debug.Assert(!string.IsNullOrEmpty(resourceSetName), "container name must be specified");
Debug.Assert(absoluteServiceUri != null && absoluteServiceUri.IsAbsoluteUri, "absoluteServiceUri != null && absoluteServiceUri.IsAbsoluteUri");
string editLinkSuffix = null;
if (includeTypeSegment)
{
editLinkSuffix = resourceType.FullName;
}
SerializedEntityKey serializedKey = LazySerializedEntityKey.Create(keySerializer, absoluteServiceUri, resourceSetName, resourceType.KeyProperties, getPropertyValue, editLinkSuffix);
return CreateFromExplicitValues(entity, resourceType, serializedKey);
}
/// <summary>
/// Creates an instance of <see cref="SerializedEntityKey"/> for the given properties and values.
/// </summary>
/// <param name="keySerializer">The key serializer to use.</param>
/// <param name="absoluteServiceUri">The absolute service URI.</param>
/// <param name="entitySetName">Name of the entity set.</param>
/// <param name="keyProperties">The key properties.</param>
/// <param name="getPropertyValue">The callback to get each property's value.</param>
/// <param name="editLinkSuffix">The suffix to append to the edit-link, or null.</param>
/// <returns>A serialized-key instance.</returns>
internal static SerializedEntityKey Create(
KeySerializer keySerializer,
Uri absoluteServiceUri,
string entitySetName,
ICollection<ResourceProperty> keyProperties,
Func<ResourceProperty, object> getPropertyValue,
string editLinkSuffix)
{
SimpleLazy<string> lazyRelativeIdentity = new SimpleLazy<string>(() =>
{
var builder = new StringBuilder();
builder.Append(entitySetName);
keySerializer.AppendKeyExpression(builder, keyProperties, p => p.Name, getPropertyValue);
return builder.ToString();
});
return new LazySerializedEntityKey(lazyRelativeIdentity, absoluteServiceUri, editLinkSuffix);
}