private static string GetEnumName(string outputPath, ILogger logger = null)
{
// Determine file-name.
string fileName = Path.GetFileNameWithoutExtension(outputPath);
if (string.IsNullOrEmpty(fileName))
{
logger?.LogCritical($"Unable to get file-name from path: '{outputPath}'");
return(null);
}
// Strip .g from the filename.
if (fileName.EndsWith(".g", StringComparison.OrdinalIgnoreCase))
{
fileName = fileName.Substring(0, fileName.Length - 2);
}
// Convert file-name into valid identifier.
if (IdentifierCreator.TryCreateIdentifier(fileName, out var nameId))
{
logger?.LogDebug($"Generated enum-name: '{nameId}' from file-name: '{fileName}'");
return(nameId);
}
logger?.LogCritical($"Unable to create valid identifier from file-name: '{fileName}'");
return(null);
}
public Message(string messageHeader, string message)
{
Id = IdentifierCreator.UniqueDigits();
MessageHeader = messageHeader;
Timestamp = TimeManagement.UnixTimestampNow;
Text = message;
ProcessingCounter = 0;
}
public Channel CreateChannel(List <User> members, string channelName = null)
{
var channelIdentifier = IdentifierCreator.UniqueDigits();
var channel = new Channel(channelIdentifier, members, Channel.KeyMetadata.InitiatorKeyNotDisplayed, channelName);
DependencyManager.ChannelsPage.ViewModel.Channels.Add(channel);
DependencyManager.Database.InsertOrReplaceWithChildren(channel);
var memberList = members.Aggregate("", (current, member) => current + member.Username + ";");
memberList = memberList.Remove(memberList.Length - 1); // Remove last semicolon
foreach (var member in members)
{
var preparedMessage = new Message(DependencyManager.Me.Id + ";" + channelIdentifier + ";" + memberList,
AppResources.CryptedOnBoardingMessage)
{
ChannelId = member.Id // Manipulated to call pull broadcast by receiver
};
new Task(() => { RestService.SendMessage(preparedMessage); }).Start(); // TODO: Handle in future if request is not succeeded
}
return(channel);
}
/// <summary>
/// Run the generator tool.
/// </summary>
/// <param name="inputFile">Path to the json file to generate the enum for</param>
/// <param name="outputFile">Path where to save the generated enum</param>
/// <param name="outputType">Type of output file to generate</param>
/// <param name="collectionJPath">JPath to the collection in the input file</param>
/// <param name="entryNameJPath">
/// JPath to the name field in an entry in the input file</param>
/// <param name="entryValueJPath">
/// Optional JPath to the value field in an entry in the input file
/// </param>
/// <param name="entryCommentJPath">
/// Optional JPath to the comment field in an entry in the input file
/// </param>
/// <param name="enumComment">
/// Optional comment to add to the generated enum.
/// </param>
/// <param name="enumNamespace">
/// Optional namespace to add the generated enum to.
/// </param>
/// <param name="headerMode">Mode to use when adding a header</param>
/// <param name="indentMode">Mode to use when indenting text</param>
/// <param name="indentSize">When indenting with spaces this controls how many</param>
/// <param name="newlineMode">Mode to use when adding newlines to text</param>
/// <param name="storageType">Storage type for the exported enum</param>
/// <param name="curlyBracketMode">Mode to use when writing curly-brackets</param>
/// <returns>Exit code</returns>
public int Run(
string inputFile,
string outputFile,
OutputType outputType,
string collectionJPath,
string entryNameJPath,
string entryValueJPath,
string entryCommentJPath,
string enumComment,
string enumNamespace,
Core.Exporter.HeaderMode headerMode,
CodeBuilder.IndentMode indentMode,
int indentSize,
CodeBuilder.NewlineMode newlineMode,
Core.Exporter.StorageType storageType,
Core.Exporter.CurlyBracketMode curlyBracketMode)
{
if (string.IsNullOrEmpty(inputFile))
{
throw new ArgumentException($"Invalid path: '{inputFile}'", nameof(inputFile));
}
if (string.IsNullOrEmpty(outputFile))
{
throw new ArgumentException($"Invalid path: '{outputFile}'", nameof(outputFile));
}
if (string.IsNullOrEmpty(collectionJPath))
{
throw new ArgumentException($"Invalid JPath: '{collectionJPath}'", nameof(collectionJPath));
}
if (string.IsNullOrEmpty(entryNameJPath))
{
throw new ArgumentException($"Invalid JPath: '{entryNameJPath}'", nameof(entryNameJPath));
}
// Resolve relative paths to absolute paths.
var fullInputPath = this.GetFullPath(inputFile);
var fullOutputPath = this.GetFullPath(outputFile);
if (fullInputPath == null || fullOutputPath == null)
{
return(1);
}
// Get input.
var inputJson = GetInputJson();
if (inputJson == null)
{
return(1);
}
// Generate enum name.
var enumName = GetEnumName();
if (enumName == null)
{
return(1);
}
// Create mapping context.
var context = Context.Create(
collectionJPath,
entryNameJPath,
entryValueJPath,
entryCommentJPath,
this.logger);
// Map enum.
EnumDefinition enumDefinition = null;
try
{
enumDefinition = context.MapEnum(inputJson, enumName, enumComment);
}
catch (JsonParsingFailureException)
{
this.logger.LogCritical("Failed to parse input file: invalid json");
return(1);
}
catch (MappingFailureException e)
{
this.logger.LogCritical($"Failed to map enum: {e.InnerException.Message}");
return(1);
}
// Export.
var output = Export(enumDefinition);
if (output == null)
{
return(1);
}
// Save to file.
try
{
if (!fullOutputPath.EndsWith(GetRequiredExtension(outputType), StringComparison.OrdinalIgnoreCase))
{
fullOutputPath = $"{fullOutputPath}{GetDesiredExtension(outputType)}";
}
Directory.GetParent(fullOutputPath).Create();
using (var stream = new FileStream(fullOutputPath, FileMode.Create, FileAccess.Write))
{
stream.Write(output);
}
this.logger.LogInformation($"Written enum to: '{fullOutputPath}'");
}
catch (Exception e)
{
this.logger.LogCritical($"Failed to save to '{fullOutputPath}': {e.Message}");
return(1);
}
return(0);
byte[] Export(EnumDefinition enumDef)
{
switch (outputType)
{
case OutputType.CSharp:
try
{
return(Utf8NoBom.GetBytes(enumDef.ExportCSharp(
enumNamespace,
headerMode,
indentMode,
indentSize,
newlineMode,
storageType,
curlyBracketMode)));
}
catch (Exception e)
{
this.logger.LogCritical($"Failed to generate csharp: {e.Message}");
return(null);
}
case OutputType.FSharp:
try
{
return(Utf8NoBom.GetBytes(enumDef.ExportFSharp(
string.IsNullOrEmpty(enumNamespace) ? "Generated" : enumNamespace,
headerMode,
indentSize,
newlineMode,
storageType)));
}
catch (Exception e)
{
this.logger.LogCritical($"Failed to generate fsharp: {e.Message}");
return(null);
}
case OutputType.VisualBasic:
try
{
return(Utf8NoBom.GetBytes(enumDef.ExportVisualBasic(
enumNamespace,
headerMode,
indentMode,
indentSize,
newlineMode,
storageType)));
}
catch (Exception e)
{
this.logger.LogCritical($"Failed to generate csharp: {e.Message}");
return(null);
}
case OutputType.Cil:
try
{
return(Utf8NoBom.GetBytes(enumDef.ExportCil(
assemblyName: enumName,
enumNamespace,
headerMode,
indentMode,
indentSize,
newlineMode,
storageType,
curlyBracketMode)));
}
catch (Exception e)
{
this.logger.LogCritical($"Failed to generate cil: {e.Message}");
return(null);
}
case OutputType.ClassLibrary:
try
{
return(enumDef.ExportClassLibrary(
assemblyName: enumName,
enumNamespace,
storageType));
}
catch (Exception e)
{
this.logger.LogCritical($"Failed to generate class-library: {e.Message}");
return(null);
}
default:
this.logger.LogCritical($"Unsupported output-type '{outputType}'");
return(null);
}
}
string GetInputJson()
{
if (!File.Exists(fullInputPath))
{
this.logger.LogCritical($"No file found at: '{fullInputPath}'");
return(null);
}
try
{
var result = File.ReadAllText(fullInputPath);
this.logger.LogDebug($"'{result.Length}' characters read from: '{fullInputPath}'");
return(result);
}
catch (Exception e)
{
this.logger.LogCritical($"Unable to read file '{fullInputPath}': {e.Message}");
return(null);
}
}
string GetEnumName()
{
// Determine file-name.
string fileName;
try
{
fileName = Path.GetFileNameWithoutExtension(fullOutputPath);
if (fileName.EndsWith(".g", StringComparison.OrdinalIgnoreCase))
{
fileName = fileName.Substring(0, fileName.Length - 2);
}
}
catch (Exception)
{
this.logger.LogCritical($"Unable to get file-name from path: '{fullOutputPath}'");
return(null);
}
// Convert file-name into valid identifier.
if (IdentifierCreator.TryCreateIdentifier(fileName, out var nameId))
{
this.logger.LogDebug($"Generated enum-name: '{nameId}' from file-name: '{fileName}'");
return(nameId);
}
this.logger.LogCritical($"Unable to create valid identifier from file-name: '{fileName}'");
return(null);
}
}
private static void MapEntry(this Context context, EnumBuilder builder, JToken entryToken)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
if (builder == null)
throw new ArgumentNullException(nameof(builder));
if (entryToken == null)
throw new ArgumentNullException(nameof(entryToken));
var parsedName = ParseName();
if (string.IsNullOrEmpty(parsedName))
{
context.Logger?.LogTrace("Skipping entry without name");
return;
}
context.Logger?.LogDebug($"Parsed entry-name: {parsedName}");
var parsedValue = ParseValue();
context.Logger?.LogDebug($"Parsed entry-value: {parsedValue}");
var parsedComment = ParseComment();
if (!string.IsNullOrEmpty(parsedComment))
context.Logger?.LogDebug($"Parsed entry-comment: {parsedComment}");
builder.PushEntry(parsedName, parsedValue, parsedComment);
string ParseName()
{
var nameToken = entryToken.SelectToken(context.EntryNameJPath);
if (nameToken == null)
{
context.Logger?.LogError($"Unable to find entry-name at path: '{context.EntryNameJPath}'");
return null;
}
string name;
try
{
name = nameToken.Value<string>();
}
catch
{
context.Logger?.LogError($"Entry-name at path: '{context.EntryNameJPath}' is not of type 'string'");
return null;
}
context.Logger?.LogTrace($"Entry name-token found: '{name}'");
// Create identifier out of the name.
if (!IdentifierCreator.TryCreateIdentifier(name, out var nameId))
{
context.Logger?.LogError($"Unable to convert name '{name}' into a valid identifier");
return null;
}
// Unduplicate name.
var duplicationCount = 1;
var unduplicatedName = nameId;
while (builder.HasEntry(unduplicatedName))
{
context.Logger?.LogTrace($"Duplicate name '{unduplicatedName}', adding number to unduplicate");
unduplicatedName = $"{nameId}_{duplicationCount++}";
}
return unduplicatedName;
}
long ParseValue()
{
var valueToken = string.IsNullOrEmpty(context.EntryValueJPath) ?
null :
entryToken.SelectToken(context.EntryValueJPath);
if (valueToken == null)
{
context.Logger?.LogTrace(
$"No value found at: '{context.EntryValueJPath}' using count '{builder.EntryCount}' as value");
return builder.EntryCount;
}
try
{
return valueToken.Value<long>();
}
catch
{
context.Logger?.LogWarning($"Value found at: '{context.EntryValueJPath}' is not of type 'number'");
return builder.EntryCount;
}
}
string ParseComment()
{
var commentToken = string.IsNullOrEmpty(context.EntryCommentJPath) ?
null :
entryToken.SelectToken(context.EntryCommentJPath);
if (commentToken == null)
return null;
try
{
return commentToken.Value<string>();
}
catch
{
context.Logger?.LogWarning($"Comment at path: '{context.EntryValueJPath}' is not of type 'string'");
return null;
}
}
}
public User(string username)
{
Id = IdentifierCreator.UniqueDigits();
Username = username;
}
public void ValidIdentifierIsGenerated(string input, string identifier)
{
Assert.True(IdentifierCreator.TryCreateIdentifier(input, out var generatedIdentifier));
Assert.True(IdentifierValidator.Validate(generatedIdentifier));
Assert.Equal(identifier, generatedIdentifier);
}