public static string GenerateContractEventHandlerMethod(CsField sourceField, CsEvent targetEvent, NamespaceManager manager = null)
{
if (sourceField == null)
{
return(null);
}
if (!sourceField.IsLoaded)
{
return(null);
}
if (targetEvent == null)
{
return(null);
}
if (!targetEvent.IsLoaded)
{
return(null);
}
SourceFormatter formatter = new SourceFormatter();
formatter.AppendCodeLine(0, "/// <summary>");
formatter.AppendCodeLine(0, $"/// Handles the raised event {targetEvent.Name}");
formatter.AppendCodeLine(0, "/// </summary>");
formatter.AppendCodeLine(0, $"protected void {GenerateContractEventHandlerMethodName(sourceField,targetEvent)}{targetEvent.EventHandlerDelegate.Parameters.CSharpFormatParametersSignature(manager,false)}");
formatter.AppendCodeLine(0, "{");
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(1, "//TODO: Add Event handler logic");
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(0, "}");
formatter.AppendCodeLine(0);
return(formatter.ReturnSource());
}
private static string InjectSourceCodeAtLevel(int level, string sourceCode)
{
SourceFormatter formatter = new SourceFormatter();
formatter.AppendCodeBlock(level, sourceCode);
return(formatter.ReturnSource());
}
/// <summary>
/// Updates the directives in the page file to use razor syntax.
/// </summary>
/// <param name="fileName">The file being processed.</param>
/// <param name="sourceData">The source data to be updated.</param>
/// <returns>The updated content.</returns>
private async Task <String> SetRazorPageDirectives(string fileName, Dictionary <string, string> sourceData)
{
//String result = String.Empty;
SourceFormatter result = new SourceFormatter();
try
{
var pageData = sourceData["HeaderData"];
Regex regex = new Regex(@"(?<=\bMasterPageFile="")[^""]*");
Match match = regex.Match(pageData);
string layout = match.Value;
layout = layout.Replace(".", ""); //remove the old-style Site.Master layout to read SiteMaster
result.AppendCode($"@page \"/{fileName}\" ");
if (layout.Length > 0)
{
//Making sure the ~ gets removed from directives
result.AppendCodeLine(0, $"@layout { layout.Replace("~/", "")}");
}
//result += $"@inherits {fileName}Base\r\n\r\n {sourceData["alteredSource"]}";
result.AppendCodeLine(0);
result.AppendCodeLine(0);
result.AppendCodeLine(0, $"{sourceData["alteredSource"]}");
}
catch (Exception unhandledError)
{
await _statusTracking.UpdateCurrentStatusAsync(MigrationStepEnum.AspxPages, MessageTypeEnum.Error,
$"The following unhandled error occured while setting the razor page directives in the file {fileName}. '{unhandledError.Message}'");
}
return(result.ReturnSource());
}
public static string GeneratePartialClass(CsClass source, NamespaceManager manager = null)
{
if (source == null)
{
return(null);
}
if (!source.IsLoaded)
{
return(null);
}
SourceFormatter formatter = new SourceFormatter();
StringBuilder classBuilder = new StringBuilder($"{source.Security.CSharpFormatKeyword()} partial {Keywords.Class} {source.Name}");
if (source.IsGeneric)
{
classBuilder.Append(source.GenericParameters.CSharpFormatGenericParametersSignature(manager));
}
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(0, $"namespace {source.Namespace}");
formatter.AppendCodeLine(0, "{");
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(1, classBuilder.ToString());
formatter.AppendCodeLine(1, "{");
formatter.AppendCodeLine(1);
formatter.AppendCodeLine(1, "}");
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(0, "}");
return(formatter.ReturnSource());
}
public static string GenerateRaiseContractEvent(CsEvent targetEvent, NamespaceManager manager = null)
{
if (targetEvent == null)
{
return(null);
}
if (!targetEvent.IsLoaded)
{
return(null);
}
SourceFormatter formatter = new SourceFormatter();
string eventParameters = targetEvent.RaiseMethod.Parameters.CSharpFormatParametersSignature(manager);
int parameterCount = 0;
StringBuilder parameterBuilder = new StringBuilder();
foreach (var raiseMethodParameter in targetEvent.RaiseMethod.Parameters)
{
parameterCount++;
if (parameterCount > 1)
{
parameterBuilder.Append($", {raiseMethodParameter.Name}");
continue;
}
parameterBuilder.Append(raiseMethodParameter.Name);
}
formatter.AppendCodeLine(0, "/// <summary>");
formatter.AppendCodeLine(0, $"/// Raises the event {targetEvent.Name}");
formatter.AppendCodeLine(0, "/// </summary>");
formatter.AppendCodeLine(0, $"protected void On{targetEvent.Name}{targetEvent.RaiseMethod.Parameters.CSharpFormatParametersSignature(manager,false)}");
formatter.AppendCodeLine(0, "{");
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(1, $"var raiseHandler = _{targetEvent.Name.ConvertToCamelCase()};");
formatter.AppendCodeLine(1, $"raiseHandler?.Invoke({parameterBuilder});");
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(0, "}");
formatter.AppendCodeLine(0);
return(formatter.ReturnSource());
}
/// <summary>
/// Generates a method that releases to a target interface contract for the target field.
/// </summary>
/// <param name="sourceField">The field for which events to subscribe to.</param>
/// <param name="contract">The contract to subscribe to.</param>
/// <returns>Full source code for the subscribe method.</returns>
public static string GenerateContractReleaseMethod(CsField sourceField, CsInterface contract)
{
if (sourceField == null)
{
return(null);
}
if (!sourceField.IsLoaded)
{
return(null);
}
if (contract == null)
{
return(null);
}
if (!contract.IsLoaded)
{
return(null);
}
SourceFormatter formatter = new SourceFormatter();
formatter.AppendCodeLine(0, "/// <summary>");
formatter.AppendCodeLine(0, $"/// Releases the events from the interface contract of {contract.Namespace}.{contract.Name} for the field {sourceField.Name}");
formatter.AppendCodeLine(0, "/// </summary>");
formatter.AppendCodeLine(0, $"private void {GenerateContractReleaseMethodName(sourceField)}()");
formatter.AppendCodeLine(0, "{");
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(1, $"if({sourceField.Name} == null) return;");
formatter.AppendCodeLine(0);
foreach (var contractEvent in contract.Events)
{
if (!contractEvent.IsLoaded)
{
continue;
}
formatter.AppendCodeLine(1, $"{sourceField.Name}.{contractEvent.Name} -= {sourceField.Name.ConvertToProperCase(new []{'_'})}_{contractEvent.Name}_EventHandler;");
}
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(0, "}");
formatter.AppendCodeLine(0);
return(formatter.ReturnSource());
}
/// <summary>
/// Extension method that will add a using statement to target source code. If the using statement already exists it will simply return the existing source.
/// </summary>
/// <param name="source">The source code to update.</param>
/// <param name="nameSpace">The namespace to be added to the using statement.</param>
/// <param name="alias">Optional parameter to set if you want an alias assigned to the namespace.</param>
/// <returns>The updated source code or the original source code if no changes were necessary.</returns>
public static async Task <CsSource> AddUsingStatementAsync(this CsSource source, string nameSpace, string alias = null)
{
// ReSharper disable once ExpressionIsAlwaysNull
if (source == null)
{
return(source);
}
if (string.IsNullOrEmpty(nameSpace))
{
return(source);
}
if (source.HasUsingStatement(nameSpace, alias))
{
return(source);
}
SourceFormatter usingFormatter = new SourceFormatter();
usingFormatter.AppendCodeLine(0, alias == null ? $"using {nameSpace};" : $"using {alias} = {nameSpace};");
string usingStatement = usingFormatter.ReturnSource();
CsSource result = null;
if (source.NamespaceReferences.Any())
{
var lastUsingStatement = source.NamespaceReferences.Last();
result = await lastUsingStatement.AddAfterAsync(usingStatement);
}
else
{
result = await source.AddToBeginningAsync(usingStatement);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="targetClass"></param>
/// <param name="sourceCode"></param>
/// <param name="members"></param>
/// <param name="logging"></param>
/// <param name="cdf"></param>
/// <param name="cdfAspnet"></param>
/// <param name="isContract"></param>
/// <returns></returns>
private async Task <CsSource> UpdateFileAsync(CsClass targetClass, CsSource sourceCode, IEnumerable <CsMember> members, bool logging, bool cdf, bool cdfAspnet, bool isContract)
{
if (targetClass == null)
{
throw new CodeFactoryException("Cannot access class data cannot add members");
}
if (sourceCode == null)
{
throw new CodeFactoryException("Cannot access the classes source code cannot add members.");
}
if (members == null)
{
return(sourceCode);
}
if (!members.Any())
{
return(sourceCode);
}
CsSource updatedSourceCode = await sourceCode.AddMissingNamespaces(members, targetClass.Namespace);
CsClass updatedClass = targetClass;
if (logging)
{
updatedSourceCode = await updatedSourceCode.AddUsingStatementAsync(NetConstants.MicrosoftLoggerNamespace);
updatedClass = sourceCode.GetModel(updatedClass.LookupPath) as CsClass;
if (updatedClass == null)
{
throw new CodeFactoryException("Cannot get class data to add members.");
}
if (!updatedClass.Fields.Any(f => f.Name == NetConstants.DefaultClassLoggerName))
{
var formatter = new SourceFormatter();
formatter.AppendCodeLine(0, "///<summary>");
formatter.AppendCodeLine(0, "///Logger used to manage logging for this class.");
formatter.AppendCodeLine(0, "///</summary>");
formatter.AppendCodeLine(0, $"private ILogger {NetConstants.DefaultClassLoggerName};");
updatedSourceCode =
await updatedClass.AddToBeginningAsync(
CsSourceFormatter.IndentCodeBlock(2, formatter.ReturnSource()));
}
}
if (cdf)
{
updatedSourceCode = await updatedSourceCode.AddUsingStatementAsync(CommonDeliveryFrameworkConstants
.CommonDeliveryFrameworkNamespace);
}
if (cdfAspnet)
{
updatedSourceCode = await updatedSourceCode.AddUsingStatementAsync(CommonDeliveryFrameworkConstants
.CommonDeliveryFrameworkNetAspNetNamespace);
}
updatedClass = sourceCode.GetModel(updatedClass.LookupPath) as CsClass;
if (updatedClass == null)
{
throw new CodeFactoryException("Cannot get class data to add members.");
}
updatedSourceCode = await UpdateMembersAsync(updatedClass, members, logging, cdf, cdfAspnet,
updatedSourceCode.SourceDocument, isContract, sourceCode.LoadNamespaceManager(updatedClass.Namespace));
return(updatedSourceCode);
}
/// <summary>
/// Generates the source code for a standard raise event method.
/// </summary>
/// <param name="eventData">The target event model to generate the raise method for.</param>
/// <param name="manager">The namespace manager to manage type naming.</param>
/// <param name="eventName">the name of implemented event to raise.</param>
/// <param name="security">The target security level to set the event to.</param>
/// <param name="eventHandler">Optional field, that provides the name of the direct event handler field to raise.</param>
/// <param name="methodName">Optional parameter of the custom name of the method. If not set will be On[eventName]</param>
/// <returns></returns>
public static string GenerateStandardRaiseEventMethod(CsEvent eventData, NamespaceManager manager,
string eventName, CsSecurity security, string eventHandler = null, string methodName = null)
{
//Bounds checking to make sure all data that is needed is provided. If any required data is missing will return null.
if (eventData == null)
{
return(null);
}
if (!eventData.IsLoaded)
{
return(null);
}
if (manager == null)
{
return(null);
}
if (string.IsNullOrEmpty(eventName))
{
return(null);
}
if (security == CsSecurity.Unknown)
{
return(null);
}
var raiseMethod = eventData.EventHandlerDelegate.InvokeMethod;
if (raiseMethod == null)
{
return(null);
}
if (!raiseMethod.IsLoaded)
{
return(null);
}
var parameters = raiseMethod.Parameters.CSharpFormatParametersSignature(manager, false);
string raiseHandler = string.IsNullOrEmpty(eventHandler) ? eventName : eventHandler;
StringBuilder parametersBuilder = new StringBuilder();
int parameterCount = 0;
foreach (var raiseMethodParameter in raiseMethod.Parameters)
{
parameterCount++;
if (parameterCount > 1)
{
parametersBuilder.Append(", ");
}
parametersBuilder.Append(raiseMethodParameter.Name);
}
//C# helper used to format output syntax.
var formatter = new SourceFormatter();
string raiseMethodName = string.IsNullOrEmpty(methodName) ? $"On{eventName}" : methodName;
formatter.AppendCodeLine(0, "/// <summary>");
formatter.AppendCodeLine(0, $"/// Raises the event {eventName} when there are subscribers to the event.");
formatter.AppendCodeLine(0, "/// </summary>");
formatter.AppendCodeLine(0, $"{security.CSharpFormatKeyword()} {Keywords.Void} {raiseMethodName}{parameters}");
formatter.AppendCodeLine(0, "{");
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(1, $"var raiseEvent = {raiseHandler};");
formatter.AppendCodeLine(1, $"raiseEvent?.Invoke({parametersBuilder});");
formatter.AppendCodeLine(0);
formatter.AppendCodeLine(0, "}");
formatter.AppendCodeLine(0);
return(formatter.ReturnSource());
}