Neuen Repository-Eintrag aus einem Stream anlegen

Deutschsprachiges Forum
1

Hi,

ich erzeuge on-the-fly eine LST-Datei. Bisher habe ich diese gespeichert und konnte sie ins Repository importieren. Das Vorgehen hat viele Nachteile mit sich gebracht (langsam, weil Schreiben ins Netzwerk; fehleranfällig, wegen Zugriffsproblemen). Hinzukommt, dass diese Methode bei einer Webanwendung so nicht mehr durchführbar ist.

Meine Idee war, dass ich den MemoryStream direkt ins Repository schreiben könnte. Leider finde ich nicht die geeigneten Klassen und Methoden, um diese Aufgabe zu lösen.

Auch das RepositoryImportUtil ist hierbei keine große Hilfe, da es nur Dateien liest, die ich zuvor irgendwo auf Platte geschrieben habe.

Wie also bekomme ich am besten meinen MemoryStream ins Repository geschrieben?

Viele Grüße

Alex

2

Hi Alex,

in diesem Fall könntest du eine eigene Repository-Implementierung verwenden. Bitte schau dir einmal die in LL mitgelieferten Web-Samples an, z. B. das MVC Web Reporting Sample

..\combit\LL??\Beispiele\Microsoft .NET\.NET 8\ASP.NET\MVC Web Reporting Sample

Die dort verwendete Repository-Implementierung (SQLiteFileRepository.cs) arbeitet mit Streams:

        public void CreateOrUpdateItem(RepositoryItem item, string userImportData, Stream sourceStream)
        {
            string currentUser = null;
            try
            {
                currentUser = HttpContext.Current.User.Identity.Name;
            }
            catch (NullReferenceException)
            {
            }

            if (string.IsNullOrEmpty(currentUser))
                currentUser = "[Anonymous User]";

            // Convert stream from List & Label to byte array to store it in the DB
            // Warning: sourceStream may be null! In that case, only the metadata should be changed in the database. See the documentation for IRepository.CreateOrUpdateItem() for details.
            byte[] fileContent = null;
            bool setMetadataOnly;
            if (sourceStream != null)
            {
                using (var memStream = new MemoryStream())
                {
                    sourceStream.CopyTo(memStream);
                    fileContent = memStream.ToArray();
                }
                setMetadataOnly = false;
            }
            else
            {
                setMetadataOnly = true;
            }
...

Hilft dir das weiter?

Grüße
Chris

3

Hi Christ,

danke für die schnelle Antwort.

Das war auch mein ursprünglicher Ansatz

var oRepRepo = new ReportRepository(oAddData, string.Empty);
var oItem = new RepositoryItem(sItemId, null, @"ll/project/lst", DateTime.Now); 
oRepRepo.CreateOrUpdateItem(oItem, oAddData.ToString(), ms);

Das Dumme ist nur, dass in diesem Fall der Descriptor null ist, was nicht sein darf, und ich keine Möglichkeit habe, einen Descriptor über die Klasse RepositoryItemDescriptor zu erzeugen. Das habe ich nicht hinbekommen, weil diese anscheinend nur für den internen Gebrauch gedacht ist.

Normalerweise ist es ja so, dass das RepositoryItem von LL erzeugt wird und dabei ist der Descriptor immer gefüllt, wenn er in die Methode CreateOrUpdateItem kommt, um das neue Objekt ins Repository zu schreiben.

Viele Grüße

Alex
PS
Ich habe es noch nicht testen können, aber wäre sowas ein erlaubter Weg, um den Descriptor zu erhalten?

string sUIName = "Standard";
RepositoryItemDescriptor oDescriptor = RepositoryItemDescriptor.LoadFromDescriptorString("");
oDescriptor.SetUIName(0, sUIName);    
string sDescriptorString = oDescriptor.SerializeToString();
4

Morgen Alexandra, ich habe dir hier mal meine Implentierung von CreateOrUpdateItem eingefügt, vielleicht hilft dir das weiter.

public void CreateOrUpdateItem(RepositoryItem item, string importUserData, Stream sourceStream)
        {
            if (item.ExtractDisplayName(GermanLocalId) == null)
            {
                var descriptorString = item.Descriptor;
                var descriptor = RepositoryItemDescriptor.LoadFromDescriptorString(descriptorString);
                descriptor.SetUIName(GermanLocalId, currentNeededItem.Name);
                item.Descriptor = descriptor.SerializeToString();
            }

            if(isImportFile)
            {
                ImportItem(item, sourceStream);
                return;
            }

            byte[] fileContent = null;

            var documentKey = AlphanumericKeyUtils
                .GenerateUniqueKey(6, dataContext.Documents
                    .Select(x => x.DocumentKey)
                    .ToList());

            // Wenn sourceStream null ist, ist es ein neues Projekt.
            if (sourceStream != null)
            {
                using (var memStream = new MemoryStream())
                {
                    sourceStream.CopyTo(memStream);
                    fileContent = memStream.ToArray();
                }
            }
            else
            {
                AddItem(item, documentKey);
                return;
            }

            var isTemplate = ItemIsTemplate(item);

            var document = dataContext.Documents
                .SingleOrDefault(x => x.ItemRepoId == item.InternalID);

            if (document == null)
            {
                document = new Document()
                {
                    IsRepoitem = true,
                    DocumentKey = documentKey
                };
                dataContext.Documents.Add(document);
            }

            document.FileContentOfDraft = fileContent;
            document.IsTemplate = isTemplate;
            document.ItemRepoId = item.InternalID;
            document.ItemRepoType = item.Type;
            document.Descriptor = item.Descriptor;
            document.LastModification = item.LastModificationUTC.ToLocalTime(); // LL liefert hier immer die UTC zurück, daher in Ortzeit umwandeln.
            document.UserId = userId;
            document.Filename = document.Filename == null ? item.ExtractDisplayName() : document.Filename;
            document.LaboratoryId = laboratoryId;
            if (document.Name == string.Empty)
            {
                document.Name = item.ExtractDisplayName();
            }

            dataContext.SaveChanges();
        }

Hier noch das AddItem

        private void AddItem(RepositoryItem item, string documentKey)
        {
            if (dataContext.Documents
                    .SingleOrDefault(x => x.ItemRepoId == item.InternalID) != null)
            {
                return;
            }

            dataContext.Documents.Add((currentNeededItem));

            currentNeededItem.DocumentKey = documentKey;
            currentNeededItem.ItemRepoId = item.InternalID;
            currentNeededItem.ItemRepoType = item.Type;
            currentNeededItem.Descriptor = item.Descriptor;
            currentNeededItem.LastModification = item.LastModificationUTC.ToLocalTime(); // LL liefert hier immer die UTC zurück, daher in Ortzeit umwandeln.
            currentNeededItem.UserId = userId;
            currentNeededItem.Filename ??= item.ExtractDisplayName();
            currentNeededItem.Name ??= item.ExtractDisplayName();
            dataContext.SaveChanges();
        }