DokumentListe

using System.ComponentModel.DataAnnotations;
using FMH.Komponente.Basis.Ui.Validation.DataAnnotation;
using FMH.Komponente.FileUpload.Models;
using FMH.Komponente.Infrastruktur;

namespace FMH.Komponente.WebUI.Areas.FileUpload.Models
{
    public class DokumentListeStandardBeispielViewModel
    {
        // Das Feld ist vom Typ DokumentListeViewModel — anders als beim Template IFormFile gehört
        // hier keine eigene Id-Liste ins ViewModel: DokumentIds und DokumentLoeschenIds stecken im
        // DokumentListeViewModel und werden vom Template selbst als versteckte Felder gerendert.
        [UIHint("DokumentListe")]
        [Display(Name = "Kursbelege <strong>hochladen</strong>")]
        [DisplaySupportsHtml]
        [HelpText(Name = "Erlaubt sind PDF- und JPG-Dateien bis 1 MB.")]
        [AdditionalMetadata(MvcConst.MetaDataUploadUrl, "/FileUpload/DokumentListeStandardBeispiel/Upload")]
        [AdditionalMetadata(MvcConst.MaxFileSizeInMb, "1")]
        [AdditionalMetadata(MvcConst.MaxFiles, "10")]
        [AdditionalMetadata(MvcConst.FilenameMaxLength, "50")]
        [AdditionalMetadata(MvcConst.MetaDataAllowedFiles, ".pdf, .jpg, .jpeg")]
        [AdditionalMetadata(MvcConst.MetaDataDownloadActionName, "Download")]
        [AdditionalMetadata(MvcConst.MetaDataDownloadControllerName, "DokumentListeStandardBeispiel")]
        public DokumentListeViewModel KursBelege { get; set; } = new DokumentListeViewModel();
    }
}

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using FMH.Komponente.Basis.Erweiterungen;
using FMH.Komponente.Basis.Ui.Feedback.Alert;
using FMH.Komponente.FileUpload.Models;
using FMH.Komponente.WebUI.Areas.FileUpload.Models;
using Microsoft.AspNetCore.Mvc;

namespace FMH.Komponente.WebUI.Areas.FileUpload.Controllers.Beispiele
{
    // Ein Beispiel, ein Controller: Upload-Endpunkt, Download-Endpunkt, Ablage und der
    // Formular-Round-Trip stehen vollständig in dieser Datei — der Grundfall lässt sich damit ohne
    // Sprünge nachlesen.
    [Area("FileUpload")]
    public class DokumentListeStandardBeispielController : Controller
    {
        // Ablage der Demo: In einem Projekt landen die Dateien in der Datenbank oder im
        // Dokumentenspeicher; hier genügt der Dateiname je vergebener Id. Statisch und damit
        // prozessweit, weil die Demo keine Sitzung kennt.
        private static readonly ConcurrentDictionary<int, string> Dokumente =
            new ConcurrentDictionary<int, string>(
                new Dictionary<int, string> { [5] = "Kurs.pdf", [6] = "Kurs2.pdf" });

        private static int letzteId = 100;

        // Baut das Modell für die Anzeige: die bereits zugeordneten Dokumente kommen als
        // DokumentEintrag-Liste in das DokumentListeViewModel.
        // Auch die Doku-Seite zeigt die gefüllte Liste — deshalb öffentlich.
        public static DokumentListeStandardBeispielViewModel ErstelleModell()
        {
            var modell = new DokumentListeStandardBeispielViewModel();

            modell.KursBelege.Dokumente = Dokumente
                .OrderBy(eintrag => eintrag.Key)
                .Select(eintrag => new DokumentEintrag
                                   {
                                       DokumentEintragId = eintrag.Key,
                                       Name = eintrag.Value,
                                       Groesse = 30000 + (eintrag.Key * 100),
                                   })
                .ToList();

            return modell;
        }

        [HttpGet]
        public IActionResult Index()
        {
            return this.View(ErstelleModell());
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public IActionResult Index(DokumentListeStandardBeispielViewModel modell)
        {
            // Die Dateien sind zu diesem Zeitpunkt längst übertragen; das Formular bringt nur noch
            // die Ids mit: DokumentIds die neu hochgeladenen, DokumentLoeschenIds die zum Löschen
            // markierten. Das endgültige Löschen ist Sache dieser Action.
            // PRG-Pattern (Post-Redirect-Get): Meldung merken und per Redirect auf die GET-Action.
            this.AddAlert(
                $"Formular übertragen – {BeschreibeAenderungen(modell.KursBelege)}",
                AlertType.Success,
                autoHide: true);

            return this.RedirectToAction(nameof(this.Index));
        }

        /// <summary>
        /// Der Upload-Endpunkt dieses Beispiels; seine Adresse steht als
        /// <see cref="FMH.Komponente.Infrastruktur.MvcConst.MetaDataUploadUrl" /> am ViewModel.
        /// Die Dropzone schickt jede Datei einzeln hierher, sobald der Dialog bestätigt wurde.
        /// Antwort muss ein Json mit der Eigenschaft <c>id</c> sein — das Template legt daraus ein
        /// verstecktes Feld <c>DokumentIds</c> im Formular an. Fehlt die Id, lädt die Seite neu.
        /// </summary>
        /// <returns>Json mit der vergebenen Id.</returns>
        [HttpPost]
        public IActionResult Upload()
        {
            // Die Dropzone meldet sich mit diesem Kopfzeilen-Eintrag. In einem Projekt lässt sich
            // daran ein normaler Formular-Post von einem Dropzone-Upload unterscheiden.
            if (this.Request.Headers.ContainsKey("IsDropzoneRequest") == false || this.Request.Form.Files.Count == 0)
            {
                return this.Json(new { id = 0 });
            }

            var datei = this.Request.Form.Files[0];

            // Der im Dialog erfasste Dateiname kommt als eigenes Formularfeld mit, der Inhalt als Datei.
            var bezeichnung = this.Request.Form["DateiBezeichnung"].ToString();
            var name = string.IsNullOrWhiteSpace(bezeichnung) ? datei.FileName : bezeichnung;

            var id = Interlocked.Increment(ref letzteId);
            Dokumente[id] = name;

            return this.Json(new { id });
        }

        /// <summary>
        /// Der Download-Endpunkt: Action- und Controller-Name stehen als
        /// <see cref="FMH.Komponente.Infrastruktur.MvcConst.MetaDataDownloadActionName" /> bzw.
        /// <see cref="FMH.Komponente.Infrastruktur.MvcConst.MetaDataDownloadControllerName" /> am
        /// ViewModel; das Template baut daraus je Tabellenzeile einen Link mit der Dokument-Id.
        /// </summary>
        /// <param name="id">Die Id des Dokuments aus der Tabellenzeile.</param>
        /// <returns>Die Datei zum Herunterladen.</returns>
        [HttpGet]
        public IActionResult Download(int id)
        {
            if (Dokumente.TryGetValue(id, out var name) == false)
            {
                return this.NotFound();
            }

            // Die Demo speichert keine Inhalte, sondern gibt einen Platzhalter zurück – der Link in
            // der Tabelle soll trotzdem eine echte Datei liefern.
            var inhalt = Encoding.UTF8.GetBytes($"Platzhalter-Inhalt für «{name}» (Id {id}).");

            return this.File(inhalt, "text/plain", name);
        }

        // Nur für die Rückmeldung: macht aus den Ids wieder die Dateinamen.
        private static string BeschreibeAenderungen(DokumentListeViewModel liste)
        {
            var teile = new List<string>();

            if (liste.DokumentIds != null && liste.DokumentIds.Length > 0)
            {
                teile.Add($"neu: {string.Join(", ", liste.DokumentIds.Select(NameZuId))}");
            }

            if (liste.DokumentLoeschenIds != null && liste.DokumentLoeschenIds.Length > 0)
            {
                teile.Add($"zum Löschen markiert: {string.Join(", ", liste.DokumentLoeschenIds.Select(NameZuId))}");
            }

            return teile.Count == 0 ? "keine Änderungen." : string.Join(" | ", teile);
        }

        private static string NameZuId(int id)
        {
            return Dokumente.TryGetValue(id, out var name) ? name : $"Id {id}";
        }
    }
}