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");
}
