Nextcloud Dateiübertrag mit Freigabelink und Schlagwortsetzung

20.11.2024 12:27:40: Hochladen zur Nextcloud läuft ...
20.11.2024 12:27:48: Datei erfolgreich hochgeladen!
20.11.2024 12:27:48: Antwort des Servers: <?xml version="1.0"?>  
<ocs>
 <meta>
  <status>ok</status>
  <statuscode>200</statuscode>
  <message>OK</message>
 </meta>
 <data>
  <id>52</id>
  <share_type>3</share_type>
  <uid_owner>name</uid_owner>
  <displayname_owner>Name</displayname_owner>
  <permissions>1</permissions>
  <can_edit>1</can_edit>
  <can_delete>1</can_delete>
  <stime>1732102096</stime>
  <parent/>
  <expiration>2024-11-25 00:00:00</expiration>
  <token>Tokennummer ctn53mdgb</token>
  <uid_file_owner>name</uid_file_owner>
  <note></note>
  <label></label>
  <displayname_file_owner>Name</displayname_file_owner>
  <path>/UNTERORDNER/Datei.zip</path>
  <item_type>file</item_type>
  <item_permissions>27</item_permissions>
  <mimetype>application/zip</mimetype>
  <has_preview></has_preview>
  <storage_id>home::name</storage_id>
  <storage>5</storage>
  <item_source>8556</item_source>
  <file_source>8556</file_source>
  <file_parent>690</file_parent>
  <file_target>/Datei.zip</file_target>
  <item_size>17606910</item_size>
  <item_mtime>1732102096</item_mtime>
  <share_with>3|$argon2id$v=19$m=65536,t=4,p=2$5yQnBHgTrrFp65kgNyw$yNg6nKyHHXWd+SdCztjffbq06x1uLM7YFm2ABp5GQO0</share_with>
  <share_with_displayname>(Geteilter Link)</share_with_displayname>
  <password>3|$argon2id$v=19$m=65536,t=4,p=2$5yQnBHgTrrFp65kgNyw$yNg6nKyHHXWd+SdCztjffbq06x1uLM7YFm2ABp5GQO0</password>
  <send_password_by_talk></send_password_by_talk>
  <url>https://domainname/nextcloud/index.php/s/SAWRK5jok6kfw3B</url>
  <mail_send>1</mail_send>
  <hide_download>0</hide_download>
  <attributes/>
 </data>
</ocs>

20.11.2024 12:27:48: Fehler beim Erstellen der Freigabe: Unexpected character encountered while parsing value: <. Path '', line 0, position 0.  

using System;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Newtonsoft.Json;
using System.Text.RegularExpressions;

namespace TestfreigabeNC
{
    public partial class Form1 : Form
    {
        private NextcloudUploader uploader; // Instanz der NextcloudUploader-Klasse

        public Form1()
        {
            InitializeComponent();
            uploader = new NextcloudUploader(prozesstextBox1); // Instanz mit Status-Textbox erstellen
        }

        private void Form1_Load(object sender, EventArgs e)
        {
        }

        private async void button1_Click(object sender, EventArgs e)
        {
            // Beispielwerte für die Parameter
            string zipFilePath = @"c:\Freigabe\TemporaerDaten\Datei.zip"; // Lokaler Pfad  
            string ncordnername = "UNTERORDNER";            // Ordnername in Nextcloud  
            string dateiname = "Datei.zip"; // Dateiname in Nextcloud  
            string ocUrl = "https://domainname.de/nextcloud"; // Nextcloud-Basis-URL  
            string ncpassword2 = "1234567890";    // Passwort für die Freigabe  
            string ncablaufdatum = "2024-11-25"; // Ablaufdatum der Freigabe  

            try
            {
                // Hochladen und Freigabe erstellen
                await uploader.UploadFileToNextcloud(zipFilePath, ncordnername, dateiname, ocUrl, ncpassword2, ncablaufdatum);
            }
            catch (Exception ex)
            {
                // Fehlerbehandlung
                MessageBox.Show($"Fehler: {ex.Message}", "Fehler beim Hochladen", MessageBoxButtons.OK, MessageBoxIcon.Error);  
                uploader.LogMessage($"Fehler: {ex.Message}");  
            }
        }
    }

    public class NextcloudUploader
    {
        private TextBox _statusTextBox;

        // Konstruktor: TextBox zur Anzeige des Fortschritts übergeben
        public NextcloudUploader(TextBox statusTextBox)
        {
            _statusTextBox = statusTextBox;
        }

        public async Task UploadFileToNextcloud(string zipFilePath, string ncordnername, string dateiname, string ocUrl, string ncpassword2, string ncablaufdatum)
        {
            if (File.Exists(zipFilePath))
            {
                string nextcloudUrl = "https://domainname/nextcloud/remote.php/dav/files/name/UNTERORDNER/";  
                string username = "name";  
                string passwordNextcloud = "passwort";  

                UpdateStatus("Hochladen zur Nextcloud läuft ...");  
                LogMessage("Hochladen zur Nextcloud läuft ...");  

                using (var client = new HttpClient())
                {
                    // Authentifizierung für die HTTP-Anfrage
                    var authToken = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{passwordNextcloud}"));  
                    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authToken);  

                    // Zusätzlicher Header für die OCS-API
                    client.DefaultRequestHeaders.Add("OCS-APIREQUEST", "true");  

                    using (var fileStream = File.OpenRead(zipFilePath))
                    {
                        var content = new StreamContent(fileStream);
                        content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");  
                        string targetUrl = nextcloudUrl + Path.GetFileName(zipFilePath);

                        // Datei hochladen
                        var response = await client.PutAsync(targetUrl, content);

                        if (response.IsSuccessStatusCode)
                        {
                            UpdateStatus("Datei erfolgreich hochgeladen!");  
                            LogMessage("Datei erfolgreich hochgeladen!");  

                            // Erstellen der Freigabe nach erfolgreichem Upload
                            var shareUrl = $"{ocUrl}/ocs/v2.php/apps/files_sharing/api/v1/shares";  

                            // Erstellen der Freigabeparameter
                            var shareRequestData = new FormUrlEncodedContent(new[]
                            {
                                new KeyValuePair<string, string>("path", $"{ncordnername}/{dateiname}"),  
                                new KeyValuePair<string, string>("shareType", "3"), // Öffentliche Freigabe  
                                new KeyValuePair<string, string>("password", ncpassword2),  
                                new KeyValuePair<string, string>("permissions", "1"), // Leseberechtigung  
                                new KeyValuePair<string, string>("expireDate", ncablaufdatum)  
                            });

                            try
                            {
                                var shareResponse = await client.PostAsync(shareUrl, shareRequestData);

                                // Antwortinhalt als Rohtext ausgeben
                                var responseContent = await shareResponse.Content.ReadAsStringAsync();
                                UpdateStatus($"Antwort des Servers: {responseContent}");  // Protokollierung der Serverantwort  
                                LogMessage($"Antwort des Servers: {responseContent}");  

                                // Überprüfen des Statuscodes
                                if (shareResponse.IsSuccessStatusCode)
                                {
                                    dynamic shareResponseJson = JsonConvert.DeserializeObject(responseContent);

                                    // Freigabelink aus der Antwort extrahieren
                                    string publicLink = shareResponseJson?.ocs?.data?.url;
                                    UpdateStatus($"Datei erfolgreich freigegeben! Freigabelink: {publicLink}");  
                                    LogMessage($"Datei erfolgreich freigegeben! Freigabelink: {publicLink}");  

                                    // Schlagwort "2Tage" setzen 
                                    await SetTagOnFile(client);
                                }
                                else
                                {
                                    // Fehler bei der Freigabe
                                    UpdateStatus($"Fehler bei der Freigabe: {shareResponse.StatusCode}");  
                                    LogMessage($"Fehler bei der Freigabe: {shareResponse.StatusCode}");  
                                }
                            }
                            catch (Exception ex)
                            {
                                // Fehler beim Verarbeiten der Antwort
                                UpdateStatus($"Fehler beim Erstellen der Freigabe: {ex.Message}");  
                                LogMessage($"Fehler beim Erstellen der Freigabe: {ex.Message}");  
                            }
                        }
                        else
                        {
                            // Fehler beim Hochladen der Datei
                            UpdateStatus($"Fehler beim Hochladen: {response.StatusCode}");  
                            LogMessage($"Fehler beim Hochladen: {response.StatusCode}");  
                        }
                    }
                }
            }
            else
            {
                UpdateStatus("Die angegebene Datei existiert nicht!");  
                LogMessage("Die angegebene Datei existiert nicht!");  
            }
        }

        private async Task SetTagOnFile(HttpClient client)
        {
            // URL aus der Logdatei extrahieren
            string publicLink = GetUrlFromLogFile(@"c:\Freigabe\Log\nc.log");  
            if (!string.IsNullOrEmpty(publicLink))
            {
                string tagUrl = "https://domainname/nextcloud/ocs/v2.php/apps/files_tags/api/v1/tags";  
                var tagData = new FormUrlEncodedContent(new[]
                {
                    new KeyValuePair<string, string>("tag", "2Tage"),  
                    new KeyValuePair<string, string>("itemType", "file"),  
                    new KeyValuePair<string, string>("itemId", publicLink) // Die ID oder der Link der Datei  
                });

                try
                {
                    var tagResponse = await client.PostAsync(tagUrl, tagData);
                    if (tagResponse.IsSuccessStatusCode)
                    {
                        UpdateStatus("Schlagwort '2Tage' erfolgreich gesetzt!");  
                        LogMessage("Schlagwort '2Tage' erfolgreich gesetzt!");  
                    }
                    else
                    {
                        UpdateStatus("Fehler beim Setzen des Schlagworts '2Tage'.");  
                        LogMessage("Fehler beim Setzen des Schlagworts '2Tage'.");  
                    }
                }
                catch (Exception ex)
                {
                    UpdateStatus($"Fehler beim Setzen des Schlagworts: {ex.Message}");  
                    LogMessage($"Fehler beim Setzen des Schlagworts: {ex.Message}");  
                }
            }
            else
            {
                UpdateStatus("Kein gültiger Link in der Logdatei gefunden!");  
                LogMessage("Kein gültiger Link in der Logdatei gefunden!");  
            }
        }

        private string GetUrlFromLogFile(string logFilePath)
        {
            try
            {
                if (File.Exists(logFilePath))
                {
                    string logContent = File.ReadAllText(logFilePath);
                    Regex regex = new Regex(@"<url>(.*?)</url>", RegexOptions.IgnoreCase);  
                    Match match = regex.Match(logContent);
                    if (match.Success)
                    {
                        return match.Groups[1].Value;
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessage($"Fehler beim Auslesen der Logdatei: {ex.Message}");  
            }
            return null;
        }

        // Hilfsmethode zur Aktualisierung der Statusanzeige
        private void UpdateStatus(string message)
        {
            if (_statusTextBox.InvokeRequired)
            {
                _statusTextBox.Invoke(new Action(() => _statusTextBox.Text = message));
            }
            else
            {
                _statusTextBox.Text = message;
            }
        }

        // Loggen von Nachrichten
        public void LogMessage(string message)
        {
            string logDirectory = @"c:\Freigabe\Log";  
            string logFile = Path.Combine(logDirectory, "nc.log");  

            try
            {
                if (!Directory.Exists(logDirectory))
                {
                    Directory.CreateDirectory(logDirectory);
                }

                if (!File.Exists(logFile))
                {
                    File.Create(logFile).Close();
                }

                using (StreamWriter writer = new StreamWriter(logFile, true))
                {
                    writer.WriteLine($"{DateTime.Now}: {message}");  
                }
            }
            catch (Exception ex)
            {
                UpdateStatus($"Fehler beim Loggen der Nachricht: {ex.Message}");  
            }
        }
    }
}