/// <summary>
/// DataSource로부터 새로운 Persistent object를 빌드합니다.
/// </summary>
/// <param name="dataReader">데이타 소스</param>
/// <returns>Persistent object</returns>
public override T Persist(IDataReader dataReader)
{
dataReader.ShouldNotBeNull("dataReader");
if (IsDebugEnabled)
{
log.Debug("Build Persistent object of Type [{0}] from IDataReader... Name Mapping method=[{1}]",
typeof(T).FullName, NameMapper.GetType().FullName);
}
var persistent = FactoryFunction();
var columnNames = Enumerable.Range(0, dataReader.FieldCount).Select <int, string>(dataReader.GetName).ToArray();
foreach (var columnName in columnNames)
{
var propertyName = NameMapper.MapToPropertyName(columnName);
if (propertyName.IsNotWhiteSpace())
{
var columnValue = dataReader.AsValue(columnName);
if (IsDebugEnabled)
{
log.Debug("속성명 [{0}]에 DataReader 컬럼명 [{1}]의 값 [{2}]를 설정합니다...", propertyName, columnName, columnValue);
}
DynamicAccessor.SetPropertyValue(persistent, propertyName, columnValue);
}
}
return(persistent);
}
/// <summary>
/// DataSource로부터 새로운 Persistent object를 빌드합니다.
/// </summary>
/// <param name="dataRow">데이타 소스</param>
/// <returns>Persistent object</returns>
public override TPersistent Persist(DataRow dataRow)
{
dataRow.ShouldNotBeNull("dataRow");
if (IsDebugEnabled)
{
log.Debug("Build Persistent object of Type [{0}] from DataRow... Name Mapping method=[{1}]",
typeof(TPersistent).FullName, NameMapper.GetType().FullName);
}
var persistent = FactoryFunction();
foreach (DataColumn col in dataRow.Table.Columns)
{
var propertyName = NameMapper.MapToPropertyName(col.ColumnName);
if (propertyName.IsNotWhiteSpace())
{
if (IsDebugEnabled)
{
log.Debug("속성명 [{0}]에 DataRow의 컬럼명 [{1}]의 값 [{2}]를 설정합니다...", propertyName, col.ColumnName, dataRow[col]);
}
DynamicAccessor.SetPropertyValue(persistent, propertyName, dataRow[col]);
}
}
return(persistent);
}
protected virtual void SanitizeMessageTemplateData(MessageTemplateData data)
{
// Sanitize possible identifier duplicates resulting from name identifier mapping
// Fall back to ROS identifier name in this case.
var duplicateIdentifiers = data.Fields.Select(f => f.Identifier)
.Union(data.Constants.Select(c => c.Identifier))
.GroupBy(identifier => identifier)
.Select(x => new { x.Key, Count = x.Count() })
.Where(x => x.Count > 1)
.Select(x => x.Key)
.ToList();
foreach (var field in data.Fields.Where(x => duplicateIdentifiers.Contains(x.Identifier)))
{
field.Identifier = field.RosIdentifier;
}
foreach (var constant in data.Constants.Where(x => duplicateIdentifiers.Contains(x.Identifier)))
{
constant.Identifier = constant.RosIdentifier;
}
// Sanitize possible CS0542: Members cannot be the same as their enclosing type.
// Rename those field to PreferredIdentifierIfEqualsTypeName. If the name is already used fall back to
// the original ROS identifier.
var cs0542Field = data.Fields
.FirstOrDefault(x => x.Identifier == data.TypeName);
if (cs0542Field != null)
{
var alternativeIdentifier = PreferredIdentifierIfEqualsTypeName;
alternativeIdentifier = NameMapper.GetFieldName(alternativeIdentifier);
if (data.Fields.Any(x => x.Identifier == alternativeIdentifier))
{
alternativeIdentifier = cs0542Field.RosIdentifier;
}
cs0542Field.Identifier = alternativeIdentifier;
}
var cs0542Const = data.Constants
.FirstOrDefault(x => x.Identifier == data.TypeName);
if (cs0542Const != null)
{
var alternativeIdentifier = PreferredIdentifierIfEqualsTypeName;
alternativeIdentifier = NameMapper.GetConstantName(alternativeIdentifier);
if (data.Constants.Any(x => x.Identifier == alternativeIdentifier))
{
alternativeIdentifier = cs0542Const.RosIdentifier;
}
cs0542Const.Identifier = alternativeIdentifier;
}
}
private static string ToExternal(string term)
{
if (NameMapper != null)
{
term = NameMapper.ToExternal(term);
}
return(term);
}
public static string ToInternal(string term)
{
if (NameMapper != null)
{
term = NameMapper.ToInternal(term);
}
return(term);
}
public List <NameDTO> GetNames()
{
var returnList = new List <NameDTO>();
foreach (var item in pssc.GetNames())
{
returnList.Add(NameMapper.MapToDTO(item));
}
return(returnList);
}
public List <NameDAO> GetNames()
{
var returnList = new List <NameDAO>();
foreach (var item in data.GetNames())
{
returnList.Add(NameMapper.MapToNameDAO(item));
}
return(returnList);
}
protected virtual void CreateService(RosTypeInfo rosType, ServiceDescriptor service)
{
if (NameMapper.IsBuiltInType(rosType))
{
return;
}
WriteServiceInternal(rosType);
WriteMessageInternal(rosType, DetailedRosMessageType.ServiceRequest, service.Request);
WriteMessageInternal(rosType, DetailedRosMessageType.ServiceResponse, service.Response);
}
private void AddNugetDependencies()
{
EnsurePackageData();
IList <string> messageNugetPackages;
// If package is a meta package use dependencies
// form package info (parsed package.xml)
// else use real dependencies retrieved form
// message files.
if (Package.PackageInfo.IsMetaPackage)
{
messageNugetPackages = Package.Parser
.PackageDependencies
.Select(x => NameMapper.ResolveNugetPackageName(x))
.Distinct()
.ToList();
}
else
{
messageNugetPackages = Package.Parser
.ExternalTypeDependencies
.Select(x => NameMapper.ResolveNugetPackageName(x))
.Distinct()
.ToList();
}
if (!messageNugetPackages.Any())
{
return;
}
Logger.LogInformation($"Restoring package dependencies");
foreach (var dependency in messageNugetPackages)
{
Logger.LogInformation($" {dependency}");
try
{
DotNetProcess.AddPackage(_projectFilePath, dependency);
}
catch (ProcessFailedException e)
{
Environment.ExitCode |= (int)ExitCodes.CouldNotAddDependency;
throw new DependencyNotFoundException(dependency,
$"Could not add dependency {dependency}.", e);
}
}
Logger.LogInformation(string.Empty);
}
protected virtual MessageTemplateData GetMessageTemplateData(RosTypeInfo rosType, DetailedRosMessageType messageType,
MessageDescriptor message)
{
var fields = message.Fields
.Select(x => new FieldTemplateData
{
Index = message.Items
.Select((item, index) => new { Item = item, Index = index })
.First(f => f.Item == x)
.Index + 1, // Index of this field in serialized message (starting at 1)
RosType = x.TypeInfo,
RosIdentifier = x.Identifier,
Type = new FieldTypeTemplateData(NameMapper.ResolveFullQualifiedInterfaceName(x.TypeInfo),
NameMapper.ResolveFullQualifiedTypeName(x.TypeInfo),
x.TypeInfo)
,
Identifier = NameMapper.GetFieldName(x.Identifier)
})
.ToList();
var constants = message.Constants
.Select(c => new ConstantTemplateData
{
Index = message.Items
.Select((item, index) => new { item, index })
.First(x => x.item == c)
.index + 1,
RosType = c.TypeInfo,
RosIdentifier = c.Identifier,
TypeName = NameMapper.ResolveFullQualifiedTypeName(c.TypeInfo),
Identifier = NameMapper.GetConstantName(c.Identifier),
Value = c.Value
})
.ToList();
var data = new MessageTemplateData
{
Package = PackageTemplateData,
RosTypeName = NameMapper.GetRosTypeName(rosType.TypeName, messageType),
RosAbstractTypeName = rosType.TypeName,
TypeName = NameMapper.GetTypeName(rosType.TypeName, messageType),
AbstractTypeName = NameMapper.GetTypeName(rosType.TypeName, DetailedRosMessageType.None),
Fields = fields,
Constants = constants,
MessageType = new MessageTypeTemplateData(messageType)
};
return(data);
}
protected virtual PackageTemplateData GetPackageTemplateData()
{
var data = new PackageTemplateData
{
RosName = Package.PackageInfo.Name,
Version = Package.PackageInfo.Version,
Name = Package.PackageInfo.Name.ToPascalCase(),
Namespace = NameMapper.GetNamespace(Package.PackageInfo.Name),
Description = Package.PackageInfo.Description,
ProjectUrl = Package.PackageInfo.ProjectUrl,
RepositoryUrl = Package.PackageInfo.RepositoryUrl,
Authors = Package.PackageInfo.Authors,
};
return(data);
}
/// <summary>
/// 실행 결과인 <paramref name="reader"/>를 반환합니다.
/// </summary>
/// <param name="reader"></param>
protected virtual IEnumerable <Dictionary <string, string> > BuildResponse(IDataReader reader)
{
var records = new List <Dictionary <string, string> >();
while (reader.Read())
{
var record = new Dictionary <string, string>();
foreach (var columnName in reader.GetFieldNames())
{
var propertyName = NameMapper.MapToPropertyName(columnName);
record[propertyName] = reader.AsString(columnName);
}
records.Add(record);
}
return(records);
}
public void InsertPizzaOrder(PizzaOrderDAO po)
{
List <Pizza> Pizza = new List <Pizza>();
List <List <Topping> > toppings = new List <List <Topping> >();
List <List <Cheese> > cheeses = new List <List <Cheese> >();
foreach (var item in po.Order.Pizzas)
{
Pizza.Add(PizzaMapper.PizzaDAO_Pizza(item));
toppings.Add(PizzaMapper.PizzaDAO_Topping(item));
cheeses.Add(PizzaMapper.PizzaDAO_Cheeses(item));
}
data.InsertPizzaOrder(CustomerMapper.CustomerDAO_Customer(po.Customer), Pizza, toppings, cheeses,
EmailMapper.EmailDAO_Email(po.Customer.Email),
NameMapper.NameDAO_Name(po.Customer.Name),
NumberMapper.NumberDAO_Number(po.Customer.Number),
AddressMapper.AddressDAO_Address(po.Customer.Address));
}
private void WriteMessageInternal(RosTypeInfo rosType, DetailedRosMessageType messageType, MessageDescriptor message)
{
if (messageType == DetailedRosMessageType.None ||
messageType == DetailedRosMessageType.Action ||
messageType == DetailedRosMessageType.Service)
{
throw new ArgumentException($"message type is not detailed enough", nameof(messageType));
}
if (NameMapper.IsBuiltInType(rosType))
{
return;
}
var data = GetMessageTemplateData(rosType, messageType, message);
SanitizeMessageTemplateData(data);
var filePath = _directories.TempDirectory.GetFilePath($"{data.TypeName}.cs");
var content = _templateEngine.Format(MessageTemplateFile, data);
WriteFile(filePath, content);
}
protected virtual ServiceTemplateData GetServiceTemplateData(RosTypeInfo serviceType)
{
var data = new ServiceTemplateData
{
Package = PackageTemplateData,
ServiceType = new ConcreteTypeTemplateData
{
RosTypeName = NameMapper.GetRosTypeName(serviceType.TypeName, DetailedRosMessageType.Service),
TypeName = NameMapper.GetTypeName(serviceType.TypeName, DetailedRosMessageType.Service)
},
RequestType = new ConcreteTypeTemplateData
{
RosTypeName = NameMapper.GetRosTypeName(serviceType.TypeName, DetailedRosMessageType.ServiceRequest),
TypeName = NameMapper.GetTypeName(serviceType.TypeName, DetailedRosMessageType.ServiceRequest)
},
ResponseType = new ConcreteTypeTemplateData
{
RosTypeName = NameMapper.GetRosTypeName(serviceType.TypeName, DetailedRosMessageType.ServiceResponse),
TypeName = NameMapper.GetTypeName(serviceType.TypeName, DetailedRosMessageType.ServiceResponse)
}
};
return(data);
}
public static int Main(string[] args)
{
if (args.Length < 2)
{
return(XConsole.WriteLine("NameMapper.CLI - map names from assembly with deobfuscated names to assembly with obfuscated names\n" +
"by exys, 2019\n" +
"\n" +
"Usage:\n" +
"NameMapper.CLI [clean module] [obfuscated module]"));
}
if (!File.Exists(_cleanModulePath = Path.GetFullPath(args[0])))
{
return(XConsole.PrintError("Specified clean module path does not exist"));
}
if (!File.Exists(_obfModulePath = Path.GetFullPath(args[1])))
{
return(XConsole.PrintError("Specified obfuscated module path does not exist"));
}
try
{
_cleanModule = ModuleDefMD.Load(_cleanModulePath, ModuleDef.CreateModuleContext());
_obfModule = ModuleDefMD.Load(_obfModulePath, ModuleDef.CreateModuleContext());
}
catch (Exception e) { return(XConsole.PrintError("An error occurred while trying to load and process modules! Details:\n" + e)); }
XConsole.PrintInfo($"Loaded modules: {_cleanModule.Assembly.FullName} (clean); {_obfModule.Assembly.FullName} (obfuscated).");
var fancyOut = new ConcurrentQueue <string>();
// ReSharper disable once FunctionNeverReturns
ThreadPool.QueueUserWorkItem(state =>
{
while (true)
{
if (!fancyOut.IsEmpty && fancyOut.TryDequeue(out string msg))
{
XConsole.Write(msg);
}
Thread.Sleep(1);
}
});
NameMapper nameMapper = new NameMapper(_cleanModule, _obfModule, fancyOut);
nameMapper.BeginProcessing();
string filename = Path.GetFileNameWithoutExtension(_obfModulePath) + "-nmapped" + Path.GetExtension(_obfModulePath);
XConsole.PrintInfo("Finally writing module back (with \"-nmapped\" tag)!");
_obfModule.Write(
Path.Combine(
Path.GetDirectoryName(_obfModulePath) ?? throw new NameMapperCliException("Path to write module to is null unexpectedly"), filename),
new ModuleWriterOptions(_obfModule)
{
MetadataOptions = { Flags = DEFAULT_METADATA_FLAGS }
});
Console.ReadKey(true);
return(0);
}
public NameDTO GetName(int id)
{
return(NameMapper.MapToDTO(pssc.GetName(id)));
}
public bool ChangeName(NameDTO item)
{
return(pssc.ChangeName(NameMapper.MapToDAO(item)));
}
public bool DeleteName(NameDTO item)
{
return(pssc.DeleteName(NameMapper.MapToDAO(item)));
}
public void MyTestMethod(string parameterName, string expectedStoredProcedureParameter)
{
var storedProcedureParameter = NameMapper.MapName(parameterName);
Assert.AreEqual(expectedStoredProcedureParameter, storedProcedureParameter);
}
public bool InsertName(NameDTO item)
{
return(pssc.InsertName(NameMapper.MapToDAO(item)));
}
public bool DeleteName(NameDAO name)
{
return(data.DeleteName(NameMapper.MapToName(name)));
}
public NameDAO GetName(int id)
{
return(NameMapper.MapToNameDAO(data.GetName(id)));
}
public bool InsertName(NameDAO name)
{
return(data.InsertName(NameMapper.MapToName(name)));
}
public bool ChangeName(NameDAO name)
{
return(data.ChangeName(NameMapper.MapToName(name)));
}
