public ActionResult Generate(GeneratorViewModel model)
{
if (!Services.Authorizer.Authorize(Permissions.GenerateModule, T("Not allowed to generate module")))
{
return(new HttpUnauthorizedResult());
}
Module module = new Module
{
ModuleName = model.ModuleName,
Guid = Guid.NewGuid().ToString(),
Entities = (from c in model.ContentTypes
where c.Selected
select new Entity
{
TypeName = c.Name,
DisplayName = c.Name,
Properties = GetContentTypeDefinition(c.Name)
}).ToList()
};
bool result = _moduleGeneratorService.GenerateModule(model.TemplateName, module);
ViewBag.Success = result;
return(View(module));
}
public Generator()
{
_context = new GeneratorViewModel {
DatabaseConnections = new ObservableCollection <DatabaseConnection>()
};
DataContext = _context;
InitializeComponent();
}
public MainWindow()
{
InitializeComponent();
DataContext = new GeneratorViewModel();
var name2path = Model.Helper.GetFontPairs();
foreach (var n2p in name2path)
{
fontPathes.Items.Add(n2p);
}
}
private void ViewItem()
{
if (SelectedInventoryItem != null)
{
SelectedInventoryItem.ItemSaving += InventoryItem_ItemSaved;
if (SelectedInventoryItem.ConcreteType == typeof(ReconstitutedColdKit))
{
ReconstitutedColdKitViewModel vm = new ReconstitutedColdKitViewModel((DataStoreItem)SelectedInventoryItem);
DesktopApplication.MakeModalDocument(vm);
}
else if (SelectedInventoryItem.ConcreteType == typeof(Elution))
{
ElutionViewModel dvm = new ElutionViewModel((DataStoreItem)SelectedInventoryItem);
DesktopApplication.MakeModalDocument(dvm);
}
else if (SelectedInventoryItem.ConcreteType == typeof(SplitUnitDose))
{
SplitUnitDoseViewModel dvm = new SplitUnitDoseViewModel((DataStoreItem)SelectedInventoryItem);
DesktopApplication.MakeModalDocument(dvm);
}
else if (SelectedInventoryItem.ConcreteType == typeof(SyringeUnitDose))
{
SyringeUnitDoseViewModel dvm = new SyringeUnitDoseViewModel((DataStoreItem)SelectedInventoryItem);
DesktopApplication.MakeModalDocument(dvm);
}
else if (SelectedInventoryItem.ConcreteType == typeof(Generator))
{
GeneratorViewModel dvm = new GeneratorViewModel((DataStoreItem)SelectedInventoryItem);
DesktopApplication.MakeModalDocument(dvm);
}
else if (SelectedInventoryItem.ConcreteType == typeof(Kit))
{
DataStoreItemViewModel dvm = new DataStoreItemViewModel((DataStoreItem)SelectedInventoryItem);
DesktopApplication.MakeModalDocument(dvm);
}
else if (SelectedInventoryItem.ConcreteType == typeof(ReconstitutedColdKit))
{
DataStoreItemViewModel dvm = new DataStoreItemViewModel((DataStoreItem)SelectedInventoryItem);
DesktopApplication.MakeModalDocument(dvm);
}
else if (SelectedInventoryItem.ConcreteType == typeof(CapsuleUnitDose))
{
CapsuleUnitDoseViewModel dvm = new CapsuleUnitDoseViewModel((DataStoreItem)SelectedInventoryItem);
DesktopApplication.MakeModalDocument(dvm);
}
}
else
{
DesktopApplication.ShowDialog("Debug", "SelectedInventoryItem is null");
}
}
public IActionResult Generate([FromBody] GeneratorViewModel generatorViewModel)
{
using (var reader = new StringReader(generatorViewModel.ProtoContent))
{
var set = new FileDescriptorSet
{
ImportValidator = path => ValidateImport(path),
};
set.AddImportPath(Path.Combine(_host.WebRootPath, "protoc"));
set.Add("my.proto", true, reader);
set.Process();
var errors = set.GetErrors();
if (errors.Length != 0)
{
//code parsing is supposed to happening client side, so we don't send error here
return(BadRequest());
}
if (generatorViewModel.IsProtobugGen())
{
return(Ok(
generatorViewModel
.GetCodeGenerator()
.Generate(set, generatorViewModel.GetNameNormalizerForConvention(),
generatorViewModel.GetOptions())
.ToList()));
}
// we're going to offer protoc! hold me...
if (generatorViewModel.ProtoContent.Contains("import"))
{
// code output disabled because of import
return(BadRequest());
}
else
{
var files = RunProtoc(_host,
generatorViewModel.ProtoContent,
generatorViewModel.GetProtocTooling(),
out var stdout,
out var stderr,
out var exitCode);
if (exitCode != 0)
{
return(base.StatusCode(500, new { stderr, stdout, exitCode }));
}
return(Ok(files));
}
}
}
public IActionResult Generate([FromBody] GeneratorViewModel generatorViewModel)
{
using var reader = new StringReader(generatorViewModel.ProtoContent);
var set = new FileDescriptorSet
{
ImportValidator = path => ValidateImport(path),
};
set.AddImportPath(Path.Combine(_host.WebRootPath, "protoc"));
set.Add("my.proto", true, reader);
set.Process();
var errors = set.GetErrors();
if (errors.Length != 0)
{
//code parsing is supposed to happening client side, so we don't send error here
return(BadRequest());
}
if (generatorViewModel.IsProtogen())
{
return(Ok(
generatorViewModel
.GetCodeGenerator()
.Generate(set, generatorViewModel.GetNameNormalizerForConvention(),
generatorViewModel.GetOptions())
.ToList()));
}
// if we got this far, it means that we resolved all the imports, so
// we don't need to worry about protoc going out-of-bounds with external files
// (since we constrain with ValidateImport), so: off to 'protoc' we go!
var files = RunProtoc(_host,
generatorViewModel.ProtoContent,
generatorViewModel.GetProtocTooling(),
out var stdout,
out var stderr,
out var exitCode);
if (exitCode != 0)
{
return(base.StatusCode(500, new { stderr, stdout, exitCode }));
}
return(Ok(files));
}
public ActionResult Index()
{
if (!Services.Authorizer.Authorize(Permissions.GenerateModule, T("Not allowed to generate module")))
{
return(new HttpUnauthorizedResult());
}
var model = new GeneratorViewModel
{
ContentTypes = (from c in _contentManager.GetContentTypeDefinitions()
select new ContentType
{
Name = c.Name,
DisplayName = c.DisplayName
}).ToList(),
ReferenceTemplates = GetTemplates(),
ModuleTemplatesPathName = ModuleGeneratorService.ModuleTemplatesPathName
};
return(View(model));
}
public IActionResult Random()
{
_database.GetCollection <GeneratorViewModel>("RandomWorkout").DeleteMany(FilterDefinition <GeneratorViewModel> .Empty);
var workoutDb = GetWorkoutDatabase();
var random = new Random();
var r = random.Next(workoutDb.Count());
var generator = new GeneratorViewModel();
try
{
generator.Random_Workout = workoutDb[r];
}
catch
{
return(RedirectToAction("Index"));
}
_database.GetCollection <GeneratorViewModel>("RandomWorkout").InsertOne(generator);
return(RedirectToAction("Index", generator));
}
/// <summary>
/// Refreshes viewmodel if propertyChanged parameter is not null
/// </summary>
/// <param name="model">sender object</param>
/// <param name="propertyChanged">event handler</param>
/// <param name="nameOfField">name of property that is needed to refresh</param>
public static void RefreshViewModel(GeneratorViewModel model, PropertyChangedEventHandler propertyChanged, string nameOfField)
{
//if not null invoke event listener
propertyChanged?.Invoke(model, new PropertyChangedEventArgs(nameOfField));
}
private void GeneratorViewControl_Loaded(object sender, RoutedEventArgs e)
{
ViewModel.GeneratorViewModel generatorViewModel = new GeneratorViewModel();
this.GeneratorViewControl.DataContext = generatorViewModel;
}
private void OnLoaded(object sender, RoutedEventArgs e)
{
var serializer = new XmlSerializer(typeof(MapLayout[]), new XmlRootAttribute("MapLayouts"));
var layouts = serializer.Deserialize(File.OpenRead("MapLayouts.xml")) as MapLayout[];
serializer = new XmlSerializer(typeof(Scenery));
var sceneries = Directory.GetFiles("Sceneries", "*.xml").Select(f =>
{
try
{
return((Scenery)serializer.Deserialize(File.OpenRead(f)));
}
catch
{
return(default(Scenery));
}
});
var processors = MapProcessors.FromXaml(File.OpenRead("Genesis.xaml"));
generator = new GeneratorViewModel(new MapGenerator(processors), layouts, sceneries.ToArray(), logFile);
options = new OptionsViewModel();
try
{
using (var stream = File.OpenRead("Options.xml"))
{
options.ReadXml(stream);
}
}
catch { }
generator.MapNameTemplate = options.MapNameTemplate;
generator.Generator.PreviewGenerator.AddObjects = options.AddObjectsToPreview;
generator.Generating += (s, a) => content.Cursor = Cursors.Wait;
generator.Generated += (s, a) =>
{
content.Cursor = Cursors.Arrow;
log.Focus();
CommandManager.InvalidateRequerySuggested();
};
DataContext = generator;
// We need to wait until the window is fully initialized before we can show a MessageBox.
Dispatcher.BeginInvoke(new Action(() =>
{
if (string.IsNullOrEmpty(options.OutputDirectory))
{
if (ZeroHour.MapsDirectory == null)
{
MessageBox.Show("The location of your Zero Hour data folder could not be determined.\nYou need to set the path manually in the options to be able to save maps.", "Zero Hour Data Folder", MessageBoxButton.OK, MessageBoxImage.Warning);
EditOptions();
}
else
{
generator.OutputPath = ZeroHour.MapsDirectory;
}
}
else
{
generator.OutputPath = options.OutputDirectory;
}
generator.GenerateCommand.Execute(null);
}));
}
public GeneratorPage()
{
InitializeComponent();
BindingContext = viewModel = new GeneratorViewModel();
}
public DatabaseConnectionManager(GeneratorViewModel viewModel)
{
InitializeComponent();
_context = viewModel;
DataContext = _context;
}
public GeneratorOptionsPage(GeneratorViewModel parentViewModel)
{
InitializeComponent();
BindingContext = _viewModel = new GeneratorOptionsViewModel(parentViewModel);
}
public GeneratorView()
{
InitializeComponent();
DataContext = new GeneratorViewModel();
}
