Skip to content

Latest commit

 

History

History
412 lines (315 loc) · 18.4 KB

chapter-09-initializer-importer.md

File metadata and controls

412 lines (315 loc) · 18.4 KB

Kapitel 9 - Fabrik aus Code - Initializer, Importer, Factory Monitor

In diesem Kapitel legst du Ressourcen und Stammdaten reproduzierbar aus Code an: ResourceInitializer, ProductImporter und den Factory Monitor mit Ressourcen-Graph.

Inhaltsverzeichnis | Vorheriges | Nächstes

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.

Datenbanken leeren

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

Screenshot

Screenshot

Factory Monitor Pakete

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)" />

ResourceInitializer

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

Erklärung

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

Config: Initializer eintragen (Command Center)

  1. Command Center, ResourceManager, Console: Initialize Resource. Unter configs eine ResourceInitializerConfig hinzufügen, TeaFactoryInitializer wählen, Invoke.
  2. Module Overview: ResourceManager reincarnaten

Screenshot

Jetzt solltest du alle im Code angelegten Ressourcen in der Resources-UI sehen können.

Screenshot

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: Hintergrundbild im FactoryMonitor ändern

Optional kannst du das Hintergrundbild austauschen und die Stationen darauf ausrichten bzw. verschieben.

  1. Media-Modul öffnen (Launcher).
  2. Bild hochladen (z. B. Skizze der Tee-Linie mit vier Stationen).
  3. Auf das Bild klicken, Rechtsklick, Info (oder Details), Media-URL in die Zwischenablage kopieren. Typisches Format: /api/moryx/media/{guid}/master/stream
  4. Factory Monitor öffnen, Bearbeiten-Symbol klicken
  5. Property BackgroundUrl: kopierte URL einfügen und speichern.
  6. 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.

ProductImporter (Produkte, Workplans, Recipes)

Konzept

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

Angelegte Stammdaten

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)

TeaFactoryImportParameters.cs

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

TeaFactoryProductImporterConfig.cs

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

TeaFactoryProductImporter.cs

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

Config: Importer eintragen (Command Center)

  1. ProductManager, CONFIGURATION, Importers: Plugin-Typ TeaFactoryProductImporterConfig hinzufügen (+)
  2. SAVE + RESTART

Screenshot

Ausführen

  1. Products-UI öffnen, Import (nicht „New Product“).
  2. Importer TeaFactoryProductImporter wählen.
  3. PackQuantity z. B. 20 lassen und Import starten.
  4. Erwartung: fünf Produkte, zwei Workplans, vier Default-Recipes.

Screenshot

Die UI ist der Editor. Initializer und Importer sind der Seed, so setzt ein Application Developer eine Fabrik auf, die jeder reproduzieren kann.

Checkliste

  • Datenbanken geleert und Module neu gestartet
  • Factory-Monitor-Pakete in csproj und Directory.Packages.props eingetragen
  • TeaFactoryInitializer angelegt 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