public TypeResolution Resolve(
ITypeSymbol typeSymbol,
ResolutionContext context,
bool fillInheritance = false
)
{
var type = typeSymbol as INamedTypeSymbol;
var result = new TypeResolution();
result.ConstructedFrom = type?.ConstructedFrom?.ToString();
//Normalize type identifier
if (!string.IsNullOrWhiteSpace(result.ConstructedFrom))
{
var splitted = result.ConstructedFrom.Split('<');
var baseName = splitted[0];
if (splitted.Length > 1)
{
splitted = splitted[1].Split(',');
//Normalize constructedFrom. when analyzing compiled assemblies, generic args are omitted
result.ConstructedFrom = baseName + "<" + new StringBuilder().Append(',', splitted.Length - 1) + ">";
}
}
//Get generics
if (type != null && type.IsGenericType)
{
result.GenericArguments = type
.TypeArguments
.Select(t =>
t is INamedTypeSymbol ?
/* When type is defined */
(object)Resolve(t as INamedTypeSymbol, context)
//Just the argument name
: t.Name
)
.ToList();
}
//Base Type
if (fillInheritance && type != null && type.BaseType != null && type.BaseType.SpecialType != SpecialType.System_Object)
{
result.Inherits = Resolve(
type.BaseType,
context,
//Avoid creating unecessary extra import int the current context
false);
}
//User custom type mapping
if (Options.CustomMap != null && result.ConstructedFrom != null && Options.CustomMap.ContainsKey(result.ConstructedFrom))
{
//Found definition with this full type name
var clientType = Options.CustomMap[result.ConstructedFrom];
var externalModule = clientType.Module;
var externalName = clientType.Name;
if (string.IsNullOrWhiteSpace(externalModule))
{
result.Declaration = externalName;
}
else
{
var alias = context.GetAliasByModule(externalModule);
result.ModuleAlias = alias;
result.Declaration = $"{alias}.{externalName}";
}
result.IsKnown = true;
return(result);
}
//Generic part of a generic class
if (typeSymbol is ITypeParameterSymbol)
{
result.Declaration = typeSymbol.Name;
return(result);
}
result.IsNullable = IsNullable(typeSymbol);
var tsType = TypeFiles.ContainsKey(typeSymbol) ?
TypeFiles[typeSymbol]
//When inheriting from another generic model
: TypeFiles.ContainsKey(typeSymbol.OriginalDefinition) ?
TypeFiles[typeSymbol.OriginalDefinition] : null;
if (tsType != null)
{
//result.TsType = tsType;
result.IsEnum = tsType is TsEnum;
result.IsKnown = true;
result.Declaration = tsType.ClassName;
if (tsType is TsModelBase
&&
tsType != context.Target //auto-reference
)
{
var tsModel = tsType as TsModelBase;
var c = new Uri("C:\\", UriKind.Absolute);
var uriOther = new Uri(c, new Uri(tsModel.OutputFilePath, UriKind.Relative));
var uriMe = new Uri(c, new Uri(context.Target.OutputFilePath, UriKind.Relative));
var module = uriMe.MakeRelativeUri(uriOther).ToString();
module = module.Substring(0, module.Length - 3);
if (module[0] != '.')
{
module = "./" + module;
}
var alias = context.GetAliasByModule(module);
result.ModuleAlias = alias;
result.Declaration = $"{alias}.{result.Declaration}";
}
//When inheriting from another generic model
if (type.IsGenericType)
{
var gp_ = GetGenericPart(type, result.Declaration, context);
result.Declaration = $"{result.Declaration}{gp_.genericPart}";
}
return(result);
}
//Array
if (typeSymbol is IArrayTypeSymbol)
{
var arrTypeSymbol = typeSymbol as IArrayTypeSymbol;
//This generic type does not really exists, just the base type "System.Array", but it will help generators easily identify arrays
result.ConstructedFrom = "System.Array<>";
result.GenericArguments = new List <object>
{
Resolve(arrTypeSymbol.ElementType, context)
};
if (arrTypeSymbol.ElementType.SpecialType == SpecialType.System_Byte)
{
result.Declaration = "string";
}
else
{
var elementTypeRes = Resolve(arrTypeSymbol.ElementType, context);
result.Declaration = $"Array<{elementTypeRes.Declaration}>";
}
return(result);
}
//tuples
if (type.IsTupleType)
{
var tupleElements = type.TupleElements
.Select(te => new
{
field = (Options.KeepPropsCase ? te.Name : te.Name.ToCamelCase()),
tupleField = (Options.KeepPropsCase ? te.CorrespondingTupleField.Name : te.CorrespondingTupleField.Name.ToCamelCase()),
type = Resolve(te.Type as INamedTypeSymbol, context).Declaration
});
var tupleProps = tupleElements
.Select(te => $"/** field:{te.field} */{te.tupleField}: {te.type}");
result.Declaration = $"{{{string.Join(", ", tupleProps)}}}";
return(result);
}
//string name = type.Name;
var members = type.GetTypeMembers();
string typeName = type.Name;
//In case of nested types
var parent = type.ContainingType;
while (parent != null)
{
//Check if parent type is controller > service
var parentName = parent.Name;
//Adjust to check prerequisites
if (Service.IsService(parent))
{
//parentName = parentName.Replace("Controller", "Service");
parentName = parentName.Replace("Controller", Options.ServiceSuffix);
}
//For now, we'll just check if ends with "Controller" suffix
//if (parentName.EndsWith("Controller")) {
// parentName = parentName.Replace("Controller", "Service");
//}
typeName = $"{parentName}.{typeName}";
parent = parent.ContainingType;
}
//Change type to ts type
var tsTypeName = ToTsTypeName(type, context);
//If contains "{" or "}" then it was converted to anonymous type, so no need to do anything else.
if (tsTypeName.Contains("{"))
{
result.Declaration = tsTypeName;
return(result);
}
var gp = GetGenericPart(type, tsTypeName, context);
result.Declaration = $"{gp.modifiedTsTypeName}{gp.genericPart}";
return(result);
}
/// <summary>
/// The SortFolder
/// </summary>
/// <param name="DelFile">The DelFile<see cref="bool"/></param>
/// <param name="SortExtension">The SortExtension<see cref="bool"/></param>
/// <param name="path">The path<see cref="string"/></param>
public void SortFolder(bool DelFile, bool SortExtension, string path)
{
MainWindow.BGThread = (new Thread(() => {
var Progress = new ProgressController();
Progress.ShowProgressBar();
try {
if (!Directory.Exists(path))
{
throw new ArgumentNullException("path not exists", nameof(path));
}
var dir = new DirectoryInfo(path);
var FileList = dir.GetFiles();
Progress.SetMax(DelFile == true ? FileList.Length * 2 : FileList.Length);
path += $"/Sort ({DateTime.Now.ToString("dd.MM.yyyy")})/";
if (!SortExtension)
{
foreach (var t in FileList)
{
try {
Progress.AddLog("Sort:" + t.Name);
Directory.CreateDirectory(path + TypeFiles.GetTypePath(t));
t.CopyTo(path + TypeFiles.GetTypePath(t) + t.Name, true);
Progress.AddProgress(1);
}
catch (Exception ex) {
Progress.AddLog("Error:" + t.Name);
Progress.AddLog(ex.StackTrace.ToString());
Progress.AddProgress(1);
}
}
}
else
{
foreach (var t in FileList)
{
try {
Progress.AddLog("Sort:" + t.Name);
Directory.CreateDirectory(path + t.Extension.ToString().Replace(".", ""));
t.CopyTo(path + t.Extension.ToString().Replace(".", "") + "/" + t.Name, true);
Progress.AddProgress(1);
}
catch (Exception ex) {
Progress.AddLog("Error:" + t.Name);
Progress.AddLog(ex.StackTrace.ToString());
Progress.AddProgress(1);
}
}
}
if (DelFile)
{
foreach (FileInfo file in dir.GetFiles())
{
try {
file.Delete();
}
catch (Exception ex) {
Progress.AddLog("Error:" + file.Name);
Progress.AddLog(ex.StackTrace.ToString());
}
finally {
Progress.AddProgress(1);
}
}
}
Progress.HideProgressBar();
}
catch (Exception ex) {
Progress.AddLog(ex.StackTrace);
Progress.HideProgressBar("!Error!");
}
}));
MainWindow.BGThread.IsBackground = true;
MainWindow.BGThread.Start();
}
