Beschreibung

Mit Einstellungen des Interface "IWmsActivitySettingList" kann der WMS-Benutzer mehrere Einstellungen des selben Typs hinterlegen. Über Zuordnungen kann er einzelne dieser Einstellungen dann im Workflow und in Aktivitäten verwenrden.

Die Einstellungen SMTP, FTP und Datenbanken im WMS nutzen dieses Interface.

Häufige Anwendungsfälle:

Allgemeingültige Verbindungseinstellungen zu Drittsystemen oder Geräten

Inhalt

1 Beschreibung
2 Aufbau des Interface IWmsActivitySettingList
3 Beispiel

Aufbau des Interface IWmsActivitySettingList

Eigenschaft / Methode	Beschreibung

Eigenschaft / Methode	Beschreibung
Identifier	Immer gleicher, eindeutiger Identifier dieser Einstellung!
Title	Titel der Einstellung, wird als Name des Menüs verwendet.
TitleToolTip	Tooltip für das Menü bzw. die Schaltfläche.
DialogContent	UserControl zur Bearbeitung der Einstellung im Dialog. Erst in InitialiseDialog-Methoden zusammen bauen!
IsValidDialogData()	Prüft, ob die Eingaben im Dialog valide sind. Nur dann wird der Dialog geschlossen.
AddErrorToDialog(string error)	Diese Methode soll die angegbene Fehlermeldung im Dialog anzeigen. Das WMS ruft diese Methode auf, wenn eine Einstellung mit diesem Namen bereits vorhanden ist.
InitialiseDialogData(WmsSettingEntry entry)	Erzeugt die Oberfläche zur Bearbeitung eines Eintrages.
GetDialogData()	Ermittelt die Eingaben aus dem Dialog um sie zu speichern.

Beispiel

Im Folgenden entwickeln wir eine Aktivität, um Dateien auf einen FTP Server hochzuladen. Der WMS-Benutzer kann beliebig viele FTP-Einstellungen konfigurieren und über die Zuordnungen die

Implementierung IWmsActivitySettingList

IWmsActivitySettingList

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Windows.Controls;
using Accantum.Wms.ActivityContracts.Settings;
using ActivitySample.Activities.FtpUpload.V01;

namespace ActivitySample.Activities.FtpUpload.Setting
{
    public class FtpConfigurationSettings :  IWmsActivitySettingList
    {
        public static Guid SettingId = new Guid("1f2d1198-b5c7-47f9-a8c4-fda02cc49d61");

        // Eindeutiger Identifier dieser Einstellung
        public Guid Identifier => SettingId;

        /// <summary>
        /// Bezeichnung für das Einstellungsmenü
        /// </summary>
        public string Title => "FTP";

        /// <summary>
        /// Tooltip für die Schaltfläche im Einstellungsmenü
        /// </summary>
        public string TitleTooltip => "FTP-Verbindungen verwalten, die in den FTP-Aktivitäten zur Verfügung stehen.";

        /// <summary>
        /// Prefix für Zuordnungsvariablen
        /// </summary>
        public string MappingVariablePrefix => "ftp";

        /// <summary>
        /// Zusätzliche Spalten, die in der Übersicht angezeigt werden sollen
        /// </summary>
        public IEnumerable<WmsSettingColumnDef> ColumnDefinitions => new List<WmsSettingColumnDef>
        {
            new WmsSettingColumnDef("FTP-Host", nameof(WmsFtpConfig.Host)),
            new WmsSettingColumnDef("Verzeichnis", nameof(WmsFtpConfig.RootDirectory))
        };

        /// <summary>
        /// UserControl zur Bearbeitung der Einstellung im Dialog.
        /// </summary>
        public UserControl DialogContent { get; private set; }

        /// <summary>
        /// Prüft, ob die Eingaben im Dialog valide sind. Nur dann wird der Dialog geschlossen
        /// </summary>
        /// <returns>true, wenn der Dialog geschlossen werden darf</returns>
        public Task<bool> IsValidDialogData()
        {
            var oViewModel = (DialogContent as FtpConfig)?.ViewModel;
            return Task.FromResult(oViewModel != null && oViewModel.IsValid());
        }

        /// <summary>
        /// Zeigt eine Fehlermeldung im Dialog an.
        /// </summary>
        /// <param name="a_sPropertyName">Name der fehlerhaften Eigenschaft</param>
        /// <param name="a_sErrorMessage">Fehlermeldung</param>
        public void AddErrorToDialog(string a_sPropertyName, string a_sErrorMessage)
        {
            var oViewModel = (DialogContent as FtpConfig)?.ViewModel;
            oViewModel?.AddErrorToDialog(a_sPropertyName, a_sErrorMessage);
        }

        /// <summary>
        /// Erzeugt die Oberfläche zur Bearbeitung eines Eintrages
        /// </summary>
        /// <param name="a_oSettingEntry"></param>
        public void InitialiseDialogData(WmsSettingEntry a_oSettingEntry)
        {
            var oVm = new FtpConfigViewModel(a_oSettingEntry);
            DialogContent = new FtpConfig(oVm);
        }

        /// <summary>
        /// Ermittelt die Eingaben aus dem Dialog um sie zu speichern
        /// </summary>
        /// <returns></returns>
        public WmsSettingEntry GetDialogData()
        {
            var control = DialogContent as FtpConfig;
            var viewModel = control.ViewModel;
            //Hier könnten das Passwort wieder aus der Passwortbox ermitteln
            viewModel.Password = control.PasswordBox.SecurePassword;
            return viewModel.GetSettingEntry(;
        }
    }
}

WmsFtpConfig: Wert der FTP Einstellung, die gespeichert wird

using System;
using System.Security.Authentication;
using System.Xml.Serialization;
using Accantum.Wms.ActivityContracts.Settings;

namespace ActivitySample.Activities.FtpUpload.V01
{
    /// <summary>
    /// Einstellungen zu einem FTP-Account
    /// </summary>
    [Serializable]
    public class WmsFtpConfig
    {
        private readonly WmsSettingEntry m_oSettingEntry;
        private string m_strRootDirectory;

        public WmsFtpConfig()
        {
            Port = null;
        }

        public WmsFtpConfig(WmsSettingEntry a_oSettingEntry)
        {
            m_oSettingEntry = a_oSettingEntry;
            Id = a_oSettingEntry.Id;
            Name = a_oSettingEntry.Name;

            //Eigenschaften aus dem Properites-Array laden
            Host = a_oSettingEntry.Properties[nameof(Host)] as string;
            Port = a_oSettingEntry.Properties[nameof(Port)] as int?;
            User = a_oSettingEntry.Properties[nameof(User)] as string;
            EncryptedPassword = a_oSettingEntry.Properties[nameof(EncryptedPassword)] as string;
            EncryptionMode = a_oSettingEntry.Properties[nameof(EncryptionMode)] as EFtpEncryptionMode? ?? EFtpEncryptionMode.AutoDetect;
            EncryptionProtocol = a_oSettingEntry.Properties[nameof(EncryptionProtocol)] as SslProtocols? ?? SslProtocols.None;

            RootDirectory = a_oSettingEntry.Properties[nameof(RootDirectory)] as string;
        }

        /// <summary>
        /// Eindeutige Id aus der Einstellung
        /// </summary>
        public Guid Id { get; set; }

        /// <summary>
        /// Name aus der Einstellung
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// FTP-Host für den Datenaustausch
        /// </summary>
        public string Host { get; set; }

        /// <summary>
        /// Port, welcher für den FTP-Zugang verwendet wird. Wenn nicht gesetzt, dann werden die Standardports verwendet
        /// Standardwert: null
        /// </summary>
        public int? Port { get; set; }

        /// <summary>
        /// Benutzer des FTP-Zugangs.
        /// </summary>
        public string User { get; set; }

        /// <summary>
        /// Passwort des FTP-Zugangs
        /// </summary>
        [XmlElement("Password")]
        public string EncryptedPassword { get; set; }

        /// <summary>
        /// Modus der Verschlüsselung (none, explizit, implizit).
        /// </summary>
        public EFtpEncryptionMode EncryptionMode { get; set; }

        /// <summary>
        /// Protokoll der Verschlüsselung (SSL -Secure Sockets Layer, TLS).
        /// </summary>
        public SslProtocols EncryptionProtocol { get; set; }

        /// <summary>
        /// Basis-Verzeichnis auf dem FTP-Server (Verzeichnisse mit "/" getrennt, nicht mit "\")
        /// </summary>
        public string RootDirectory
        {
            get => m_strRootDirectory;
            set
            {
                if (value != null)
                {
                    string strPath = value.Replace('\\', '/');
                    m_strRootDirectory = (string.IsNullOrEmpty(strPath) || strPath.StartsWith("/")) ? strPath : $"/{strPath}";
                }
                else
                {
                    m_strRootDirectory = null;
                }
            }
        }

        /// <summary>
        /// Um Einstellung zu speichern in ein WmsSettingEntry wandeln und die zu speichernden Eigenschaften in das Properties-Array schreiben
        /// </summary>
        public WmsSettingEntry ToWmsSettingEntry()
        {
            return new WmsSettingEntry
            {
                Id = m_oSettingEntry.Id,
                Name = m_oSettingEntry.Name,
                Description = m_oSettingEntry.Description,
                CreationDate = m_oSettingEntry.CreationDate,
                CreationUser = m_oSettingEntry.CreationUser,
                ModifyDate = m_oSettingEntry.ModifyDate,
                ModifyUser = m_oSettingEntry.ModifyUser,
                Properties = new WmsPropertyCollection
                {
                    new WmsSettingEntryProperty(nameof(Host), Host),
                    new WmsSettingEntryProperty(nameof(Port), Port),
                    new WmsSettingEntryProperty(nameof(User), User),
                    new WmsSettingEntryProperty(nameof(EncryptedPassword), EncryptedPassword),
                    new WmsSettingEntryProperty(nameof(EncryptionMode), EncryptionMode),
                    new WmsSettingEntryProperty(nameof(EncryptionProtocol), EncryptionProtocol),
                    new WmsSettingEntryProperty(nameof(RootDirectory), RootDirectory)
                }
            };
        }
    }
}

Implementierung der Oberfläche zur Eingabe der Einstellung

ViewModel des FTP-Dialogs

using System.ComponentModel.DataAnnotations;
using System.Net;
using System.Security;
using System.Security.Authentication;
using Accantum.Wms.ActivityContracts.Settings;
using ActivitySample.Activities.FtpUpload.V01;
using ActivitySample.Helper;
using ActivitySample.Properties;

namespace ActivitySample.Activities.FtpUpload.Setting
{
    // ViewModel für die Bearbeitung einer FTP-Verbindungseinstellung
    // Accantum verwendet in seinen ViewModel eine Klasse "ValidatableModelBase". Diese implementiert u.a. INotifyPropertyChanged.
    // Für externe Entwicklungen steht die Klasse nicht zur Verfügung. Beispiele von Microsoft: https://learn.microsoft.com/en-us/dotnet/desktop/wpf/data/how-to-implement-property-change-notification?view=netframeworkdesktop-4.8
    public class FtpConfigViewModel : ValidatableModelBase
    {
        private string m_sName;
        private string m_sDescription;
        private string m_sHost;
        private string m_sUsername;
        private SecureString m_sPassword;
        private int? m_iPort;
        private EFtpEncryptionMode m_eEncryptionMode;
        private SslProtocols m_eEncryptionProtocol;
        private string m_sRootDirectory;
        private bool m_bIsBusy;
        private string m_sConnectionStateInfo;

        private readonly WmsSettingEntry m_oSettingEntry;

        public FtpConfigViewModel(WmsSettingEntry a_oSettingEntry)
        {
            m_oSettingEntry = a_oSettingEntry ?? new WmsSettingEntry();
            SetProperties();
        }

        #region Properties

        [Required]
        public string Name
        {
            get => m_sName;
            set => SetProperty(ref m_sName, value);
        }

        public string Description
        {
            get => m_sDescription;
            set => SetProperty(ref m_sDescription, value);
        }

        [Required, Display(ResourceType = typeof(Resource), Name = "Host")]
        public string Host
        {
            get => m_sHost;
            set => SetProperty(ref m_sHost, value);
        }

        [Display(ResourceType = typeof(Resource), Name = "Username")]
        public string Username
        {
            get => m_sUsername;
            set => SetProperty(ref m_sUsername, value);
        }

        public SecureString Password
        {
            get => m_sPassword;
            set => SetProperty(ref m_sPassword, value);
        }

        public int? Port
        {
            get => m_iPort;
            set => SetProperty(ref m_iPort, value);
        }

        public EFtpEncryptionMode EncryptionMode
        {
            get => m_eEncryptionMode;
            set
            {
                SetProperty(ref m_eEncryptionMode, value);
                if (value == EFtpEncryptionMode.AutoDetect)
                    EncryptionProtocol = SslProtocols.None;
            }
        }

        public SslProtocols EncryptionProtocol
        {
            get => m_eEncryptionProtocol;
            set => SetProperty(ref m_eEncryptionProtocol, value);
        }

        [Display(ResourceType = typeof(Resource), Name = "RootDirectoryName")]
        public string RootDirectory
        {
            get => m_sRootDirectory;
            set => SetProperty(ref m_sRootDirectory, value);
        }
        

        public bool IsBusy
        {
            get => m_bIsBusy;
            set => SetPropertyWithoutValidate(ref m_bIsBusy, value);
        }

        public string ConnectionStateInfo
        {
            get => m_sConnectionStateInfo;
            set => SetPropertyWithoutValidate(ref m_sConnectionStateInfo, value);
        }

        #endregion


        public bool IsValid()
        {
            return ValidateObject();
        }

        public void AddErrorToDialog(string a_sPropertyName, string a_sErrorMessage)
        {
            AddError(a_sPropertyName, a_sErrorMessage);
        }
        
        public WmsFtpConfig CreateFtpConfig()
        {
            m_oSettingEntry.Name = Name;
            m_oSettingEntry.Description = Description;

            var sPasswortString = new NetworkCredential(string.Empty, Password).Password;

            var oConfig = new WmsFtpConfig(m_oSettingEntry)
            {
                Host = Host,
                Port = Port,
                User = Username,
                EncryptedPassword = sPasswortString, //Hier Verschlüsseln! z.B. TripleDES
                EncryptionMode = EncryptionMode,
                EncryptionProtocol = EncryptionProtocol,
                RootDirectory = RootDirectory
            };
            return oConfig;
        }

        public WmsSettingEntry GetSettingEntry()
        {
            var oFtpConfig = CreateFtpConfig();
            return oFtpConfig.ToWmsSettingEntry();
        }

        
        private void SetProperties()
        {
            var oFtp = new WmsFtpConfig(m_oSettingEntry);
            m_sName = m_oSettingEntry.Name;
            m_sDescription = m_oSettingEntry.Description;

            var oSecurePassword = new NetworkCredential(string.Empty, oFtp.EncryptedPassword).SecurePassword; //Hier Entschlüsseln

            m_sHost = oFtp.Host;
            m_sUsername = oFtp.User;
            m_sPassword = oSecurePassword;
            m_iPort = oFtp.Port;
            m_eEncryptionMode = oFtp.EncryptionMode;
            m_eEncryptionProtocol = oFtp.EncryptionProtocol;
            m_sRootDirectory = oFtp.RootDirectory;
        }
    }
}

WMS Developer

WMS Einstellung: IWmsActivitySettingList

Beschreibung

Aufbau des Interface IWmsActivitySettingList

Beispiel

Implementierung IWmsActivitySettingList

IWmsActivitySettingList

WmsFtpConfig: Wert der FTP Einstellung, die gespeichert wird

Implementierung der Oberfläche zur Eingabe der Einstellung

ViewModel des FTP-Dialogs

Oberfläche zur Eingabe der FTP-Einstellung

Beispiel Setting Control - CodeBehind (xaml.cs)

Verwendung in der Aktivität

Beispiel zur Verwendung in der Aktivität

Designer zur FTP Aktivität