public XmlParameterMapping(MethodInfo methodInfo, XElement xParameter)
{
DbParameterName = xParameter.Attribute("db-name").Value;
var parameterName = xParameter.Attribute("name").Value;
Parameter = methodInfo.GetParameters().FirstOrDefault(p => p.Name == parameterName);
if (Parameter == null)
{
throw new DocumentParseException("Canot find parameter '{0}'", parameterName);
}
XAttribute xConverter;
if (xParameter.TryGetAttribute("converter", out xConverter))
{
Converter = ConverterFactory.Create(xConverter.Value);
}
XAttribute xDbType;
if (xParameter.TryGetAttribute("db-type", out xDbType))
{
DbType = xDbType.GetAsEnum <DbType>();
}
XAttribute xLength;
if (xParameter.TryGetAttribute("length", out xLength))
{
Length = xLength.GetAsInt();
}
}
//---------------------------------------------------------------------
private static void Initialize()
{
string dsn = null;
Database database = null;
try
{
// create the converters
m_raceConverter = ConverterFactory.Create(ConverterFactory.SCHEMA_RACE);
m_punyConverter = ConverterFactory.Create(ConverterFactory.SCHEMA_PUNYCODE);
// Load the tld cache
dsn = ConfigurationSettings.AppSettings["dsn"];
database = new Database(dsn);
// load the tld cache.
m_tldCache = database.GetTldCache();
}
catch (SqlException e)
{
// sql exception, load cache from local file
LoadLocalCache();
EventLogger.Log(EVENT_SOURCE, EventLogger.LogType.Error, "Load tld Cache from database failed\r\n" + e.ToString());
}
}
private TResult UseConverter <TResult>(Func <IProductConverter, TResult> call)
{
var converter = ConverterFactory.Create();
var converted = call(converter);
ConverterFactory.Destroy(converter);
return(converted);
}
public void Convert_With_ShouldNotBeNull()
{
var locator = new Mock<IServiceLocator>();
locator.Setup(x=>x.Resolve<IConverter<CustomerRequest, Customer>>()).Returns(new CustomerRequestCustomerConverter());
var sut = new ConverterFactory(locator.Object);
var converter = sut.Create<CustomerRequest, Customer>();
converter.ShouldNotBeNull();
}
private void Init(DbConnectionSchema schema, IDbConnection connection = null)
{
this._connectionSchema = schema;
this._factory = ConverterFactory.GetFactory(schema.ProviderName);
this._converter = ConverterFactory.Create(schema.ProviderName);
if (connection == null)
{
this._connection = this._factory.CreateConnection();
this._connection.ConnectionString = schema.ConnectionString;
this._connectionCreatedBySelf = true;
}
else
{
this._connection = connection;
}
}
public XmlViewPropertyMapping(Type classType, XElement xTableProperty)
{
Name = xTableProperty.Attribute("column").Value;
var name = xTableProperty.Attribute("name").Value;
Member = classType.GetMember(name, MemberTypes.Field | MemberTypes.Property, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault();
if (Member == null)
{
throw new DocumentParseException("Canot find member '{0}'", name);
}
XAttribute xConverter;
if (xTableProperty.TryGetAttribute("converter", out xConverter))
{
Converter = ConverterFactory.Create(xConverter.Value);
}
}
public void Execute()
{
this.Status = "Running...";
var converter = ConverterFactory.Create <ClickPostCsvModel>();
try
{
var src = CsvReader.Read <BoothCsvModel>(this.SrcPath);
var dest = converter.Convert(src);
CsvWriter.Write(this.DestPath, dest);
}
catch
{
this.Status = $"Error!";
return;
}
this.Status = "Complete!";
}
public XmlVersionProperty(IMapping objectMapping, XElement xVersion)
{
var name = xVersion.Attribute("name").Value;
Member = objectMapping.Type.GetMember(name, MemberTypes.Field | MemberTypes.Property, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault();
if (Member == null)
{
throw new DocumentParseException("Canot find member '{0}'", Name);
}
Name = xVersion.Attribute("column").Value;
XAttribute xConverter;
if (xVersion.TryGetAttribute("converter", out xConverter))
{
Converter = ConverterFactory.Create(xConverter.Value);
}
}
public XmlFunctionReturnMapping(XElement xFunctionReturn)
{
XAttribute xConverter;
if (xFunctionReturn.TryGetAttribute("converter", out xConverter))
{
Converter = ConverterFactory.Create(xConverter.Value);
}
XAttribute xDbType;
if (xFunctionReturn.TryGetAttribute("db-type", out xDbType))
{
DbType = xDbType.GetAsEnum <DbType>();
}
XAttribute xLength;
if (xFunctionReturn.TryGetAttribute("length", out xLength))
{
Length = xLength.GetAsInt();
}
}
protected override int ExecuteArguments(IEnumerable <IArgument> args)
{
var srcPathArg = args.Get <Src1Argument>();
var srcTypeArg = args.Get <SrcType1Argument>();
var destPathArg = args.Get <DestArgument>();
var destTypeArg = args.Get <DestTypeArgument>();
var srcType = CsvResolver.ResolveType(srcTypeArg);
var destType = CsvResolver.ResolveType(destTypeArg);
var srcConvertKind = CsvKindResolver.Resolve(srcType);
var destConvertKind = CsvKindResolver.Resolve(destType);
try
{
var converter = ConverterFactory.Create(srcConvertKind, destConvertKind);
var records = CsvReader.Read(srcType, srcPathArg.Argument).Cast <ICsvModel>();
var dest = converter.Convert(records);
CsvWriter.Write(destType, destPathArg.Argument, dest);
this._messenger.Send("CSV 変換が終了しました");
return(0);
}
catch (Exception ex)
{
this._messenger.Send("CSV 変換でエラーが発生しました");
this._messenger.Send(ex.Message);
this._messenger.Send(ex.StackTrace);
return(1);
}
}
public XmlTablePropertyMapping(Type classType, XNamespace xNamespace, XElement xTableProperty)
{
Name = xTableProperty.Attribute("column").Value;
var name = xTableProperty.Attribute("name").Value;
Member = classType.GetMember(name, MemberTypes.Field | MemberTypes.Property, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault();
if (Member == null)
{
throw new DocumentParseException("Canot find member '{0}'", name);
}
XElement xGenerator;
if (xTableProperty.TryGetElement(xNamespace + "generator", out xGenerator))
{
var xGeneratorElement = xGenerator.SubElement();
Generator = GeneratorFactory.GetGenerator(xNamespace, xGeneratorElement);
}
XAttribute xInsert;
Insert = !xTableProperty.TryGetAttribute("insert", out xInsert) || xInsert.GetAsBoolean();
XAttribute xUpdate;
Update = !xTableProperty.TryGetAttribute("update", out xUpdate) || xUpdate.GetAsBoolean();
XAttribute xConverter;
if (xTableProperty.TryGetAttribute("converter", out xConverter))
{
Converter = ConverterFactory.Create(xConverter.Value);
}
}
public void ResolveShorthandLowerTrueFalse()
{
Assert.AreEqual(ConverterFactory.Create("tf").GetType(), typeof(LowerTrueFalseConverter));
}
public void ResolveShorthandLowerYesNo()
{
Assert.AreEqual(ConverterFactory.Create("yn").GetType(), typeof(LowerYesNoConverter));
}
public CsvBuilder(CsvBuildingContext context)
{
this._converter = ConverterFactory.Create(context.ConvertFrom, context.ConvertTo);
this._context = context;
}
