In diesem Kapitel legst du Ressourcen und Stammdaten reproduzierbar aus Code an: ResourceInitializer, ProductImporter und den Factory Monitor mit Ressourcen-Graph.
Bislang hast du Ressourcen, Produkte, Workplans und Recipes in der UI angelegt. Das ist zum Lernen richtig, in einer echten Anwendung willst du denselben Stand aber reproduzierbar aus Code haben (leere Datenbank, neuer Rechner, Schulungslabor). Außerdem ist es für viele Anwendungsentwickler angenehmer, das Nötige über den Code hinzuzufügen.
Genau das machen wir jetzt in diesem Kapitel.
Wir erstellen zwei neue Plugins: ResourceInitializer und ProductImporter.
Der Initializer ist Teil des ResourceManager-Moduls und erzeugt die Tee-Linie (Weighing, Filling, Sealing, Packaging + Instructor + ein Simulated Driver nur für Sealing).
Der Product Importer gehört zum ProductManager und erzeugt die Produkte Sencha, Earl Grey, Chamomile, Green Carton, Sencha 20er (PartLinks), beide Workplans und Default-Recipes.
Darüber hinaus binden wir das Modul Factory Monitor ein, das die Stationen in unserer Fabrik zeigt. Dafür brauchen wir einen Ressourcen-Graphen mit ManufacturingFactory / MachineLocation.
Bevor wir weitermachen, solltest du alle Datenbanken leeren, sonst bleiben alte Zellen und Produkte doppelt.
- Im Command Center unter Databases jeden DB-Kontext öffnen, Erase Database, Create Database. Für alle Kontexte wiederholen.
- Alle Modules reincarnaten oder App schließen und neu starten
- Jetzt sollten alle Produkte, Ressourcen, Workplans, Aufträge usw. in der UI gelöscht sein
Der Monitor hat bisher nicht geladen, weil nur die Web-UI referenziert war, ohne API und ohne Factory-Typen.
Deshalb trägst du die Pakete in TeaFactory.App.csproj ein:
<!-- MORYX FactoryMonitor -->
<PackageReference Include="Moryx.Factory" />
<PackageReference Include="Moryx.FactoryMonitor.Endpoints" />
<PackageReference Include="Moryx.FactoryMonitor.Web" />Datei: Directory.Packages.props:
<!-- MORYX FactoryMonitor -->
<PackageVersion Include="Moryx.Factory" Version="$(MoryxVersion)" />
<PackageVersion Include="Moryx.FactoryMonitor.Endpoints" Version="$(MoryxVersion)" />
<PackageVersion Include="Moryx.FactoryMonitor.Web" Version="$(MoryxVersion)" />Als Nächstes erstellen wir den ResourceInitializer. Er baut den kompletten Resource-Graph per Code auf, dieselbe Struktur, die du sonst in der Resources-UI per Hand anlegst.
Lege die Datei src/TeaFactory.App/TeaFactoryInitializer.cs an und füge folgendes ein. Der Code ist weitgehend selbsterklärend; danach gehen wir die Bausteine noch einmal durch.
[Plugin(LifeCycle.Transient, typeof(IResourceInitializer), Name = nameof(TeaFactoryInitializer))]
[Display(Name = "Tea Factory Initializer", Description = "Creates cells, visual instructor and factory layout.")]
public class TeaFactoryInitializer : ResourceInitializerBase
{
public override string Name => nameof(TeaFactoryInitializer);
public override string Description => "Setup the simulated tea factory resources";
public override Task<ResourceInitializerResult> ExecuteAsync(IResourceGraph graph, object parameters, CancellationToken cancellationToken)
{
var instructor = graph.Instantiate<VisualInstructor>();
instructor.Name = "Visual Instructor";
instructor.Description = "Shared display for weighing, filling, blend change and packaging";
var lineGroup = graph.Instantiate<MachineGroup>();
lineGroup.Name = "Tea Line";
lineGroup.Description = "Weighing, filling, sealing and packaging";
// Manuell: nur VisualInstructor, kein Simulated Driver
var weighingCell = graph.Instantiate<WeighingCell>();
weighingCell.Name = "Weighing Cell";
weighingCell.VisualInstructor = instructor;
weighingCell.Value = 0;
lineGroup.Children.Add(Place(graph, "W-1", "Weighing station", "scale", 0.18, 0.32, weighingCell));
var fillingCell = graph.Instantiate<FillingCell>();
fillingCell.Name = "Filling Cell";
fillingCell.VisualInstructor = instructor;
fillingCell.Blend = TeaBlend.Sencha;
lineGroup.Children.Add(Place(graph, "F-1", "Filling station", "science", 0.42, 0.32, fillingCell));
// Automatisch: nur Sealing bekommt einen Simulated Driver
var sealingDriver = graph.Instantiate<SimulatedSealingDriver>();
sealingDriver.Name = "Sealing Simulated Driver";
var sealingCell = graph.Instantiate<SealingCell>();
sealingCell.Name = "Sealing Cell";
sealingCell.Driver = sealingDriver;
sealingCell.Value = 0;
lineGroup.Children.Add(Place(graph, "S-1", "Sealing station", "precision_manufacturing", 0.66, 0.32, sealingCell));
var packagingCell = graph.Instantiate<PackagingCell>();
packagingCell.Name = "Packaging Cell";
packagingCell.VisualInstructor = instructor;
lineGroup.Children.Add(Place(graph, "P-1", "Packaging workplace", "inventory_2", 0.42, 0.68, packagingCell));
var factory = graph.Instantiate<ManufacturingFactory>();
factory.Name = "Tea Manufactory";
factory.Description = "Simulated tea bag production and retail packing";
factory.Children.Add(instructor);
factory.Children.Add(lineGroup);
factory.Children.Add(sealingDriver);
return Task.FromResult(new ResourceInitializerResult
{
InitializedResources = [factory],
Saved = false
});
}
private static MachineLocation Place(IResourceGraph graph, string name, string description, string icon, double x, double y, Resource cell)
{
var location = graph.Instantiate<MachineLocation>();
location.Name = name;
location.Description = description;
location.SpecificIcon = icon;
location.PositionX = x;
location.PositionY = y;
location.Children.Add(cell);
return location;
}
}Der ResourceInitializer ist ein Plugin, das du einmal in der ResourceManager-Console ausführst. Er baut den kompletten Resource-Graph per Code auf.
| Baustein | Rolle |
|---|---|
IResourceGraph graph |
API zum Erzeugen von Resources im Graph |
graph.Instantiate<T>() |
Legt eine Resource vom Typ T an (Zelle, Driver, Gruppe, ...) |
[ResourceReference]-Properties |
Verdrahtung zwischen Resources (VisualInstructor, Driver), wie in der UI |
MachineGroup |
Logische Gruppe (hier: „Tea Line“), ordnet Zellen zusammen |
MachineLocation |
Platz auf dem Factory-Monitor: Name, Icon, Position (PositionX/PositionY 0...1), enthält die Zelle als Kind |
ManufacturingFactory |
Wurzel der Fabrik, alles andere hängt darunter |
Place(...) |
Hilfsmethode: erzeugt MachineLocation + setzt Layout, gibt Location zurück |
Children.Add(...) |
Hängt Kind-Ressourcen in den Baum |
Saved = false |
ResourceManager speichert den Graph selbst; du gibst nur die Wurzel zurück |
- Command Center, ResourceManager, Console: Initialize Resource. Unter configs eine ResourceInitializerConfig hinzufügen,
TeaFactoryInitializerwählen, Invoke. - Module Overview: ResourceManager reincarnaten
Jetzt solltest du alle im Code angelegten Ressourcen in der Resources-UI sehen können.
Im Factory Monitor solltest du jetzt die Teefabrik mit vier Locations (W-1, F-1, S-1, P-1) an den PositionX/PositionY-Koordinaten sehen.
Optional kannst du das Hintergrundbild austauschen und die Stationen darauf ausrichten bzw. verschieben.
- Media-Modul öffnen (Launcher).
- Bild hochladen (z. B. Skizze der Tee-Linie mit vier Stationen).
- Auf das Bild klicken, Rechtsklick, Info (oder Details), Media-URL in die Zwischenablage kopieren. Typisches Format:
/api/moryx/media/{guid}/master/stream - Factory Monitor öffnen, Bearbeiten-Symbol klicken
- Property BackgroundUrl: kopierte URL einfügen und speichern.
- Die MachineLocations (W-1, F-1, S-1, P-1) per Drag oder
PositionX/PositionY(0...1) auf die passenden Stellen auf dem Bild verschieben.
Die Icons liegen dann über dem Hintergrund. Das ist reine Optik, die Produktion läuft unverändert.
Der CLI-Stub TeaFactoryProductImporter war bislang leer. Jetzt erzeugt er Objekte und speichert sie selbst (Saved = true), weil Workplans über IWorkplans und Recipes über IProductStorage persistiert werden, nicht nur ProductTypes.
Reihenfolge: Teile zuerst (Beutel, Karton), dann Retail Pack (PartLinks), dann Workplans, dann Recipes (brauchen Produkt + Workplan).
Der ProductImporter ist ein Plugin für den ProductManager. Du startest ihn in der Products-UI über Import. Er legt Stammdaten per Code an: reproduzierbar, statt fünf Produkte und zwei Workplans per Hand.
| Baustein | Rolle |
|---|---|
[ProductImporter] |
Meldet die Klasse als Importer beim ProductManager an |
TeaFactoryImportParameters |
Felder im Import-Dialog (PackQuantity wird zur Quantity am TeaBagPartLink) |
IProductStorage |
Speichert ProductTypes und Recipes |
IWorkplans |
Speichert Workplans |
Saved = true |
Importer persistiert selbst (anders als Initializer mit Saved = false) |
| Reihenfolge | Teile zuerst (Beutel, Karton), dann Retail Pack (PartLinks), dann Workplans, dann Recipes |
| Materialnummer | Name | Typ |
|---|---|---|
100001 |
Sencha Classic | TeaBag, Sencha, 2,5 g |
100002 |
Earl Grey | TeaBag, EarlGrey, 2,5 g |
100003 |
Chamomile Classic | TeaBag, Chamomile, 3,5 g |
200001 |
Green Tea Carton | Zukauf-Schachtel |
300001 |
Sencha 20er | Retail Pack: N× Sencha + 1× Karton |
Workplans: Tea bag production (Weighing, Filling, Sealing) | Retail packing (Packaging)
Recipes: Default-Recipe für alle drei Beutel + eines für das Retail Pack (4 Stück)
Pfad: src/TeaFactory.Products/Importer/TeaFactoryImportParameters.cs
Die Parameter erscheinen im Import-Dialog, hier steuerst du die Packungsmenge:
[DataContract]
public class TeaFactoryImportParameters
{
[DataMember]
[Description("How many tea bags go into one retail pack")]
public int PackQuantity { get; set; } = 20;
}Pfad: src/TeaFactory.Products/Importer/TeaFactoryProductImporterConfig.cs
Die Config verbindet den Importer mit dem ProductManager:
public class TeaFactoryProductImporterConfig : ProductImporterConfig
{
public override string PluginName => nameof(TeaFactoryProductImporter);
}Pfad: src/TeaFactory.Products/Importer/TeaFactoryProductImporter.cs
Hier entsteht der komplette Stammdaten-Seed: Produkte speichern, Workplans anlegen, Default-Recipes verdrahten:
[ExpectedConfig(typeof(TeaFactoryProductImporterConfig))]
[ProductImporter(nameof(TeaFactoryProductImporter))]
public class TeaFactoryProductImporter : ProductImporterBase<TeaFactoryProductImporterConfig, TeaFactoryImportParameters>, ILoggingComponent
{
public IModuleLogger Logger { get; set; }
public IProductStorage Storage { get; set; }
public IWorkplans WorkplanStorage { get; set; }
protected override async Task<ProductImporterResult> ImportAsync(ProductImportContext context, TeaFactoryImportParameters parameters, CancellationToken cancellationToken)
{
var quantity = parameters.PackQuantity > 0 ? parameters.PackQuantity : 20;
var sencha = CreateTeaBag("100001", 1, "Sencha Classic", TeaBlend.Sencha, 2.5);
var earlGrey = CreateTeaBag("100002", 1, "Earl Grey", TeaBlend.EarlGrey, 2.5);
var chamomile = CreateTeaBag("100003", 1, "Chamomile Classic", TeaBlend.Chamomile, 3.5);
var greenCarton = CreateCarton("200001", 1, "Green Tea Carton", CartonColor.Green);
var senchaPack = CreateRetailPack("300001", 1, "Sencha 20er", sencha, quantity, greenCarton);
await Storage.SaveTypeAsync(sencha, cancellationToken);
await Storage.SaveTypeAsync(earlGrey, cancellationToken);
await Storage.SaveTypeAsync(chamomile, cancellationToken);
await Storage.SaveTypeAsync(greenCarton, cancellationToken);
await Storage.SaveTypeAsync(senchaPack, cancellationToken);
var bagWorkplan = CreateTeaBagWorkplan();
var packWorkplan = CreatePackagingWorkplan();
await WorkplanStorage.SaveWorkplanAsync(bagWorkplan, cancellationToken);
await WorkplanStorage.SaveWorkplanAsync(packWorkplan, cancellationToken);
await Storage.SaveRecipeAsync(CreateRecipe("Tea bag production", sencha, bagWorkplan), cancellationToken);
await Storage.SaveRecipeAsync(CreateRecipe("Tea bag production", earlGrey, bagWorkplan), cancellationToken);
await Storage.SaveRecipeAsync(CreateRecipe("Tea bag production", chamomile, bagWorkplan), cancellationToken);
await Storage.SaveRecipeAsync(CreateRecipe("Retail packing", senchaPack, packWorkplan), cancellationToken);
return new ProductImporterResult { Saved = true };
}
private static TeaBagType CreateTeaBag(string materialNumber, short revision, string name, TeaBlend blend, double targetWeightGrams)
{
return new TeaBagType
{
Identity = new ProductIdentity(materialNumber, revision),
Name = name,
Blend = blend,
TargetWeightGrams = targetWeightGrams
};
}
private static TeaCartonType CreateCarton(string materialNumber, short revision, string name, CartonColor color)
{
return new TeaCartonType
{
Identity = new ProductIdentity(materialNumber, revision),
Name = name,
Color = color
};
}
private static TeaRetailPackType CreateRetailPack(string materialNumber, short revision, string name, TeaBagType bag, int quantity, TeaCartonType carton)
{
return new TeaRetailPackType
{
Identity = new ProductIdentity(materialNumber, revision),
Name = name,
TeaBag = new TeaBagPartLink { Product = bag, Quantity = quantity },
Carton = new ProductPartLink<TeaCartonType> { Product = carton }
};
}
private static ProductionRecipe CreateRecipe(string name, ProductType product, Workplan workplan)
{
return new ProductionRecipe
{
Name = name,
Product = product,
Workplan = workplan,
Classification = RecipeClassification.Default,
State = RecipeState.Released
};
}
private static Workplan CreateTeaBagWorkplan()
{
var workplan = new Workplan
{
Name = "Tea bag production (Imported)",
State = WorkplanState.Released
};
var start = workplan.AddConnector("Start", NodeClassification.Start);
var weighed = workplan.AddConnector("Weighed", NodeClassification.Intermediate);
var filled = workplan.AddConnector("Filled", NodeClassification.Intermediate);
var end = workplan.AddConnector("End", NodeClassification.End);
var failed = workplan.AddConnector("Failed", NodeClassification.Failed);
workplan.AddStep(new WeighingTask(), new WeighingParameters
{
Instructions =
[
new VisualInstruction
{
Type = InstructionContentType.Text,
Content = "Weigh the tea blend, then confirm SUCCESS or FAILED."
}
]
}, start, weighed, failed);
workplan.AddStep(new FillingTask(), new FillingParameters
{
Instructions =
[
new VisualInstruction
{
Type = InstructionContentType.Text,
Content = "Fill the tea bag with the required blend, then confirm SUCCESS."
}
]
}, weighed, filled, failed);
workplan.AddStep(new SealingTask(), new SealingParameters(), filled, end, failed);
return workplan;
}
private static Workplan CreatePackagingWorkplan()
{
var workplan = new Workplan
{
Name = "Retail packing (Imported)",
State = WorkplanState.Released
};
var start = workplan.AddConnector("Start", NodeClassification.Start);
var end = workplan.AddConnector("End", NodeClassification.End);
var failed = workplan.AddConnector("Failed", NodeClassification.Failed);
workplan.AddStep(new PackagingTask(), new PackagingParameters(), start, end, failed);
return workplan;
}
}- ProductManager, CONFIGURATION, Importers: Plugin-Typ TeaFactoryProductImporterConfig hinzufügen (+)
- SAVE + RESTART
- Products-UI öffnen, Import (nicht „New Product“).
- Importer TeaFactoryProductImporter wählen.
PackQuantityz. B. 20 lassen und Import starten.- Erwartung: fünf Produkte, zwei Workplans, vier Default-Recipes.
Die UI ist der Editor. Initializer und Importer sind der Seed, so setzt ein Application Developer eine Fabrik auf, die jeder reproduzieren kann.
- Datenbanken geleert und Module neu gestartet
- Factory-Monitor-Pakete in
csprojundDirectory.Packages.propseingetragen -
TeaFactoryInitializerangelegt und über die ResourceManager-Console ausgeführt - Resources-UI und Factory Monitor zeigen W-1, F-1, S-1, P-1
- ProductImporter-Dateien angelegt und Importer in der Config eingetragen
- Import ausgeführt: fünf Produkte, zwei Workplans, vier Default-Recipes