public string GetClassServiceFileFromInterface(
ServiceFile interfaceServiceFile,
string serviceClassName,
string serviceNamespace,
List <string> appendUsingDirectives,
ClassInterfaceBody appendClassBody)
{
var usingSet = interfaceServiceFile.UsingDirectives.ToHashSet();
usingSet.UnionWith(appendUsingDirectives);
usingSet.Remove(serviceNamespace);
var classDeclaration = _serviceCommandParserService.GetClassFromInterface(
interfaceServiceFile.ServiceDeclaration,
serviceClassName);
var fieldDeclarations = appendClassBody?.FieldDeclarations;
classDeclaration.Body.ConstructorDeclaration = appendClassBody?.ConstructorDeclaration;
if (fieldDeclarations != null)
{
classDeclaration.Body.FieldDeclarations = fieldDeclarations;
}
return(_serviceCommandStgService.RenderServiceFile(
usingDirectives: usingSet.ToList(),
serviceNamespace: serviceNamespace,
service: classDeclaration));
}
private void ConsolidateServiceClassAndInterface(
SourceOfTruth sourceOfTruth,
string serviceClassName,
string serviceInterfaceName,
List <TypeParameter> typeParameters,
List <InjectedService> injectedServices,
string serviceClassFilePath,
string serviceInterfaceFilePath,
string serviceNamespace,
string outServiceClassFilePath,
string outServiceInterfaceFilePath)
{
var usingDirectives = new HashSet <string>();
var fieldDeclarations = new List <FieldDeclaration>();
var ctorParameters = new FormalParameterList();
var fixedParams = ctorParameters.FixedParameters;
var ctorBody = new ConstructorBody();
var statements = ctorBody.Statements;
var appendBody = new ClassInterfaceBody()
{
FieldDeclarations = fieldDeclarations,
ConstructorDeclaration = new ConstructorDeclaration()
{
FormalParameterList = ctorParameters,
Body = ctorBody
}
};
if (injectedServices != null && injectedServices.Count > 0)
{
foreach (var injectedService in injectedServices)
{
var injectedServiceIdentifier = injectedService.ServiceIdentifier
?? Regex.Replace(
Regex.Replace(
injectedService.Type,
@"^I?([A-Z])",
"$1"),
@"^[A-Z]",
m => m.ToString().ToLower());
if (!Regex.Match(serviceNamespace, "^" + Regex.Escape(injectedService.Namespace)).Success)
{
usingDirectives.Add(injectedService.Namespace);
}
fieldDeclarations.Add(
new FieldDeclaration()
{
Modifiers = new List <string>()
{
Keywords.Private,
Keywords.Readonly
},
Type = injectedService.Type,
VariableDeclarator = new VariableDeclarator()
{
Identifier = "_" + injectedServiceIdentifier
}
});
fixedParams.Add(
new FixedParameter()
{
Type = injectedService.Type,
Identifier = injectedServiceIdentifier
});
statements.Add(
new Statement()
{
SimpleAssignment = new SimpleAssignment()
{
LeftHandSide = "_" + injectedServiceIdentifier,
RightHandSide = injectedServiceIdentifier
}
});
}
}
CSharpParserWrapper serviceClassParser = null;
CSharpParserWrapper serviceInterfaceParser = null;
ServiceFile classScraperResults = null;
ServiceFile interfaceScraperResults = null;
//Check if <service> class file exists:
if (File.Exists(serviceClassFilePath))
{
_logger.LogDebug("Service class file found. Pulling data from service class.");
// Else:
// Parse <service> class file
// Extract list of existing public method signatures
serviceClassParser = new CSharpParserWrapper(GetPathFromWrittenTo(serviceClassFilePath));
classScraperResults = _serviceCommandService.ScrapeServiceClass(
serviceClassParser,
serviceClassName,
serviceNamespace,
typeParameters);
}
else
{
_logger.LogDebug($"No service class file found at {serviceClassFilePath}.");
}
//Check if <service> interface file exists:
if (File.Exists(serviceInterfaceFilePath))
{
_logger.LogDebug("Service interface file found. Pulling data from service interface.");
// Else:
// Parse <service> interface file
// Extract list of existing method signatures
serviceInterfaceParser = new CSharpParserWrapper(GetPathFromWrittenTo(serviceInterfaceFilePath));
interfaceScraperResults = _serviceCommandService.ScrapeServiceInterface(
serviceInterfaceParser,
serviceInterfaceName,
serviceNamespace,
typeParameters);
}
else
{
_logger.LogDebug($"No service interface file found at {serviceInterfaceFilePath}.");
}
if (classScraperResults is null && interfaceScraperResults is null)
{
_logger.LogDebug("Creating new service class and interface and writing them to file.");
// Create <service> class file
// Create serviceClass StringTemplate with empty class body
var classDeclaration = new ClassInterfaceDeclaration()
{
IsInterface = false,
Modifiers = new List <string>()
{
Keywords.Public
},
Identifier = serviceClassName,
TypeParameters = typeParameters.Copy(),
Base = new ClassInterfaceBase()
{
InterfaceTypeList = new List <string>()
{
serviceInterfaceName + _cSharpCommonStgService.RenderTypeParamList(typeParameters.Copy())
}
},
Body = new ClassInterfaceBody()
{
FieldDeclarations = fieldDeclarations,
ConstructorDeclaration = new ConstructorDeclaration()
{
Modifiers = new List <string>()
{
Keywords.Public
},
Identifier = serviceClassName,
FormalParameterList = ctorParameters,
Body = ctorBody
}
}
};
UpdateWrittenTo(serviceClassFilePath, outServiceClassFilePath);
_ioUtilService.WriteStringToFile(
_serviceCommandStgService.RenderServiceFile(
usingDirectives: usingDirectives.ToList(),
serviceNamespace: serviceNamespace,
service: classDeclaration),
outServiceClassFilePath);
// Create <service> interface file
// Create serviceInterface StringTemplate with empty interface body
var interfaceDeclaration = new ClassInterfaceDeclaration()
{
IsInterface = true,
Modifiers = new List <string>()
{
Keywords.Public
},
Identifier = serviceInterfaceName,
TypeParameters = typeParameters.Copy()
};
UpdateWrittenTo(serviceInterfaceFilePath, outServiceInterfaceFilePath);
_ioUtilService.WriteStringToFile(
_serviceCommandStgService.RenderServiceFile(
serviceNamespace: serviceNamespace,
service: interfaceDeclaration),
outServiceInterfaceFilePath);
}
private void ValidateServiceClass(
string serviceClassName,
List <TypeParameter> typeParameters,
List <InjectedService> injectedServices,
string serviceClassFilePath,
string serviceNamespace,
string outServiceClassFilePath)
{
var usingDirectives = new HashSet <string>();
var fieldDeclarations = new List <FieldDeclaration>();
var ctorParameters = new FormalParameterList();
var fixedParams = ctorParameters.FixedParameters;
var ctorBody = new ConstructorBody();
var statements = ctorBody.Statements;
var appendBody = new ClassInterfaceBody()
{
FieldDeclarations = fieldDeclarations,
ConstructorDeclaration = new ConstructorDeclaration()
{
FormalParameterList = ctorParameters,
Body = ctorBody
}
};
if (injectedServices != null && injectedServices.Count > 0)
{
foreach (var injectedService in injectedServices)
{
var injectedServiceIdentifier = injectedService.ServiceIdentifier
?? Regex.Replace(
Regex.Replace(
injectedService.Type,
@"^I?([A-Z])",
"$1"),
@"^[A-Z]",
m => m.ToString().ToLower());
if (!Regex.Match(serviceNamespace, "^" + Regex.Escape(injectedService.Namespace)).Success)
{
usingDirectives.Add(injectedService.Namespace);
}
fieldDeclarations.Add(
new FieldDeclaration()
{
Modifiers = new List <string>()
{
Keywords.Private,
Keywords.Readonly
},
Type = injectedService.Type,
VariableDeclarator = new VariableDeclarator()
{
Identifier = "_" + injectedServiceIdentifier
}
});
fixedParams.Add(
new FixedParameter()
{
Type = injectedService.Type,
Identifier = injectedServiceIdentifier
});
statements.Add(
new Statement()
{
SimpleAssignment = new SimpleAssignment()
{
LeftHandSide = "_" + injectedServiceIdentifier,
RightHandSide = injectedServiceIdentifier
}
});
}
}
var serviceClassFile = new ServiceFile()
{
UsingDirectives = usingDirectives.ToList(),
ServiceNamespace = serviceNamespace,
ServiceDeclaration = new ClassInterfaceDeclaration()
{
IsInterface = false,
Modifiers = new List <string>()
{
Keywords.Public
},
Identifier = serviceClassName,
TypeParameters = typeParameters.Copy(),
Body = new ClassInterfaceBody()
{
FieldDeclarations = fieldDeclarations,
ConstructorDeclaration = new ConstructorDeclaration()
{
Modifiers = new List <string>()
{
Keywords.Public
},
Identifier = serviceClassName,
FormalParameterList = ctorParameters,
Body = ctorBody
}
}
}
};
if (!File.Exists(serviceClassFilePath))
{
// Create <service> class file
// Create serviceClass StringTemplate with empty class body
_logger.LogDebug("Creating new service class and writing it to file.");
UpdateWrittenTo(serviceClassFilePath, outServiceClassFilePath);
_ioUtilService.WriteStringToFile(
_serviceCommandStgService.RenderServiceFile(
usingDirectives: usingDirectives.ToList(),
serviceNamespace: serviceNamespace,
service: serviceClassFile.ServiceDeclaration),
outServiceClassFilePath);
}
else
{
var serviceClassParser = new CSharpParserWrapper(GetPathFromWrittenTo(serviceClassFilePath));
var serviceClassRewrite = _serviceCommandService.InjectDataIntoServiceClass(
serviceClassFile,
serviceClassParser,
serviceClassName,
_userSettings.Value.TabString);
if (serviceClassRewrite != null)
{
_logger.LogDebug("Overwriting service class file.");
UpdateWrittenTo(serviceClassFilePath, outServiceClassFilePath);
_ioUtilService.WriteStringToFile(
serviceClassRewrite,
outServiceClassFilePath);
}
else
{
_logger.LogDebug("Service class file was already up to date.");
}
}
}