public async Task GenerateCode(GeneratorModel model) { var typeLocator = _serviceProvider.GetRequiredService <IModelTypesLocator>(); var genModel = new Model() { Namespace = model.Namespace, Types = typeLocator.GetAllTypes().Select(t => new MyType { Name = t.Name, Properties = (t.TypeSymbol as INamedTypeSymbol) .GetMembers() .Where(m => m.Kind == SymbolKind.Property) .OfType <IPropertySymbol>() .Select(m => new MyProperty { Name = m.Name, Type = m.Type.Name }).ToArray() }).ToArray() }; var applicationInfo = _serviceProvider.GetRequiredService <IApplicationInfo>(); var projectInfo = _serviceProvider.GetRequiredService <IProjectContext>(); var templateFolders = TemplateFoldersUtilities .GetTemplateFolders("AdvancedScaffolder", applicationInfo.ApplicationBasePath, new string[] { "Adv" }, projectInfo); var actionService = _serviceProvider.GetRequiredService <ICodeGeneratorActionsService>(); await actionService.AddFileFromTemplateAsync(@".\file.txt", "Template.cshtml", templateFolders, genModel); }
private async Task <ActionResult> GenerateProject(GeneratorModel model) { try { var archiveBytes = await _sttemplateService.GenerateProjectArchiveAsync(model); var cd = new ContentDispositionHeaderValue("attachment") { FileNameStar = model.ArchiveName, }; Response.Headers.Add("Content-Disposition", cd.ToString()); return(File(archiveBytes, "application/zip")); } catch (Exception ex) { HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest; var message = ex.Message; /* * if (model.TargetFrameworkVersion == "netcoreapp3.1" && model.SteeltoeVersion == "2.3.0") * { * message = "2.4.0 is the lowest version of Steeltoe that works with netcoreapp3.1\n"; * } */ return(Content(message)); } }
public async void PostStarterZipValidationTest() { var model = new GeneratorModel() { Dependencies = "Actuator,MySql", Description = "TestDescription", ProjectName = "123.TestProject", SteeltoeVersion = "2.2.0", TargetFrameworkVersion = "netcoreapp2.2", TemplateShortName = "Steeltoe-WebApi", TemplateVersion = TemplateVersion.V2, }; var props = model.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); var kvps = props.Select(prop => new KeyValuePair <string, string>(prop.Name, prop.GetValue(model).ToString())).ToArray(); var formContent = new FormUrlEncodedContent(kvps); var result = await _client.PostAsync("https://localhost/starter.zip", formContent); Assert.Equal(HttpStatusCode.BadRequest, result.StatusCode); var responseString = await result.Content.ReadAsStringAsync(); Assert.Contains(@"""ProjectName"":[""ProjectName must be a valid C# Identifier""]", responseString); }
private void Awake() { _generatorModel = new GeneratorModel(); _generatorModel.SetPrefabs(); _generatorView.GeneratorModel = _generatorModel; _generatorView.BoxModel = _boxController.GetModel(); _generatorView.OnStoreInstantiatedBox = OnStoreInstantiatedBox; _groundHeight = 0.7f; _boxHeight = 0.5f; _generatorView.OnAddHeightOfPosition = () => { AddHeightPositon(); }; _generatorView.OnSetStarterBox = (starterBox, pieces) => { _generatorModel.StarterBox = starterBox; _boxController.GetModel().BoxPieces = pieces; }; _generatorView.StarterParent = GameObject.Find("environment").transform; _generatorView.GeneratorParent = GameObject.Find("Generator").transform; _generatorView.PiecesParent = GameObject.Find("Pieces").transform; _generatorView.GenerateStarter(); _generatorView.GenerateBoxes(); }
private async Task <byte[]> GenerateProjectArchive(GeneratorModel model) { byte[] archiveBytes; var listOfFiles = await GenerateProjectFiles(model); using (var memoryStream = new MemoryStream()) { using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true)) { foreach (var(key, value) in listOfFiles) { _logger.LogDebug(key); var ef = archive.CreateEntry(key, CompressionLevel.Optimal); using (var entryStream = ef.Open()) using (var fileToCompress = new MemoryStream(Encoding.UTF8.GetBytes(value))) { ef.ExternalAttributes = 27262976; // RW_(Owner)/R__(Group)/___(Other) fileToCompress.CopyTo(entryStream); } } } archiveBytes = memoryStream.ToArray(); } return(archiveBytes); }
public ActionResult SelectOutcomes(FormCollection form) { if (Session["USER"] != null) { if (lecturer.Priority >= 7) { GeneratorModel generator = Session["Generator"] as GeneratorModel; string[] TypesOfQuestions = new string[generator.NumberOfQuestions]; for (int i = 0; i < generator.NumberOfQuestions; i++) { TypesOfQuestions[i] = form["QuestionType" + i].ToString(); } QuestionsSelectionModel questionsSelectionModel = new QuestionsSelectionModel(Request.Cookies["SubjectChoosen"].Value); questionsSelectionModel.NumberOfQuestions = generator.NumberOfQuestions; questionsSelectionModel.TypesOfQuestion = TypesOfQuestions; //Session["Selection"] = questionsSelectionModel; generator.TypesOfQuestions = TypesOfQuestions; Session["Generator"] = generator; return(View(questionsSelectionModel)); } } return(RedirectToAction("Index", "Home")); }
public void Execute(GeneratorModel generator, bool useUniform) { List <string> ServiceDIString = new List <string>(); GenDB(generator); if (!useUniform) { foreach (var item in generator.Db_List) { GenService(generator, item); GenServiceInterface(generator, item); ServiceDIString.Add(GetDIString(item.ServiceName)); } } else { GenUniformCenterService(generator, generator.UniformModel); foreach (var item in generator.Db_List) { GenUniformService(generator, item); } } bool IsWindows = System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Windows); if (IsWindows) { FolderSymbol = "\\"; } Console.WriteLine($"Current Folder : {Directory.GetCurrentDirectory()}"); Directory.CreateDirectory("Snippest"); File.AppendAllLines($"Snippest{FolderSymbol}Startup.txt", ServiceDIString); }
private byte[] GenerateProjectArchive(GeneratorModel model) { byte[] archiveBytes; var listOfFiles = GenerateProjectFiles(model); using (var memoryStream = new MemoryStream()) { using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true)) { foreach (var(key, value) in listOfFiles) { _logger.LogDebug(key); var ef = archive.CreateEntry(key, CompressionLevel.Optimal); using (var entryStream = ef.Open()) using (var fileToCompress = new MemoryStream(Encoding.UTF8.GetBytes(value))) { fileToCompress.CopyTo(entryStream); } } } archiveBytes = memoryStream.ToArray(); } return(archiveBytes); }
private static void GenService(GeneratorModel generator, DatabaseServiceModel databaseService) { var serviceFile = File.CreateText($"{databaseService.ServiceName}Service.cs"); var serviceGeneration = EFCoreServiceGeneration.CreatEFCoreDefaultService(databaseService, generator); serviceGeneration.WriteTo(serviceFile); serviceFile.Close(); }
private static void GenDB(GeneratorModel generator) { var dbfile = File.CreateText($"{generator.ApplicationDbName}.cs"); var dbgeneration = DbGeneration.GenerateDb(generator); dbgeneration.WriteTo(dbfile); dbfile.Close(); }
public async Task <string> GenerateProject(GeneratorModel model) { var randomString = Guid.NewGuid().ToString() + DateTime.Now.Millisecond; var outFolder = Path.Combine(_outPath, randomString, model.ProjectName); var iParams = new Dictionary <string, string> { { "Name", model.ProjectName } }; foreach (var p in model.GetTemplateParameters()) { if (p.Contains('=')) { var paramkvp = p.Split('='); if (paramkvp.Length == 2) { iParams.Add(paramkvp[0], paramkvp[1]); } } else { iParams.Add(p, "true"); } } if (!string.IsNullOrEmpty(model.TargetFrameworkVersion)) { iParams.Add("Framework", model.TargetFrameworkVersion); } var templateShortName = string.IsNullOrEmpty(model.TemplateShortName) ? DEFAULT_TEMPLATE : model.TemplateShortName; TemplateInfo templateInfo = FindTemplateByShortName(templateShortName, model.TemplateVersion, EnvSettings); if (templateInfo == null) { throw new Exception($"Could not find template with shortName: {templateShortName} "); } TemplateCreator creator = new TemplateCreator(EnvSettings); var creationResult = await creator.InstantiateAsync( templateInfo : templateInfo, name : model.ProjectName, fallbackName : "SteeltoeProject", outputPath : outFolder, inputParameters : iParams, skipUpdateCheck : true, forceCreation : false, baselineName : "baseLine"); if (creationResult.Status != CreationResultStatus.Success) { throw new InvalidDataException(creationResult.Message + ": " + creationResult.Status + " " + templateShortName); } return(outFolder); }
/// <summary> /// Generate map partial - Using the datasource only. /// </summary> /// <param name="htmlHelper"></param> /// <param name="mapAlias">The alias for the map.</param> /// <returns></returns> public static MvcHtmlString RenderMap(this HtmlHelper htmlHelper, string mapAlias) { var model = new GeneratorModel { Alias = mapAlias }; return(htmlHelper.Partial("NcMapBuilder/Generator", model)); }
public ActionResult GenerateProjectTest2([FromQuery(Name = "templateShortName")] string templateShortName) { var testModel = new GeneratorModel { ProjectName = "mytest", Dependencies = new[] { "actuators,mysql" }, }; return(GenerateProject2(testModel)); }
public ActionResult Index(long userId) { if (IsInvalid(userId)) { return(RedirectToAction("Index", RouteConfig.MAIN_CONTROLLER_NAME)); } GeneratorModel generatorModel = GenerateItems(userId); return(View("../Knowledge/Generator", generatorModel)); }
public JsonResult Generate(long userId) { if (IsInvalid(userId)) { return(JsonResultHelper.Error()); } GeneratorModel generatorModel = GenerateItems(userId); return(JsonResultHelper.GetUnlimitedJsonResult(generatorModel.HtmlItems)); }
private void GenDB(GeneratorModel generator) { string FolderPath = $"CreatedFile{FolderSymbol}Database{FolderSymbol}"; Directory.CreateDirectory(FolderPath); var dbfile = File.CreateText($"{FolderPath}{generator.ApplicationDbName}.cs"); var dbgeneration = DbGeneration.GenerateDb(generator); dbgeneration.WriteTo(dbfile); dbfile.Close(); }
private ActionResult GenerateProject2(GeneratorModel model) { var fileBytes = _sttemplateService.GenerateProjectArchiveAsync(model).Result; var cd = new ContentDispositionHeaderValue("attachment") { FileNameStar = (model.ProjectName ?? "SteeltoeProject") + ".zip", }; Response.Headers.Add("Content-Disposition", cd.ToString()); return(File(fileBytes, "application/zip")); }
/// <summary> /// Generate map partial with only nodeIds used for markers - Important to note, that each node should be using the same titleProperty and coordsProperty for this to work. /// </summary> /// <param name="htmlHelper"></param> /// <param name="mapAlias">The alias for the map.</param> /// <param name="nodeIds">A list of node ids (List<int>)</param> /// <param name="titleProperty">The property alias for the title on the nodes.</param> /// <param name="coordsProperty">The property alias for the coordinates on the nodes.</param> /// <returns></returns> public static MvcHtmlString RenderMap(this HtmlHelper htmlHelper, string mapAlias, List <int> nodeIds, string titleProperty, string coordsProperty) { var model = new GeneratorModel { Alias = mapAlias, NodeIds = nodeIds, TitleProperty = titleProperty, CoordsProperty = coordsProperty }; return(htmlHelper.Partial("NcMapBuilder/Generator", model)); }
private async Task <ActionResult> GenerateProject(GeneratorModel model) { var archiveBytes = await _sttemplateService.GenerateProjectArchiveAsync(model); var cd = new ContentDispositionHeaderValue("attachment") { FileNameStar = model.ArchiveName, }; Response.Headers.Add("Content-Disposition", cd.ToString()); return(File(archiveBytes, "application/zip")); }
public async Task <byte[]> GenerateProjectArchiveAsync(GeneratorModel model) { var outFolder = GenerateProject(model); var zipFile = Path.Combine(outFolder, "..", model.ArchiveName); await Task.Run(() => ZipFile.CreateFromDirectory(outFolder, zipFile)); var archiveBytes = await System.IO.File.ReadAllBytesAsync(zipFile); await Task.Run(() => Delete(outFolder, zipFile)); return(archiveBytes); }
public List <KeyValuePair <string, string> > GenerateProjectFiles(GeneratorModel model) { var listOfFiles = new List <KeyValuePair <string, string> >(); var outFolder = GenerateProject(model); foreach (var file in Directory.EnumerateFiles(outFolder, "*", SearchOption.AllDirectories)) { var pathPrefix = file.Replace(Path.GetFullPath(outFolder), string.Empty).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); string fileText = File.ReadAllText(file); listOfFiles.Add(new KeyValuePair <string, string>(pathPrefix, fileText)); } return(listOfFiles); }
public ActionResult SelectNumberOfQuestions(FormCollection form) { if (Session["USER"] != null) { if (lecturer.Priority >= 7) { GeneratorModel generator = Session["Generator"] as GeneratorModel; generator.TestType = form["TestType"].ToString(); Session["Generator"] = generator; return(View()); } } return(RedirectToAction("Index", "Home")); }
private void GenUniformService(GeneratorModel generator, DatabaseServiceModel databaseService) { string folderpath = $"CreatedFile{FolderSymbol}Service{FolderSymbol}"; if (!string.IsNullOrWhiteSpace(databaseService.FolderGroupName)) { folderpath += $"{databaseService.FolderGroupName}{FolderSymbol}"; } Directory.CreateDirectory(folderpath); var serviceFile = File.CreateText($"{folderpath}{generator.UniformServiceName}Service.{databaseService.ServiceName}.cs"); var serviceGeneration = EFCoreServiceInOneGeneration.CreatEFCoreDefaultService(databaseService, generator); serviceGeneration.WriteTo(serviceFile); serviceFile.Close(); }
public ActionResult FinishUp(FormCollection form) { //QuestionsSelectionModel obj = new QuestionsSelectionModel(); if (Session["USER"] != null) { if (lecturer.Priority >= 7) { GeneratorModel generator = Session["Generator"] as GeneratorModel; generator.lecturerName = lecturer.Username; List <OutcomesCollectionModel> outcomeCollection = new List <OutcomesCollectionModel>(); int[] numberOfQuestionsPerQuestion = new int[generator.NumberOfQuestions]; for (int i = 0; i < generator.NumberOfQuestions; i++) { List <string> outcomes = new List <string>(); numberOfQuestionsPerQuestion[i] = int.Parse(form["NumberOFQuestionsPerQuestion " + i].ToString()); List <OutcomeDetailsModel> outcomesList = OutcomeDetailsModel.GetOutcomeDetails(null, null); outcomes.Add(form["OutcomeChoosen" + i].ToString()); outcomeCollection.Add(new OutcomesCollectionModel(i, generator.TypesOfQuestions[i], outcomes)); } generator.outcomesForWhere = outcomeCollection; generator.NumberOfQuestionsPerQuestion = numberOfQuestionsPerQuestion; generator.CreateExam(); Session["Generator"] = generator; return(RedirectToAction("Create", "Generator")); } } return(RedirectToAction("Index", "Home")); }
public List <KeyValuePair <string, string> > GenerateProjectFiles(GeneratorModel model) { var name = string.IsNullOrEmpty(model.TemplateShortName) ? DefaultTemplateName : model.TemplateShortName; var templatePath = _templatePath + Path.DirectorySeparatorChar + name; if (!Directory.Exists(templatePath)) { throw new InvalidDataException("Template with $name doesnt exist"); } var dataView = _mustacheConfig.GetDataView(templatePath, model); var listOfFiles = new List <KeyValuePair <string, string> >(); foreach (var file in _mustacheConfig.GetFilteredSourceSets(dataView, templatePath)) { if (file.EndsWith("mustache.json") || file.EndsWith("sourceExclusions.json")) { continue; } var pathPrefix = file.Replace(Path.GetFullPath(templatePath), string.Empty) .TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); string fileText = File.ReadAllText(file); if (file.EndsWith(".csproj")) { pathPrefix = pathPrefix.Replace("ReplaceMe", model.ProjectName ?? "SteeltoeExample"); // get from model var output = Render(file, fileText, dataView); listOfFiles.Add(new KeyValuePair <string, string>(pathPrefix, output)); } else { var output = Render(file, fileText, dataView); listOfFiles.Add(new KeyValuePair <string, string>(pathPrefix, output)); } } return(listOfFiles); }
public ActionResult SelectTestNumber(FormCollection form) { if (Session["USER"] != null) { if (lecturer.Priority >= 7) { string Subject = form["Subject"].ToString(); HttpCookie SubjectChoosen = new HttpCookie("SubjectChoosen", Subject); Response.Cookies.Add(SubjectChoosen); List <string> where = new List <string>() { "name = " + "'" + form["Subject"].ToString() + "'" }; List <SubjectModel> SubjectList = SubjectModel.GetSubject(null, where); SubjectModel subject = new SubjectModel(); if (SubjectList.Count == 1) { foreach (SubjectModel item in SubjectList) { subject = item; } } else { throw new CustomException.CustomException("Something Went Wrong"); } GeneratorModel generator = Session["Generator"] as GeneratorModel; generator.Subject = subject; Session["Generator"] = generator; return(View(subject)); } } return(RedirectToAction("Index", "Home")); }
private GeneratorModel GenerateItems(long userId) { long languageFromId = WebSettingsConfig.Instance.GetLanguageFromId(); long languageToId = WebSettingsConfig.Instance.GetLanguageToId(); var knowledgeGeneratorQuery = new KnowledgeGeneratorQuery(userId, languageFromId, languageToId); Dictionary <KnowledgeDataType, List <GeneratedKnowledgeItem> > generatedItems = knowledgeGeneratorQuery.Generate(new Dictionary <KnowledgeDataType, int> { { KnowledgeDataType.WordTranslation, 30 }, { KnowledgeDataType.PhraseTranslation, 15 }, { KnowledgeDataType.SentenceTranslation, 5 } }); string userKey = GetUserKey(userId); WriteItemsToTempData(userKey, generatedItems); var result = new GeneratorModel(ControllerContext, generatedItems); return(result); }
public async void PostStarterZipTest() { var model = new GeneratorModel() { Dependencies = "Actuator,MySql", Description = "TestDescription", ProjectName = "TestCompany.TestProject", SteeltoeVersion = "2.2.0", TargetFrameworkVersion = "netcoreapp2.2", TemplateShortName = "Steeltoe-WebApi", TemplateVersion = TemplateVersion.V2, }; var props = model.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); var kvps = props.Select(prop => new KeyValuePair <string, string>(prop.Name, prop.GetValue(model).ToString())).ToArray(); var formContent = new FormUrlEncodedContent(kvps); var result = await _client.PostAsync("https://localhost/starter.zip", formContent); Assert.Equal(HttpStatusCode.OK, result.StatusCode); Dictionary <string, string> files = new Dictionary <string, string>(); using (var stream = await result.Content.ReadAsStreamAsync()) { using (ZipArchive archive = new ZipArchive(stream, ZipArchiveMode.Read)) { foreach (var entry in archive.Entries) { var fileStream = entry.Open(); files.Add(entry.Name, new StreamReader(fileStream).ReadToEnd()); } } } Assert.True(files.Count > 0); Assert.Contains("Program.cs", files.Keys); Assert.Contains("TestCompany.TestProject", files["Program.cs"]); }
static void Main(string[] args) { var applicationDbName = "ApplicationDbContext"; var namespace_string = "WebApi"; var usingList = new List <string>(); usingList.Add(new string("WebApiModel")); usingList.Add(new string("WebApi.Database")); DatabaseServiceModel databaseService = new DatabaseServiceModel("DbGenerationModel", "MyDbs", usingList); var db_List = new List <DatabaseServiceModel>(); db_List.Add(databaseService); GeneratorModel generator = new GeneratorModel(applicationDbName, namespace_string, db_List); Generation generation = new Generation(); generation.Execute(generator, false); //GenDB(generator); //foreach (var item in db_List) //{ // GenService(generator, item); //} }
public GeneratorViewModel() { Model = new GeneratorModel(); Model.BrowseCommand = new RelayCommand <object>(BrowseExecute); Model.RunCommand = new RelayCommand <object>(RunExecute, RunCanExecute); Model.SortCommand = new RelayCommand <string>(SortExecute); Model.ToListCommand = new RelayCommand <object>(ToListExecute, RunCanExecute); #if DEBUG var path = "../../../"; #else var path = "../"; #endif var i18nFolder = new Uri(new Uri(AppDomain.CurrentDomain.BaseDirectory), path).LocalPath; Model.OutputFolder = i18nFolder; // wrapped cultures in a CollectionViewSource for sorting LoadCultures(); Model.Cultures.Source = Model.ObsCultures; SortExecute("Code"); }