private User GetUserFromInput(AddUserCommand input)
{
var user = new User()
{
Tenants = new List <UserTenant>
{
new UserTenant()
{
TenantId = input.TenantId,
FederationCode = codeGenerator.Generate(10)
}
},
Profile = new UserProfile()
{
FirstName = input.FirstName,
LastName = input.LastName,
Address = new Address()
{
City = input.City,
State = input.State,
Zip = input.Zip,
Street = input.Street,
Country = input.Country
}
}
};
return(user);
}
public void TestClassesTestGenerator()
{
try
{
baseGenerator.Init(Globals.SmsTestProject, null, new BuildAggregator());
}
catch (Exception ex)
{
Log.Error(ex);
}
baseGenerator.Generate();
}
public int OnExecute()
{
if (Profile == null)
{
Console.Error.WriteLine("You must specify a profile name for which to generate code");
return(-1);
}
var profile = GetProfiles().SingleOrDefault(x => x.Name == Profile);
if (profile == null)
{
Console.Error.WriteLine($"Could not resolve profile] for name [{Profile}]");
return(-1);
}
var options = _serializer.Load(profile);
Console.WriteLine("Got Options: " + options);
var tc = ResolveTemplates(options);
var model = _cacheBuilder.LoadFromCache(options);
_codeGenerator.Generate(options, model, tc, File.WriteAllText);
return(0);
}
private void GenerateCodeFor(IManageEntityMetadata entityMetadataMgr)
{
var aggregateRoot = entityMetadataMgr.EntityName;
// Generate namespace section
var namespaceDeclaration = new NamespaceDeclaration(aggregateRoot);
// Generate class declration
var factoryClass = new ClassDeclaration
{
ClassName = aggregateRoot + "Factory",
Base = string.Format("IResourceFactory<{0}>", aggregateRoot)
};
namespaceDeclaration.Classes.Add(factoryClass);
var context = new CodeGenContext(namespaceDeclaration, factoryClass);
var buildMethodName = "Build" + aggregateRoot;
context.ClassDeclaration
.OpenMethod(new MethodDeclaration("public", aggregateRoot, "Build", "XElement element, INodeSearch nodeSearch"))
.WriteLine("return ({0})", aggregateRoot)
.Write("{0}(element, nodeSearch);", buildMethodName)
.EndMethod();
GenerateHelperBuildMethodFor(entityMetadataMgr, context);
// write the generated code to file
codeGenerator.Generate(namespaceDeclaration);
}
public bool EmitCode()
{
if (combinedCodeGenManifest == null)
{
diags.ReportError("Compilation has no manifests for code generation.");
return(false);
}
var trap = diags.TrapError();
ICodeGenerator codeGen = opts.CodeGenOptions.CodeGeneratorFactory?.Invoke();
if (codeGen == null)
{
diags.ReportError("Failed to create the code generator instance.");
return(false);
}
using var output = FileUtilities.TryCreateFile(diags, opts.CodeGenOptions.CodeHeaderFile);
if (output == null)
{
return(false);
}
codeGen.Generate(combinedCodeGenManifest, output);
return(!trap.ErrorOccurred);
}
public Game(ICodeGenerator generator, GameStatus gameStatus, GameInputValidator validator)
{
_codeGenerator = generator;
code = _codeGenerator.Generate();
_gameStatus = gameStatus;
_validator = validator;
}
private void generate()
{
ICodeGenerator selectedCodeGenerator = (ICodeGenerator)this.cmbGenerator.SelectedItem;
this.txtGeneratedCode.Text = selectedCodeGenerator.Generate(this.txtClassName.Text, this.schemaTable);
//MessageBox.Show(selectedSchemaService.SchemaServiceName);
}
private static int GenerateCode(Options result)
{
XDocument xdoc = XDocument.Parse("<def></def>");
System.IO.DirectoryInfo directory = new DirectoryInfo(result.ModelDirectory);
if (directory.Exists)
{
directory.GetFiles().Where((file) => file.Extension == ".xml").Aggregate(xdoc, (doc, file) => {
doc.Root.Add(XDocument.Load(file.FullName).Root.Elements());
return(doc);
});
}
else
{
return(1);
}
var model = BuildModel(xdoc);
var dllPath = Path.IsPathRooted(result.Generator) ? result.Generator : Path.Combine(Directory.GetCurrentDirectory(), result.Generator);
var asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(dllPath);
var type = asm.ExportedTypes.First(t => t.GetInterfaces().Contains(typeof(ICodeGenerator)));
ICodeGenerator generator = Activator.CreateInstance(type) as ICodeGenerator;
if (generator != null)
{
return(generator.Generate(model, result.OutputDirectory, result.TemplateDirectory));
}
return(1);
}
/// <summary>
/// Decompiles the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="method">The method.</param>
/// <returns></returns>
public IPapyrusDecompilerResult Decompile(IDecompilerContext context, PapyrusMethodDefinition method)
{
context.SetTargetMethod(method);
flowAnalyzer.FindVarTypes();
flowAnalyzer.CreateFlowBlocks();
flowAnalyzer.MapLongLivedTempVariables();
flowAnalyzer.AssignLongLivedTempVariables();
flowAnalyzer.RebuildExpressionsInBlocks();
flowAnalyzer.RebuildBooleanOperators(0, method.Body.Instructions.Count);
var tree = flowAnalyzer.RebuildControlFlow(0, method.Body.Instructions.Count);
tree = flowAnalyzer.Finalize(tree);
var result = codeGenerator.Generate(tree);
var sourceCode = codeGenerator.GetMethodSourceCode(result, method);
return(new PapyrusDecompilerResult(sourceCode, null));
}
public async Task <CommandResult> Handle(ForgotPasswordCommand email)
{
var user = userRepo.Get(email.Email);
if (user == null)
{
return(CommandResult.Fail());
}
user.ValidationCodes = user.ValidationCodes.Where(v => v.Type != ValidationCodeType.PasswordReset).ToList();
var code = new ValidationCode()
{
Code = codeGenerator.Generate(30),
CreatedDate = DateTime.Now,
Type = ValidationCodeType.PasswordReset,
};
user.ValidationCodes.Add(code);
userRepo.Update(user);
var em = new PasswordResetEmail()
{
To = user.Credentials.Email,
Url = string.Format(appSettings.PasswordResetUrl, user.Id.ToString(), code.Code)
};
await emailSender.Send(em);
return(CommandResult.Success());
}
public string Compile(string code)
{
var allCode = GetStdCode() + code;
var tokens = _lexicalAnalyser.Convert(allCode);
var tree = _syntaxAnalyser.Convert(tokens);
_semanticAnalyser.Analyse(tree);
return(_codeGenerator.Generate(tree));
}
/// <summary>
/// Generates source code from <paramref name="databaseModel"/> to the specified <paramref name="toFolder"/>, <seealso cref="DatabaseModel"/>
/// </summary>
/// <param name="codeGenerator">The <see cref="ICodeGenerator"/>.</param>
/// <param name="databaseModel">The database model.</param>
/// <param name="toFolder">The folder to save the source code.</param>
/// <param name="namespace">The namespace for the generated class, if null, will use the namespace of the this tools.</param>
public static void EmitSourceCode(this ICodeGenerator codeGenerator, DatabaseModel databaseModel, string toFolder, string @namespace = null)
{
foreach (var item in codeGenerator.Generate(databaseModel, @namespace))
{
var fileName = $@"{toFolder}\{item.name}.cs";
// write to disk.
File.WriteAllText(fileName, item.syntaxNode.ToFullString());
}
}
private void GeneratCode(object obj)
{
var kv = (KeyValuePair <string, object>)obj;
var key = kv.Key;
var value = (SchemaObject)kv.Value;
var result = codeGenerator.Generate(new CodeGenerationKey {
Name = key
}, value);
GeneratedText = result;
}
protected override int OnExecute(CommandLineApplication application)
{
var workingDirectory = WorkingDirectory ?? Environment.CurrentDirectory;
var optionsFile = OptionsFile ?? GeneratorOptionsSerializer.OptionsFileName;
var options = Serializer.Load(workingDirectory, optionsFile);
if (options == null)
{
Logger.LogInformation("Using default options");
options = new GeneratorOptions();
}
// override options
if (ConnectionString.HasValue())
{
options.Database.ConnectionString = ConnectionString;
}
if (Provider.HasValue)
{
options.Database.Provider = Provider.Value;
}
if (Extensions.HasValue)
{
options.Data.Query.Generate = Extensions.Value;
}
if (Models.HasValue)
{
options.Model.Read.Generate = Models.Value;
options.Model.Create.Generate = Models.Value;
options.Model.Update.Generate = Models.Value;
}
if (Mapper.HasValue)
{
options.Model.Mapper.Generate = Mapper.Value;
}
if (Validator.HasValue)
{
options.Model.Validator.Generate = Validator.Value;
}
var result = _codeGenerator.Generate(options);
return(result ? 0 : 1);
}
private CSharpDocument WriteDocument(
ICodeGenerator generator,
ICodeDescriptor descriptor,
StringBuilder code)
{
code.Clear();
using var writer = new CodeWriter(code);
generator.Generate(writer, descriptor, out string fileName);
writer.Flush();
return(new(fileName, code.ToString()));
}
public void AddScoped_foreach_CodeIsCorrect()
{
_methodGenerator
.AddScoped("foreach(var e in list)", method => method
.AddLine("Console.WriteLine(e);"));
var code = _codeGenerator.Generate();
code.RemoveSpecialCharacters().Should().Be(
"foreach(var e in list)" +
"{" +
"Console.WriteLine(e);" +
"}");
}
private async Task <CreateRoundResult> CreateRound(int gameId, int ownerId, int questionCardId, int roundNumber)
{
var code = codeGenerator.Generate();
var gameRound = await gameRoundsRepository.CreateGameRound(new CreateGameRoundModel
{
GameId = gameId,
RoundCode = code,
OwnerPlayerId = ownerId,
QuestionCardId = questionCardId,
RoundNumber = roundNumber
});
return(new CreateRoundResult(gameRound.GameRoundId, gameRound.Code, ownerId));
}
public async Task <string> Save(string LongUrl)
{
//LongUrl = LongUrl.ToUpper();
if (!Regex.IsMatch(LongUrl, URLHelpers.HttpRegexTemplate))
{
throw new ArgumentException("Invalid parameter", "LongUrl");
}
//get string sha256 hash
var hash = GetCryptoHashCode(LongUrl.ToUpper()).ToHexString();
//check if it exists
//if exists, return existing short link
var link = (await linkMgr.GetFiltered(new LinkSpecification(l => l.LinkHash == hash))).FirstOrDefault();
if (link != null)
{
return(GetFullShortLink(link.ShortLink));
}
else
{
int retryCount = 0;
do
{
//generate shortCode
var shortPart = codeGen.Generate();
link = (await linkMgr.GetFiltered(new LinkSpecification(l => l.ShortLink == shortPart))).FirstOrDefault();
if (link == null)
{
link = new Link()
{
LongLink = LongUrl,
LinkHash = hash,
ShortLink = shortPart,
CreatedAt = DateTime.Now
};
try
{
await linkMgr.Create(link);
return(GetFullShortLink(link.ShortLink));
}
catch (DbUpdateException) { }
}
} while (++retryCount < options.RetryLimit);
throw new OperationAbortedException("Operation cann't be completed. Try again later");
}
}
public void OnExecute()
{
using var server = OutProcGenProtocol.CreateServer(PipeName);
server.WaitForConnection();
server.BeginSession();
// server.StartProfile("all_profiles");
// var buff = new StringBuilder();
// buff.AppendLine(@"
//namespace Conjure.Gen
//{
// public partial class Profiles
// {
//");
// foreach (var profile in GetProfiles())
// {
// buff.AppendLine($" // {profile.Name}");
// buff.AppendLine($" public const string ProfilePath_{profile.Name} = \"{profile.ProfilePath.Replace("\\", "\\\\")}\";");
// buff.AppendLine($" public const string OptionsPath_{profile.Name} = \"{profile.OptionsPath.Replace("\\", "\\\\")}\";");
// }
// buff.AppendLine(@"
// }
//}
//");
// server.AddFile("AllProfiles.cs", buff.ToString());
try
{
foreach (var profile in GetProfiles())
{
var options = _serializer.Load(profile);
var model = _cacheBuilder.LoadFromCache(options);
var tc = GenerateCommand.ResolveTemplates(options);
server.StartProfile(profile.Name);
_codeGenerator.Generate(options, model, tc, server.AddFile);
}
}
catch (Exception ex)
{
server.Fail("???", ex.Message, ex.StackTrace);
}
server.EndSession();
}
public async Task <CreateGameResult> Handle(CreateGame request, CancellationToken cancellationToken)
{
using (var transaction = repositoryTransactionsFactory.CreateTransaction())
{
var validationResult = await requestValidator.Validate(request);
if (!validationResult.IsSuccessful)
{
return(new CreateGameResult(validationResult.Error));
}
var gameCode = codeGenerator.Generate();
var game = await CreateGame(request, gameCode);
var player = await CreatePlayer(game.GameId, request.UserId);
var createRoundResult = await gameRoundCreator
.CreateFirstRound(game.GameId, player.PlayerId);
if (!createRoundResult.IsSuccessful)
{
return(new CreateGameResult(createRoundResult.Error));
}
var createCardsResult = await playerCardsCreator.CreateCardsForPlayer(game.GameId, player.PlayerId);
if (!createCardsResult.IsSuccessful)
{
return(new CreateGameResult(createCardsResult.Error));
}
var checkpoint = await gameCheckpointUpdater.Update(game.GameId, nameof(CreateGame));
transaction.CommitTransaction();
return(new CreateGameResult
{
GameId = game.GameId,
PlayerId = player.PlayerId,
Code = gameCode,
Checkpoint = checkpoint
});
}
}
public async Task <string> Update(int gameId, string operationType)
{
var checkpointCode = codeGenerator.Generate();
var result = await checkpointRepository.CreateGameCheckpoint(new CreateGameCheckpointModel
{
Code = checkpointCode,
GameId = gameId,
OperationType = operationType
});
if (result == 0)
{
throw new InvalidOperationException(GameErrors.CheckpointUpdateFailed);
}
return(checkpointCode);
}
private static CSharpDocument WriteDocument(
ICodeGenerator generator,
ICodeDescriptor descriptor,
StringBuilder code)
{
code.Clear();
using var writer = new CodeWriter(code);
#if DEBUG
writer.WriteLine("// " + generator.GetType().FullName);
writer.WriteLine();
#endif
generator.Generate(writer, descriptor, out string fileName);
writer.Flush();
return(new(fileName, code.ToString()));
}
private async Task <CreateUserResult> CreateNewGoogleUser(AuthenticateGoogleUser request)
{
var userCode = codeGenerator.Generate();
var result = await usersRepository.CreateGoogleUser(new CreateGoogleUserModel
{
Code = userCode,
Email = request.Email,
DisplayName = request.DisplayName,
GoogleId = request.GoogleId,
ImageUrl = request.ImageUrl
});
if (!result.IsSuccessful)
{
return(new CreateUserResult(result.Error));
}
return(CreateResult(result.Model));
}
private static void GenerateAll()
{
Type typeDefinition = typeof(ICodeGenerator);
Assembly assembly = Assembly.GetExecutingAssembly();
List <Type> types = assembly.GetTypes()
.Where(x => x.GetInterfaces().Contains(typeDefinition))
.ToList();
for (int i = 0; i < types.Count; i++)
{
Type type = types[i];
if (type.IsAbstract)
{
continue;
}
ICodeGenerator instance = (ICodeGenerator)Activator.CreateInstance(type);
instance.Generate();
}
}
private void ParseButtonClick(object sender, EventArgs e)
{
var url = new Uri(UrlTextBox.Text);
var method = pageParser.Parse(url);
var methodAsString = new StringBuilder();
methodAsString.AppendLine($"Block: {method.Block}");
methodAsString.AppendLine($"Name: {method.Name}");
methodAsString.AppendLine($"Description: {method.Description}");
methodAsString.AppendLine(string.Empty);
methodAsString.AppendLine($"Request parameters");
foreach (var parameter in method.RequestParameters)
{
methodAsString.AppendLine($" Name: {parameter.Name}");
methodAsString.AppendLine($" Type: {parameter.Type}");
methodAsString.AppendLine($" Required: {parameter.IsRequired}");
methodAsString.AppendLine($" Description: {parameter.Description}");
methodAsString.AppendLine(string.Empty);
}
methodAsString.AppendLine($"Response info");
foreach (var parameter in method.ResponseParameters)
{
methodAsString.AppendLine($" Name: {string.Join(".", parameter.Name)}");
methodAsString.AppendLine($" Type: {parameter.Type}");
methodAsString.AppendLine($" Description: {parameter.Description}");
methodAsString.AppendLine(string.Empty);
}
ParsedMethodRichTextBox.Text = methodAsString.ToString();
var generationResult = codeGenerator.Generate(method);
GeneratedRequestCodeRichTextBox.Text = generationResult.RequestClass;
GeneratedResponseCodeRichTextBox.Text = generationResult.ResponseClass;
}
/// <summary>
/// Process an individual request.
/// </summary>
/// <param name="environment"></param>
/// <returns></returns>
public Task Invoke(HttpContext context)
{
var request = context.Request;
var path = new PathString(Path);
if (request.Path == path)
{
var codeName = StringValues.IsNullOrEmpty(request.Query["name"]) ? "default" : request.Query["name"].ToString();
var length = request.Query["length"];
var codeLength = StringValues.IsNullOrEmpty(length) ? 4 : int.Parse(length);
string codeValue = _codeGenerator.Generate(codeLength);
context.Session.SetString(SessionKeyPrefix_Value + codeName.Trim(), codeValue);
var buffer = _graphicGenerator.Generate(codeValue);
context.Response.ContentLength = buffer.Length;
context.Response.ContentType = "image/jpeg";
context.Response.StatusCode = 200;
return(context.Response.Body.WriteAsync(buffer, 0, buffer.Length));
}
return(_next.Invoke(context));
}
public async Task <CreateUserResult> Handle(CreateUser request, CancellationToken cancellationToken)
{
var validationResult = await requestValidator.Validate(request);
if (!validationResult.IsSuccessful)
{
return(new CreateUserResult(validationResult.Error));
}
var userCode = codeGenerator.Generate();
var imageUrl = imageUrlProvider.GetImageUrl(request.Email);
var result = await usersRepository.CreateUser(new CreateUserModel
{
Email = request.Email,
DisplayName = request.DisplayName,
Password = request.Password,
Code = userCode,
ImageUrl = imageUrl,
});
if (!result.IsSuccessful)
{
return(new CreateUserResult(result.Error));
}
return(new CreateUserResult
{
User = new UserModel
{
UserId = result.Model.UserId,
Email = result.Model.Email,
DisplayName = result.Model.DisplayName,
UserName = result.Model.UserName,
Code = result.Model.Code,
ImageUrl = result.Model.ImageUrl
}
});
}
public async Task <int> GenerateVendorCodesAsync(int vendorCodeTypeId, int numberOfCodes)
{
VerifyManagementPermission();
var codeType = await _vendorCodeTypeRepository.GetByIdAsync(vendorCodeTypeId);
if (codeType == null)
{
throw new GraException("Unable to find vendor code type.");
}
if (codeType.SiteId != GetCurrentSiteId())
{
throw new GraException("Code type provided does not match current site.");
}
int count = 1;
var vendorCode = new VendorCode
{
IsUsed = false,
SiteId = codeType.SiteId,
VendorCodeTypeId = codeType.Id,
};
for (; count <= System.Math.Min(numberOfCodes, 5000); count++)
{
vendorCode.Code = _codeGenerator.Generate(15);
await _vendorCodeRepository.AddAsync(GetClaimId(ClaimType.UserId), vendorCode);
if (count % 1000 == 0)
{
await _vendorCodeRepository.SaveAsync();
}
}
await _vendorCodeRepository.SaveAsync();
return(--count);
}
private void Generate(ICodeGenerator generator)
{
string input = rtxtInput.Text.Trim();
if (string.IsNullOrEmpty(input))
{
rtxtInput.Text = generator.ExampleInput;
return;
}
string output = generator.Generate(rtxtInput.Lines);
rtxtOutput.Text = output;
}
public Game(ICodeGenerator codeGenerator)
{
code = codeGenerator.Generate();
}
public static async Task <string> GenerateAsync(this ICodeGenerator codeGenerator, object root)
{
using (await codeGenerator.Lock.LockAsync())
return(await Task.Run(() => codeGenerator.Generate(root)));
}
