public XMLValidatorTests()
{
schemaValidator = A.Fake<ISchemaValidator>();
businessValidator = A.Fake<IMemberRegistrationBusinessValidator>();
xmlConverter = A.Fake<IXmlConverter>();
errorTranslator = A.Fake<IXmlErrorTranslator>();
}
public static string ToXml(this IXmlConverter converter, Type valueType, object value, XmlMember member = null, XmlContract contract = null, XmlSerializerSettings settings = null)
{
var builder = new StringBuilder();
var context = CreateContext(valueType, member, contract, settings);
using (var output = new StringWriter(builder))
using (var writer = XmlWriter.Create(output, context.Settings.GetWriterSettings()))
{
writer.WriteStartElement("xml");
var isAttribute = context.Member.MappingType == XmlMappingType.Attribute;
if (isAttribute)
{
writer.WriteStartAttribute(context.Member.Name);
}
converter.WriteXml(writer, value, context);
if (isAttribute)
{
writer.WriteEndAttribute();
}
writer.WriteEndElement();
}
return(builder.ToString());
}
public XMLValidator(ISchemaValidator schemaValidator, IXmlConverter xmlConverter, IMemberRegistrationBusinessValidator businessValidator, IXmlErrorTranslator errorTranslator)
{
this.schemaValidator = schemaValidator;
this.businessValidator = businessValidator;
this.errorTranslator = errorTranslator;
this.xmlConverter = xmlConverter;
}
public GenerateProducerDataTestsBuilder()
{
XmlConverter = A.Fake <IXmlConverter>();
DataAccess = A.Fake <IGenerateFromXmlDataAccess>();
InstantiateProducerParameters();
}
static void Main(string[] args)
{
IXmlConverter xmlConverter = resolver.Get <IXmlConverter>();
XDocument document = xmlConverter.GetXMLDocument(resolver.Get <IUrlConverter>(), resolver.Get <IFileReader>());
document.Save("XML_result.xml");
}
public XMLValidatorTests()
{
schemaValidator = A.Fake <ISchemaValidator>();
businessValidator = A.Fake <IMemberRegistrationBusinessValidator>();
xmlConverter = A.Fake <IXmlConverter>();
errorTranslator = A.Fake <IXmlErrorTranslator>();
}
public ProcessXMLFileHandlerTests()
{
memberUploadsDbSet = A.Fake <DbSet <MemberUpload> >();
producersDbSet = A.Fake <DbSet <ProducerSubmission> >();
xmlConverter = A.Fake <IXmlConverter>();
producerSubmissionDataAccess = A.Fake <IProducerSubmissionDataAccess>();
var schemes = new[]
{
FakeSchemeData()
};
schemesDbSet = helper.GetAsyncEnabledDbSet(schemes);
context = A.Fake <WeeeContext>();
A.CallTo(() => context.Schemes).Returns(schemesDbSet);
A.CallTo(() => context.ProducerSubmissions).Returns(producersDbSet);
A.CallTo(() => context.MemberUploads).Returns(memberUploadsDbSet);
generator = A.Fake <IGenerateFromXml>();
xmlValidator = A.Fake <IXMLValidator>();
xmlChargeBandCalculator = A.Fake <IXMLChargeBandCalculator>();
totalChargeCalculator = A.Fake <ITotalChargeCalculator>();
totalChargeCalculatorDataAccess = A.Fake <ITotalChargeCalculatorDataAccess>();
handler = new ProcessXMLFileHandler(context, permissiveAuthorization, xmlValidator, generator, xmlConverter, xmlChargeBandCalculator, producerSubmissionDataAccess, totalChargeCalculator, totalChargeCalculatorDataAccess);
}
public XMLValidator(ISchemaValidator schemaValidator, IXmlConverter xmlConverter, IMemberRegistrationBusinessValidator businessValidator, IXmlErrorTranslator errorTranslator)
{
this.schemaValidator = schemaValidator;
this.businessValidator = businessValidator;
this.errorTranslator = errorTranslator;
this.xmlConverter = xmlConverter;
}
public CollectionXmlConverter(string collection_tag, string element_tag)
{
CollectionTag = collection_tag;
SubConverter = new XmlConverter <T>(
x => new XElement(element_tag, x.ToString()),
element => (T)Activator.CreateInstance(typeof(T), element.Value.Trim())
);
}
public XmlTypeContext(XmlContract contract, IXmlConverter readConverter, IXmlConverter writeConverter)
{
this.contract = contract;
this.readConverter = readConverter;
this.writeConverter = writeConverter;
reader = readConverter != null ? readConverter.ReadXml : NotReadable(contract.ValueType);
writer = writeConverter != null ? writeConverter.WriteXml : NotWritable(contract.ValueType);
}
public ConverterService(
IFileRepository fileRepository, ICloudRepository cloudRepository,
IXmlConverter xmlConverter, IJsonConverter jsonConverter)
{
_fileRepository = fileRepository;
_cloudRepository = cloudRepository;
_xmlConverter = xmlConverter;
_jsonConverter = jsonConverter;
}
public static void Execute()
{
IJsonCoverter j = null;
IByteArrayConveter b = null;
IXmlConverter x = null;
var converter = new ConverterFacade(j, x, b);
var json = converter.ToJson();
}
private Type DeserializeItemsFromElements(Type entityType, IList parent, ListPropertyDescriptor metadata, XmlReader reader, XmlSerializerContext context)
{
ListItemPropertyDescriptor propDesc = metadata.GetItemPropertyDescriptor(context, false);
//avanzo hasta la posicion del elemento
string nodeName = reader.LocalName;
//avanzo hasta el primer nodo
bool end = !reader.Read();
XmlNodeType typeNode = reader.MoveToContent();
object association;
Type itemType = null;
//parseo las propiedades
while (!end)
{
//me fijo si la propiedad es vacia
if (reader.NodeType != XmlNodeType.EndElement)
{
//obtengo el tipo por el atributo
itemType = base.GetEntityTypeForElement(propDesc, reader, context);
if (itemType != null)
{
IXmlConverter converter = context.GetConverter(itemType);
association = converter.FromXml(parent, propDesc, itemType, reader, context);
if (association != null || context.Settings.AddNullValueInLists)
{
//agrego el item a la lista
parent.Add(association);
}
}
else
{
reader.Skip();
}
}
//avanzo...
typeNode = reader.MoveToContent();
end = reader.NodeType == XmlNodeType.EndElement && reader.LocalName.Equals(nodeName);
}
reader.Read();
if (entityType.IsArray && itemType != null)
{
return(itemType);
}
else
{
return(metadata.DeclaringItemType);
}
}
public object Xml2Obj(string xml, Type type)
{
if (xml == null)
{
return(null);
}
if (type.IsSubclassOf(typeof(IXmlConverter)))
{
IXmlConverter converter = GetDefaultValue(type) as IXmlConverter;
converter.Xml2Object(xml);
return(converter);
}
if (IsPrimitiveXmlType(type) && !IsXmlString(xml))
{
if (type == typeof(string))
{
return(xml);
}
if (string.IsNullOrEmpty(xml))
{
return(GetDefaultValue(type));
}
if (type == typeof(int))
{
return(Convert.ToInt32(xml, CultureInfo.InvariantCulture));
}
if (type == typeof(double))
{
return(Convert.ToDouble(xml, CultureInfo.InvariantCulture));
}
;
if (type == typeof(bool))
{
return(Convert.ToBoolean(xml, CultureInfo.InvariantCulture));
}
if (type == typeof(DateTime))
{
xml = string.Format(CultureInfo.InvariantCulture, "<{0}>{1}</{0}>", "dateTime", xml);
return(MsgTransfer.Xml2Object(xml, type, true));
}
}
else
{
if (string.IsNullOrEmpty(xml))
{
return(GetDefaultValue(type));
}
return(MsgTransfer.Xml2Object(xml, type, true));
}
Exception <TypeConvertExceptionMessage> exception = new Exception <TypeConvertExceptionMessage>();
exception.Reference = xml;
exception.ErrorInfo.TargetTypeName = type.FullName;
throw exception;
}
void IXmlContextData.RegisterConverter(Type type, IXmlConverter converter)
{
if (type == null)
{
type = __nullType;
}
//registro los converters globales....
XmlSerializerContext.ConverterMap[type] = converter;
}
public TotalChargeCalculatorTests()
{
xmlChargeBandCalculator = A.Fake <IXMLChargeBandCalculator>();
xmlConverter = A.Fake <IXmlConverter>();
totalCharge = 0;
file = ProcessTestXmlFile();
totalChargeCalculator = new TotalChargeCalculator(xmlChargeBandCalculator, xmlConverter);
}
internal RouteEndPoint(string APIKey, IXmlConverter <Route> routeConverter, IDataSource dataSource)
{
if (routeConverter == null || dataSource == null || string.IsNullOrEmpty(APIKey))
{
throw new ArgumentNullException();
}
_RouteDataSource = dataSource;
_RouteConverter = routeConverter;
}
private void DeserializeKeyValueAtttributes(IDictionary parent, DictionaryKeyValuePropertyDescriptor keyDesc, DictionaryKeyValuePropertyDescriptor valueDesc, XmlReader reader, XmlSerializerContext context, out object key, out object value)
{
string attName;
Type keyType;
Type valueType;
key = null;
value = null;
if (reader.MoveToFirstAttribute())
{
attName = reader.Name;
keyType = keyDesc.GetTypeFromAttributeName(attName, context);
if (keyType == null)
{
valueType = valueDesc.GetTypeFromAttributeName(attName, context);
if (valueType != null)
{
IXmlConverter converter = context.GetConverter(valueType);
value = converter.FromXml(parent, valueDesc, valueType, reader, context);
}
}
else
{
IXmlConverter converter = context.GetConverter(keyType);
key = converter.FromXml(parent, keyDesc, keyType, reader, context);
}
if (reader.MoveToNextAttribute())
{
attName = reader.Name;
keyType = keyDesc.GetTypeFromAttributeName(attName, context);
if (keyType == null)
{
valueType = valueDesc.GetTypeFromAttributeName(attName, context);
if (valueType != null)
{
IXmlConverter converter = context.GetConverter(valueType);
value = converter.FromXml(parent, valueDesc, valueType, reader, context);
}
}
else
{
IXmlConverter converter = context.GetConverter(keyType);
key = converter.FromXml(parent, keyDesc, keyType, reader, context);
}
}
}
//me ubico en el elemento..
reader.MoveToContent();
}
internal ETAEndPoint(string APIKey, IXmlConverter <ETA> converter, IDataSource dataSource)
{
if (converter == null || dataSource == null || string.IsNullOrEmpty(APIKey))
{
throw new ArgumentNullException();
}
_APIKey = APIKey;
_dataSource = dataSource;
_converter = converter;
}
public UpdateProducerCharges(WeeeMigrationContext context,
IMigrationDataAccess memberUploadDataAccess,
IXmlConverter xmlConverter,
IMigrationProducerChargeBandCalculatorChooser producerChargeCalculator,
IMigrationTotalChargeCalculatorDataAccess totalChargeCalculatorDataAccess)
{
this.memberUploadDataAccess = memberUploadDataAccess;
this.xmlConverter = xmlConverter;
this.producerChargeCalculator = producerChargeCalculator;
this.totalChargeCalculatorDataAccess = totalChargeCalculatorDataAccess;
this.context = context;
}
public virtual void RegisterConverter(Type type, IXmlConverter converter)
{
if (type == null)
{
type = __nullType;
}
this.Stack.ConverterMap[type] = converter;
if (!this.GlobalConverterMap.ContainsKey(type))
{
this.GlobalConverterMap[type] = converter;
}
}
public static void Configure(IXmlConverter converter)
{
converterConfigFromXml.converter = converter;
converter.Rules = new xmlConverterRulesCollection();
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
XmlReader reader = XmlReader.Create(new StringReader(Properties.Resources.xmlConverter), settings);
while (reader.Read())
{
Debug.Print(reader.LocalName);
if (reader.LocalName == "rule" && reader.GetAttribute("type") == "RootTagRule")
readRootTagRule(reader);
}
}
public ProcessXMLFileHandler(WeeeContext context, IWeeeAuthorization authorization,
IXMLValidator xmlValidator, IGenerateFromXml generateFromXml, IXmlConverter xmlConverter,
IXMLChargeBandCalculator xmlChargeBandCalculator, IProducerSubmissionDataAccess producerSubmissionDataAccess, ITotalChargeCalculator totalChargeCalculator, ITotalChargeCalculatorDataAccess totalChargeCalculatorDataAccess)
{
this.context = context;
this.authorization = authorization;
this.xmlValidator = xmlValidator;
this.xmlConverter = xmlConverter;
this.xmlChargeBandCalculator = xmlChargeBandCalculator;
this.generateFromXml = generateFromXml;
this.producerSubmissionDataAccess = producerSubmissionDataAccess;
this.totalChargeCalculator = totalChargeCalculator;
this.totalChargeCalculatorDataAccess = totalChargeCalculatorDataAccess;
}
private void DeserializeElements(object parent, TypeDescriptor entityTypeDescriptor, XmlReader reader, XmlSerializerContext context)
{
string nodeName = reader.LocalName;
//avanzo hasta la posicion del elemento
bool end = !reader.Read();
XmlNodeType typeNode = reader.MoveToContent();
object association;
PropertyDescriptor prop;
//parseo las propiedades
while (!end)
{
//me fijo si la propiedad es vacia
if (reader.NodeType != XmlNodeType.EndElement)
{
prop = entityTypeDescriptor.GetPropertyByElementName(reader.LocalName);
if (prop != null)
{
Type xmlType = base.GetEntityTypeForElement(prop, reader, context);
if (xmlType != null)
{
IXmlConverter converter = context.GetConverter(xmlType);
association = converter.FromXml(parent, prop, xmlType, reader, context);
prop.Metadata.SetValue(parent, association);
}
else
{
reader.Skip();
}
}
else
{
//DefaultLogger.Warning("The xml element {0} doesn't match with a property of the class {1}", reader.LocalName, parent.GetType().ToString());
reader.Skip();
}
}
typeNode = reader.MoveToContent();
end = reader.NodeType == XmlNodeType.EndElement && reader.LocalName.Equals(nodeName);
}
reader.Read();
}
private static IXmlConverter GetConverter(XmlContract contract, IXmlConverter converter)
{
if (converter == null)
{
return(null);
}
var factory = converter as IXmlConverterFactory;
if (factory != null)
{
converter = factory.CreateConverter(contract);
}
return(converter);
}
public static void Configure(IXmlConverter converter)
{
converterConfigFromXml.converter = converter;
converter.Rules = new xmlConverterRulesCollection();
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
XmlReader reader = XmlReader.Create(new StringReader(Properties.Resources.xmlConverter), settings);
while (reader.Read())
{
Debug.Print(reader.LocalName);
if (reader.LocalName == "rule" && reader.GetAttribute("type") == "RootTagRule")
{
readRootTagRule(reader);
}
}
}
public static object ParseXml(this IXmlConverter converter, Type valueType, string xmlString, XmlMember member = null, XmlContract contract = null, XmlSerializerSettings settings = null)
{
var context = CreateContext(valueType, member, contract, settings);
using (var input = new StringReader(xmlString))
using (var reader = XmlReader.Create(input, context.Settings.GetReaderSettings()))
{
while (reader.NodeType != XmlNodeType.Element && reader.Read())
{
}
if (reader.Name != "xml")
{
Assert.Fail("Expected start element \"xml\".");
}
var isAttribute = context.Member.MappingType == XmlMappingType.Attribute;
if (isAttribute)
{
reader.MoveToAttribute(context.Member.Name.LocalName, context.Member.Name.NamespaceUri);
}
var value = converter.ReadXml(reader, context);
if (isAttribute)
{
reader.MoveToElement();
if (reader.NodeType != XmlNodeType.Element || reader.Name != "xml")
{
Assert.Fail("Expected element \"xml\".");
}
}
else if (reader.NodeType != XmlNodeType.None)
{
Assert.Fail("Expected end of xml.");
}
return(value);
}
}
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
/// <param name="entity"></param>
/// <param name="rootElementName"></param>
/// <param name="declareRootType">Indica si debe resgitrar el tipo del objeto como atributo del elemento Root. Si es true, lo registra si no hay un alias definido, sino, no lo registra.</param>
public virtual void Serialize(XmlTextWriter writer, object entity, string rootElementName)
{
if (entity == null)
{
return;
}
Type type = entity.GetType();
if (!type.IsSerializable)
{
throw new SerializationException("The entity " + type.Name + " is not marked as serializable.");
}
XmlSerializerContext context = this.CreateContext();
object holder = this.CreateObjectHolder(type, entity);
TypeDescriptor holderDesc = new TypeDescriptor(holder.GetType());
PropertyDescriptor desc = holderDesc.Properties[0];
RootPropertyMetadata metadata;
if (string.IsNullOrEmpty(rootElementName))
{
rootElementName = this.GetElementName(type, context);
metadata = new RootPropertyMetadata(rootElementName, desc.Metadata.DefaultAttributeName, desc.Metadata);
}
else
{
context.RegisterAlias(rootElementName, entity.GetType());
metadata = new RootPropertyMetadata(rootElementName, desc.Metadata.DefaultAttributeName, desc.Metadata);
}
desc.Metadata = metadata;
desc.UseAlias = true;
//podria agregar la instancia a serializa y tener un seguimiento de la secuencia.....pero para mas adelante
this.Context = context;
IXmlConverter converter = context.GetConverter(type);
converter.ToXml(holder, desc, entity, writer, context);
}
static public string Obj2Xml(object result)
{
if (result == null)
{
return(null);
}
IXmlConverter converter = result as IXmlConverter;
if (converter != null)
{
return(converter.Object2Xml());
}
string rltString = MsgTransfer.Object2XmlString(result);
if (!IsPrimitiveXmlType(result.GetType()))
{
return(rltString);
}
Match match = xmlTextRegex.Match(rltString);
return(match.Groups[1].Value);
}
private void DeserializeAttributes(object parent, TypeDescriptor entityTypeDescriptor, XmlReader reader, XmlSerializerContext context)
{
//avanzo hasta el primer atributo
bool isAtt = reader.MoveToFirstAttribute();
PropertyDescriptor prop;
//si es un atributo, el tipo de la entidad coincide con el definido en la propiedad...
string attName;
object value;
if (isAtt)
{
do
{
attName = reader.Name;
prop = entityTypeDescriptor.GetPropertyByAttributeName(attName);
if (prop != null)
{
//obtengo el tipo a partir del atributo
Type propType = prop.GetTypeFromAttributeName(attName, context);
IXmlConverter converter = context.GetConverter(propType);
value = converter.FromXml(parent, prop, propType, reader, context);
prop.Metadata.SetValue(parent, value);
}
else
{
//if (! (string.Compare(context.Settings.TypeSettings.AttributeTypeName, attName) == 0
// || string.Compare(XmlSerializerSettings.ObjectReferenceAttributeName, attName) == 0
// || string.Compare(XmlSerializerSettings.ObjectIdAttributeName, attName) == 0))
//DefaultLogger.Warning("The xml attribute {0} doesn't match with an property of the class {1}", attName, parent.GetType().ToString());
}
}while (reader.MoveToNextAttribute());
}
//me ubico de nuevo en el elemento
reader.MoveToContent();
}
public ProcessXMLFileHandlerTests()
{
memberUploadsDbSet = A.Fake<DbSet<MemberUpload>>();
producersDbSet = A.Fake<DbSet<ProducerSubmission>>();
xmlConverter = A.Fake<IXmlConverter>();
producerSubmissionDataAccess = A.Fake<IProducerSubmissionDataAccess>();
var schemes = new[]
{
FakeSchemeData()
};
schemesDbSet = helper.GetAsyncEnabledDbSet(schemes);
context = A.Fake<WeeeContext>();
A.CallTo(() => context.Schemes).Returns(schemesDbSet);
A.CallTo(() => context.ProducerSubmissions).Returns(producersDbSet);
A.CallTo(() => context.MemberUploads).Returns(memberUploadsDbSet);
generator = A.Fake<IGenerateFromXml>();
xmlValidator = A.Fake<IXMLValidator>();
xmlChargeBandCalculator = A.Fake<IXMLChargeBandCalculator>();
handler = new ProcessXMLFileHandler(context, permissiveAuthorization, xmlValidator, generator, xmlConverter, xmlChargeBandCalculator, producerSubmissionDataAccess);
}
private XmlTypeContext CreateTypeContext(Type valueType, XmlTypeContext context)
{
IXmlConverter readConverter = null;
IXmlConverter writeConverter = null;
foreach (var converter in converters.Concat(DefaultConverters))
{
if (readConverter == null && converter.CanRead(valueType))
{
readConverter = converter;
if (writeConverter != null)
{
break;
}
}
if (writeConverter == null && converter.CanWrite(valueType))
{
writeConverter = converter;
if (readConverter != null)
{
break;
}
}
}
var contract = contractResolver.ResolveContract(valueType);
readConverter = GetConverter(contract, readConverter);
writeConverter = GetConverter(contract, writeConverter);
context = new XmlTypeContext(contract, readConverter, writeConverter);
typeContextCache.TryAdd(valueType, context);
return(context);
}
static void Main(string[] args)
{
//Creational Patterns
Singleton();
Builder();
Factory();
AbstractFactory();
Prototype();
////Structural Patterns
_xmlConverter = new XmlConverter(new DataProvider());
Adapter();
Decorator();
Facade();
Proxy();
//Behavioral Patterns
Mediator();
Visitor();
Strategy();
//Others
NullObject();
}
public GenerateProducerDataTestsBuilder()
{
XmlConverter = A.Fake<IXmlConverter>();
DataAccess = A.Fake<IGenerateFromXmlDataAccess>();
InstantiateProducerParameters();
}
public SchemaValidatorTests()
{
xmlErrorTranslator = A.Fake <IXmlErrorTranslator>();
xmlConverter = A.Fake <IXmlConverter>();
namespaceValidator = A.Fake <INamespaceValidator>();
}
public GenerateFromXmlBuilder()
{
XmlConverter = A.Fake<IXmlConverter>();
SchemaValidator = A.Fake<ISchemaValidator>();
XmlErrorTranslator = A.Fake<IXmlErrorTranslator>();
}
public SchemaValidator(IXmlErrorTranslator xmlErrorTranslator, IXmlConverter xmlConverter, INamespaceValidator namespaceValidator)
{
this.xmlErrorTranslator = xmlErrorTranslator;
this.xmlConverter = xmlConverter;
this.namespaceValidator = namespaceValidator;
}
public GenerateFromXml(IXmlConverter xmlConverter, IGenerateFromXmlDataAccess dataAccess)
{
this.xmlConverter = xmlConverter;
this.dataAccess = dataAccess;
}
public XMLChargeBandCalculator(IXmlConverter xmlConverter, IProducerChargeCalculator producerChargeCalculator)
{
this.xmlConverter = xmlConverter;
this.producerChargeCalculator = producerChargeCalculator;
ErrorsAndWarnings = new List<MemberUploadError>();
}
public SchemaValidatorTests()
{
xmlErrorTranslator = A.Fake<IXmlErrorTranslator>();
xmlConverter = A.Fake<IXmlConverter>();
namespaceValidator = A.Fake<INamespaceValidator>();
}
public GenerateFromXmlBuilder()
{
XmlConverter = A.Fake<IXmlConverter>();
DataAccess = A.Fake<IGenerateFromXmlDataAccess>();
}
