1899 lines
73 KiB
C#
1899 lines
73 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Reflection;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Media;
|
|
|
|
using C4IT.API;
|
|
using C4IT.API.Contracts;
|
|
using C4IT.Logging;
|
|
using C4IT.Matrix42.WebClient;
|
|
|
|
using C4IT.Configuration;
|
|
|
|
using Microsoft.Win32;
|
|
|
|
using Newtonsoft.Json;
|
|
|
|
using static C4IT.Logging.cLogManager;
|
|
|
|
namespace C4IT_CustomerPanel.libs
|
|
{
|
|
public enum enumAlternateAuthMethods { none, authCredentials, authToken, authForms }
|
|
|
|
public class ConfigClass
|
|
{
|
|
/*
|
|
* Kommentar:
|
|
* Variablen Definition
|
|
* local_ = Konfigurationswerte zum Start und zur Kommunikation mit Server (HKEY_LOCAL_MACHINE)
|
|
* usr_ = Durch den Benutzer konfigurierbare Einstellungen
|
|
* rnt_ = Variablen nur während der Laufzeit des Anwendung
|
|
*
|
|
*/
|
|
public enum enumPresentationMode { OS = 0, Off = 1, On = 2 };
|
|
private const string hKeyAppPath = @"SOFTWARE\Consulting4IT GmbH\Customer Panel";
|
|
private const string hKeyUserPath = hKeyAppPath + @"\user";
|
|
private const string hKeyConfigPath = hKeyAppPath + @"\config";
|
|
private const string hKeyAuthPath = hKeyAppPath + @"\authentication";
|
|
private const string hKeyDefaultUserSettingsPath = hKeyAppPath + @"\DefaultUserSettings";
|
|
private const string registryHKCUPath = @"HKEY_CURRENT_USER\"+ hKeyAppPath + @"\user";
|
|
private const string registryUserInformationValueName = "userInformation";
|
|
private const int minTicketTimerValue = 2;
|
|
private const int minRegularAnnouncementTimerValue = 2;
|
|
private const int minAdHocAnnouncementTimerValue = 1;
|
|
|
|
public enum enumMainFunctions { Announcement = 0, Information, Ssp, Incident, CustomLinks };
|
|
public Dictionary<enumMainFunctions, bool> MainFunctionActivation = new Dictionary<enumMainFunctions, bool>() {
|
|
{enumMainFunctions.Announcement, false },
|
|
{enumMainFunctions.Incident, false },
|
|
{enumMainFunctions.Ssp, false },
|
|
{enumMainFunctions.Information, true },
|
|
{enumMainFunctions.CustomLinks, false }
|
|
};
|
|
public Dictionary<enumMainFunctions, string> MainFunctionM42Column = new Dictionary<enumMainFunctions, string>() {
|
|
{enumMainFunctions.Announcement, "announcementEnabled" },
|
|
{enumMainFunctions.Incident, "incidentEnabled" },
|
|
{enumMainFunctions.Information, "informationEnabled" },
|
|
{enumMainFunctions.Ssp, "sspEnabled" },
|
|
{enumMainFunctions.CustomLinks, "customlinksEnabled" }
|
|
};
|
|
public static Dictionary<int, journalAction> JournalActivityAction = new Dictionary<int, journalAction>() {
|
|
{0, new journalAction(Properties.Resources.ticketNewComment) },
|
|
{1,new journalAction(Properties.Resources.ticketCreatedByAgent) },
|
|
{2, new journalAction(Properties.Resources.ticketForwardedToUser) },
|
|
{3,new journalAction(Properties.Resources.ticketForwardedToRole)},
|
|
|
|
{4,new journalAction(Properties.Resources.ticketTakeover)},
|
|
{5,new journalAction(Properties.Resources.ticketPaused) },
|
|
{7,new journalAction(Properties.Resources.ticketAccepted) },
|
|
{8,new journalAction(Properties.Resources.ticketClosed) },
|
|
|
|
{9,new journalAction(Properties.Resources.ticketMerged) },
|
|
{11,new journalAction(Properties.Resources.ticketMailSend) },
|
|
{12,new journalAction(Properties.Resources.ticketPostedback) },
|
|
{14,new journalAction(Properties.Resources.ticketMailAnswer) },
|
|
{18,new journalAction(Properties.Resources.ticketCreatedByMail) },
|
|
{19,new journalAction(Properties.Resources.ticketCreatedBySSP) }
|
|
|
|
};
|
|
const string LocalDataPath = @"Consulting4IT GmbH\C4IT Customer Panel";
|
|
private const string ApiConfigBaseUrl = "https://{0}/m42Services/api/c4it/customerpanel/config?noCache={1}";
|
|
public int local_currentDPI = 96;
|
|
int rnt_tryCounter;
|
|
public String local_MatrixServer = String.Empty;
|
|
public bool ShowIpInfoOnlyInCorporateNetwork = false;
|
|
public String CustomerPanelTitle = String.Empty;
|
|
public String CustomAnnouncementText = String.Empty;
|
|
public int AnnouncementView;
|
|
private int usr_userLanguage = 9;
|
|
public string rnt_userInfoFromLogin;
|
|
|
|
bool _isInternalTesting = false;
|
|
|
|
string rnt_LogoUrlPrev = null;
|
|
|
|
|
|
string rnt_TrayIconUrlPrev = null;
|
|
|
|
//Aktive Buttons oder Mosueover
|
|
public Point usr_windowPosition;
|
|
private bool usr_enableNotifier;
|
|
|
|
public CustomerPanelConfig cpConfig;
|
|
internal UserInfo userInfo = new UserInfo();
|
|
public cM42WebClientV2 m42WebClient;
|
|
internal bool usingGeneralAPIToken = false;
|
|
private enumPresentationMode usr_PresentationMode = enumPresentationMode.OS;
|
|
|
|
public bool isDraggable = true;
|
|
|
|
public CustomerPanelConfig GetConfig()
|
|
{
|
|
return cpConfig;
|
|
}
|
|
|
|
public bool EnableNotifier
|
|
{
|
|
get => usr_enableNotifier;
|
|
set
|
|
{
|
|
if (usr_enableNotifier != value)
|
|
{
|
|
usr_enableNotifier = value;
|
|
WriteUserSetup();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string _localDataPath = null;
|
|
|
|
static public string GetLocalDataPath()
|
|
{
|
|
if (_localDataPath != null)
|
|
return _localDataPath;
|
|
|
|
var ass = Assembly.GetExecutingAssembly();
|
|
var Company = cLogManager.GetAssemblyCompanyName(ass);
|
|
var ProductName = cLogManager.GetAssemblyProductName(ass);
|
|
|
|
_localDataPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), Company, ProductName);
|
|
return _localDataPath;
|
|
}
|
|
|
|
static public string GetLocalFilePath(string FileName, bool withoutAlternate)
|
|
{
|
|
var FN = Path.Combine(GetLocalDataPath(), FileName);
|
|
if (!System.IO.File.Exists(FN) && !withoutAlternate)
|
|
FN = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, FileName);
|
|
return FN;
|
|
}
|
|
|
|
static public string GetLogoFilePath(bool withoutAlternate = false)
|
|
{
|
|
return GetLocalFilePath("logo.png", withoutAlternate);
|
|
}
|
|
|
|
static public string GetTrayIconFilePath(bool withoutAlternate = false)
|
|
{
|
|
return GetLocalFilePath("trayIcon.ico", withoutAlternate);
|
|
}
|
|
|
|
static public TEnum GetEnumFromString<TEnum>(string s, TEnum Default) where TEnum : System.Enum
|
|
{
|
|
try
|
|
{
|
|
if (!string.IsNullOrEmpty(s))
|
|
{
|
|
var s2 = s.ToUpperInvariant();
|
|
|
|
var R3 = Enum.GetValues(Default.GetType());
|
|
var R4 = R3.OfType<TEnum>();
|
|
|
|
foreach (TEnum Entry in R4)
|
|
{
|
|
if (Entry.ToString().ToUpperInvariant() == s2)
|
|
return Entry;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
}
|
|
|
|
return Default;
|
|
|
|
}
|
|
|
|
public Dictionary<string, string> GetLinkList()
|
|
{
|
|
return cpConfig._linkList;
|
|
}
|
|
public Color GetButtonHoverColor(Color? baseColor = null)
|
|
{
|
|
Color activeColor = baseColor ?? GetActiveButtonColor().Color;
|
|
bool isLightActive = GetRelativeLuminance(activeColor) >= 0.55;
|
|
return BlendColor(activeColor, isLightActive ? Colors.Black : Colors.White, isLightActive ? 0.10 : 0.12);
|
|
}
|
|
public SolidColorBrush GetActiveButtonColor()
|
|
{
|
|
return (SolidColorBrush)System.Windows.Application.Current.Resources["activeButtonColor"];
|
|
}
|
|
public SolidColorBrush GetInactiveButtonColor()
|
|
{
|
|
return (SolidColorBrush)System.Windows.Application.Current.Resources["inactiveButtonColor"];
|
|
}
|
|
public SolidColorBrush GetBackgroundColor()
|
|
{
|
|
return (SolidColorBrush)System.Windows.Application.Current.Resources["backgroundColor"];
|
|
}
|
|
|
|
private static Color BlendColor(Color source, Color target, double amount)
|
|
{
|
|
amount = Math.Max(0.0, Math.Min(1.0, amount));
|
|
return Color.FromArgb(
|
|
source.A,
|
|
(byte)Math.Round((source.R * (1.0 - amount)) + (target.R * amount)),
|
|
(byte)Math.Round((source.G * (1.0 - amount)) + (target.G * amount)),
|
|
(byte)Math.Round((source.B * (1.0 - amount)) + (target.B * amount)));
|
|
}
|
|
|
|
private static double GetRelativeLuminance(Color color)
|
|
{
|
|
return ((0.2126 * color.R) + (0.7152 * color.G) + (0.0722 * color.B)) / 255.0;
|
|
}
|
|
|
|
private static bool TryGetConfiguredUiColor(Dictionary<string, string> uiColors, string key, out Color color)
|
|
{
|
|
color = Colors.Transparent;
|
|
|
|
if (uiColors == null || !uiColors.TryGetValue(key, out string rawColor) || string.IsNullOrWhiteSpace(rawColor))
|
|
return false;
|
|
|
|
try
|
|
{
|
|
color = ConverterHelper.ColorConvertFromString(rawColor);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static void ApplyBackgroundDerivedResources(Color baseColor)
|
|
{
|
|
bool isLightBackground = GetRelativeLuminance(baseColor) >= 0.55;
|
|
Color panelColor = BlendColor(baseColor, Colors.White, isLightBackground ? 0.06 : 0.08);
|
|
Color navColor = BlendColor(baseColor, Colors.Black, isLightBackground ? 0.06 : 0.08);
|
|
Color activeColor = BlendColor(baseColor, isLightBackground ? Colors.Black : Colors.White, isLightBackground ? 0.30 : 0.34);
|
|
Color inactiveColor = BlendColor(baseColor, isLightBackground ? Colors.White : Colors.Black, isLightBackground ? 0.18 : 0.14);
|
|
Color panelBorder = BlendColor(baseColor, isLightBackground ? Colors.Black : Colors.White, isLightBackground ? 0.16 : 0.22);
|
|
Color navBorder = BlendColor(baseColor, isLightBackground ? Colors.Black : Colors.White, isLightBackground ? 0.20 : 0.28);
|
|
|
|
Application.Current.Resources["backgroundColor"] = new SolidColorBrush(baseColor);
|
|
Application.Current.Resources["activeButtonColor"] = new SolidColorBrush(activeColor);
|
|
Application.Current.Resources["inactiveButtonColor"] = new SolidColorBrush(inactiveColor);
|
|
Application.Current.Resources["panelBackgroundColor"] = new SolidColorBrush(panelColor);
|
|
Application.Current.Resources["navigationRailColor"] = new SolidColorBrush(navColor);
|
|
Application.Current.Resources["panelBorderColor"] = new SolidColorBrush(panelBorder);
|
|
Application.Current.Resources["navigationRailBorderColor"] = new SolidColorBrush(navBorder);
|
|
}
|
|
|
|
private static void ApplyHeaderDerivedResources(Color headerColor)
|
|
{
|
|
bool isLightHeader = GetRelativeLuminance(headerColor) >= 0.55;
|
|
Color controlBase = BlendColor(headerColor, isLightHeader ? Colors.Black : Colors.White, isLightHeader ? 0.14 : 0.18);
|
|
Color controlHover = BlendColor(headerColor, isLightHeader ? Colors.Black : Colors.White, isLightHeader ? 0.22 : 0.26);
|
|
|
|
Application.Current.Resources["headerControlBackgroundColor"] = new SolidColorBrush(controlBase);
|
|
Application.Current.Resources["headerControlHoverBackgroundColor"] = new SolidColorBrush(controlHover);
|
|
}
|
|
|
|
public SolidColorBrush GetHeaderColor()
|
|
{
|
|
return (SolidColorBrush)System.Windows.Application.Current.Resources["headerColor"];
|
|
}
|
|
|
|
public string GetNavIconColor()
|
|
{
|
|
if (cpConfig._iconColor == 10)
|
|
{
|
|
return "light";
|
|
}
|
|
else if (cpConfig._iconColor == 20)
|
|
{
|
|
return "dark";
|
|
}
|
|
return "dark";
|
|
}
|
|
public int GetNavIconColorValue()
|
|
{
|
|
return cpConfig._iconColor;
|
|
}
|
|
public string GetMainIconColor()
|
|
{
|
|
if (cpConfig._mainIconTextColor == 10)
|
|
{
|
|
return "light";
|
|
}
|
|
else if (cpConfig._mainIconTextColor == 20)
|
|
{
|
|
return "dark";
|
|
}
|
|
return "dark";
|
|
}
|
|
|
|
public bool IsPresentationModeFromOS()
|
|
{
|
|
return usr_PresentationMode == enumPresentationMode.OS;
|
|
}
|
|
|
|
public bool GetPresentationMode()
|
|
{
|
|
switch (usr_PresentationMode)
|
|
{
|
|
case enumPresentationMode.On:
|
|
return true;
|
|
case enumPresentationMode.Off:
|
|
return false;
|
|
default:
|
|
return InformationHelper.IsOsInPresentationMode();
|
|
}
|
|
}
|
|
|
|
public void SetPresentationMode(enumPresentationMode PresentationMode)
|
|
{
|
|
usr_PresentationMode = PresentationMode;
|
|
WriteUserSetup();
|
|
}
|
|
|
|
public void SetWindowPos()
|
|
{
|
|
WriteUserSetup(true);
|
|
}
|
|
|
|
public string GetRemoteAppPath()
|
|
{
|
|
return cpConfig._remoteAppPath;
|
|
}
|
|
|
|
public bool GetStartMinimized()
|
|
{
|
|
return cpConfig._isStartApplicationMinimized;
|
|
}
|
|
|
|
public int GetTimerIntervalTicket()
|
|
{
|
|
if (cpConfig._timerIntervalTicket < minTicketTimerValue && !_isInternalTesting)
|
|
{
|
|
return minTicketTimerValue;
|
|
}
|
|
else
|
|
{
|
|
return cpConfig._timerIntervalTicket;
|
|
}
|
|
}
|
|
|
|
public int GetTimerIntervalRegular()
|
|
{
|
|
if (cpConfig._timerIntervalRegularAnnouncements < minRegularAnnouncementTimerValue && !_isInternalTesting)
|
|
{
|
|
return minRegularAnnouncementTimerValue;
|
|
}
|
|
else
|
|
{
|
|
return cpConfig._timerIntervalRegularAnnouncements;
|
|
}
|
|
}
|
|
|
|
public int GetTimerIntervalAdHoc()
|
|
{
|
|
if (cpConfig._timerIntervalAdHocAnnouncements < minAdHocAnnouncementTimerValue && !_isInternalTesting)
|
|
{
|
|
return minAdHocAnnouncementTimerValue;
|
|
}
|
|
else
|
|
{
|
|
return cpConfig._timerIntervalAdHocAnnouncements;
|
|
}
|
|
}
|
|
|
|
public string GetMatrixServer(bool withHttps)
|
|
{
|
|
string Res = string.Empty;
|
|
if (withHttps)
|
|
Res = "https://";
|
|
Res += local_MatrixServer;
|
|
return Res;
|
|
}
|
|
|
|
public void SetUserLanguage(int language)
|
|
{
|
|
usr_userLanguage = language;
|
|
WriteUserSetup();
|
|
}
|
|
|
|
public int GetUserLanguage()
|
|
{
|
|
if (usr_userLanguage != 0)
|
|
return usr_userLanguage;
|
|
return CultureInfo.CurrentUICulture.LCID;
|
|
}
|
|
|
|
public bool IsUserLanguageOsDefault()
|
|
{
|
|
return usr_userLanguage == 0;
|
|
}
|
|
|
|
public string GetCultureName()
|
|
{
|
|
try
|
|
{
|
|
int ul = GetUserLanguage(); // Beispiel: 1031, 1033, etc.
|
|
CultureInfo culture = new CultureInfo(ul);
|
|
return culture.TwoLetterISOLanguageName;
|
|
}
|
|
catch (CultureNotFoundException)
|
|
{
|
|
// LCID ist ungültig oder nicht unterstützt
|
|
return "en";
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// Allgemeiner Fallback bei unerwarteten Fehlern
|
|
return "en";
|
|
}
|
|
}
|
|
|
|
public ConfigClass()
|
|
{
|
|
|
|
}
|
|
|
|
public void Initialize()
|
|
{
|
|
MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
|
|
|
|
try
|
|
{
|
|
cpConfig = new CustomerPanelConfig();
|
|
|
|
ReadUserSetup();
|
|
ReadMachineSetup(fromUser: true);
|
|
ReadMachineSetup(fromUser: false);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
finally
|
|
{
|
|
if (CM != null) LogMethodEnd(CM);
|
|
}
|
|
}
|
|
|
|
private void RegisterMsGateway()
|
|
{
|
|
MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
|
|
|
|
try
|
|
{
|
|
var cfgV2 = ConfigClassV2.Instance;
|
|
var msParams = new cM42MsGatewayAuthenticationParamters
|
|
{
|
|
Server = GetMatrixServer(false),
|
|
ApplcationId = cfgV2.MsGateway_ApplicationId,
|
|
TenantId = cfgV2.MsGateway_TenantId,
|
|
Scope = cfgV2.MsGateway_Scope,
|
|
InteractiveLogon = false
|
|
};
|
|
|
|
var _auth = new cM42MsGatewayAuthentication();
|
|
_auth.Initialize(msParams);
|
|
m42WebClient.RegisterAuthorisationProvider(_auth);
|
|
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
finally
|
|
{
|
|
if (CM != null) LogMethodEnd(CM);
|
|
}
|
|
}
|
|
|
|
public async Task<bool> CreateM42ConnectionObject()
|
|
{
|
|
MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
|
|
|
|
try
|
|
{
|
|
m42WebClient = new cM42WebClientV2(GetMatrixServer(false), GetCultureName(), DisableDNSCache: true);
|
|
|
|
var userInfosFromRegistry = ReadRegistryUserInfo();
|
|
if (userInfosFromRegistry && userInfo.ExpirationDate > DateTime.UtcNow)
|
|
m42WebClient.RegisterApiTokenAuthentication(userInfo.EncryptedApiToken);
|
|
|
|
if (App.DefaultCredentials != null)
|
|
m42WebClient.RegisterCredentialAuthentication(App.DefaultCredentials);
|
|
|
|
m42WebClient.RegisterPassThroughAuthentication();
|
|
if (ConfigClassV2.Instance.MsGateway_Enabled)
|
|
RegisterMsGateway();
|
|
|
|
var _res = await m42WebClient.LogonAsync();
|
|
|
|
if (_res.Reason == eM42ApiReason.ok)
|
|
{
|
|
await ReadConfigAsync();
|
|
return true;
|
|
}
|
|
else
|
|
LogEntry($"Initiales M42 Login fehlgeschlagen: {_res.Reason}");
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
finally
|
|
{
|
|
if (CM != null) LogMethodEnd(CM);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//public async Task<bool> VerifyUserCredentialsAndAuthorizationOld()
|
|
//{
|
|
// var methodInfo = MethodBase.GetCurrentMethod();
|
|
// LogMethodBegin(methodInfo);
|
|
|
|
// await Task.CompletedTask;
|
|
|
|
// bool authorizationState = false;
|
|
|
|
// bool useRegistrationForm = false;
|
|
// bool usePassThrough = false;
|
|
// try
|
|
// {
|
|
// // ---------------------------------------
|
|
// // 0) Versuch: (Registry) API-Token verwenden
|
|
// // ---------------------------------------
|
|
// LogEntry("Lese UserInfos aus Registry.", LogLevels.Debug);
|
|
// var userInfosFromRegistry = ReadRegistryUserInfo();
|
|
|
|
// LogEntry($"UserInfosFromRegistry: {userInfosFromRegistry}", LogLevels.Debug);
|
|
|
|
// if (userInfosFromRegistry == true && userInfo.ExpirationDate > DateTime.UtcNow)
|
|
// {
|
|
// LogEntry("Versuche Anmeldung mit lokalem API-Token (WebClient.LogonWithApiKeyAsync).", LogLevels.Debug);
|
|
// usingGeneralAPIToken = true;
|
|
// m42WebClient = new cM42WebClientV2(GetMatrixServer(false), GetCultureName(), DisableDNSCache: true);
|
|
// var retVal = await m42WebClient.LogonWithApiKeyAsync(userInfo.EncryptedApiToken);
|
|
// LogEntry($"LogonWithApiKeyAsync: {retVal}", LogLevels.Debug);
|
|
|
|
// if (retVal == eM42ApiReason.ok)
|
|
// {
|
|
// LogEntry("API-Token-Anmeldung erfolgreich.", LogLevels.Debug);
|
|
// authorizationState = true;
|
|
// MainWindow.MainInstance.InitializeOrUpdateTrayMenu();
|
|
// }
|
|
// else if (retVal == eM42ApiReason.unauthorized)
|
|
// {
|
|
// LogEntry($"API-Token-Anmeldung nicht erfolgreich. Grund: {retVal}", LogLevels.Debug);
|
|
// ClearRegistryUserInfo();
|
|
// }
|
|
// else
|
|
// {
|
|
// LogEntry($"API-Token-Anmeldung nicht erfolgreich. Grund: {retVal}", LogLevels.Debug);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// LogEntry("User-Infos nicht vorhanden oder Token abgelaufen. Prüfe DefaultCredentials.", LogLevels.Debug);
|
|
|
|
// // ---------------------------------------
|
|
// // 1) Versuch: DefaultCredentials verwenden
|
|
// // ---------------------------------------
|
|
// if (App.DefaultCredentials != null)
|
|
// {
|
|
// LogEntry("DefaultCredentials vorhanden. Versuche Anmeldung via m42WebClient.Open()...", LogLevels.Debug);
|
|
|
|
// m42WebClient = new cM42WebClientV2(
|
|
// GetMatrixServer(false),
|
|
// GetCultureName(),
|
|
// DisableDNSCache: true
|
|
// );
|
|
|
|
// eM42ApiReason retVal = await m42WebClient.Open();
|
|
// LogEntry($"m42WebClient.Open() (DefaultCredentials) => {retVal}", LogLevels.Debug);
|
|
|
|
// if (retVal == eM42ApiReason.ok)
|
|
// {
|
|
// LogEntry("DefaultCredentials-Login erfolgreich. Lese nun UserInfo...", LogLevels.Debug);
|
|
// cM42UserInfoResult result = await m42WebClient.GetUserInfoAsync();
|
|
// rnt_userInfoFromLogin = result.UserInfo;
|
|
|
|
// await ReadConfigAsync();
|
|
|
|
// authorizationState = true;
|
|
// LogEntry("DefaultCredentials-Login abgeschlossen. authorizationState=true", LogLevels.Debug);
|
|
// }
|
|
// else
|
|
// {
|
|
// LogEntry($"DefaultCredentials-Login fehlgeschlagen: {retVal}", LogLevels.Debug);
|
|
// usePassThrough = true;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// // Falls keine DefaultCredentials existieren, direkt PassThrough
|
|
// usePassThrough = true;
|
|
// LogEntry("Keine DefaultCredentials vorhanden. Wechsle zu PassThrough...", LogLevels.Debug);
|
|
// }
|
|
|
|
// // ---------------------------------------
|
|
// // 2) Versuch: PassThrough
|
|
// // ---------------------------------------
|
|
// if (usePassThrough)
|
|
// {
|
|
// LogEntry("Starte PassThrough-Login (m42WebClient.Open() ohne Credentials)...", LogLevels.Debug);
|
|
// m42WebClient = new cM42WebClientV2(GetMatrixServer(false), GetCultureName(), DisableDNSCache: true);
|
|
|
|
// eM42ApiReason retVal = await m42WebClient.Open();
|
|
// LogEntry($"m42WebClient.Open() (PassThrough) => {retVal}", LogLevels.Debug);
|
|
|
|
// if (retVal == eM42ApiReason.ok)
|
|
// {
|
|
// LogEntry("PassThrough-Login erfolgreich. Lese nun UserInfo...", LogLevels.Debug);
|
|
// cM42UserInfoResult result = await m42WebClient.GetUserInfoAsync();
|
|
// rnt_userInfoFromLogin = result.UserInfo;
|
|
// if (result.Reason == eM42ApiReason.unauthorized)
|
|
// {
|
|
// LogEntry("PassThrough: unauthorized. Muss Registrierungsformular anzeigen.", LogLevels.Debug);
|
|
// useRegistrationForm = true;
|
|
// }
|
|
// else
|
|
// {
|
|
// await ReadConfigAsync();
|
|
// authorizationState = true;
|
|
// LogEntry("PassThrough-Login abgeschlossen. authorizationState=true", LogLevels.Debug);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// LogEntry($"PassThrough fehlgeschlagen (unbekannte Ursache): {retVal}", LogLevels.Debug);
|
|
// }
|
|
// }
|
|
|
|
// // ---------------------------------------
|
|
// // 3) Versuch: Anmeldeformular anzeigen
|
|
// // ---------------------------------------
|
|
// if (useRegistrationForm)
|
|
// {
|
|
// // Prüfen, ob schon ein CPM42FormsAuthentication offen ist
|
|
// var existingWindow = Application
|
|
// .Current
|
|
// .Windows
|
|
// .Cast<Window>()
|
|
// .OfType<CPM42FormsAuthentication>()
|
|
// .FirstOrDefault();
|
|
|
|
// if (existingWindow == null)
|
|
// {
|
|
// LogEntry("Zeige Forms-Authentifizierungsdialog an.", LogLevels.Debug);
|
|
// CPM42FormsAuthentication cPM42FormsAuthentication =
|
|
// new CPM42FormsAuthentication();
|
|
|
|
|
|
// cPM42FormsAuthentication.ShowDialog();
|
|
|
|
// if (cPM42FormsAuthentication._successfulAuthorized)
|
|
// {
|
|
// LogEntry("Forms-Authentifizierung erfolgreich.", LogLevels.Debug);
|
|
// var accessToken = cPM42FormsAuthentication.GetAccessToken();
|
|
// if (accessToken != null)
|
|
// {
|
|
// m42WebClient = new cM42WebClientV2(GetMatrixServer(false), GetCultureName(), DisableDNSCache: true);
|
|
// m42WebClient.SetBearerToken(accessToken);
|
|
// await m42WebClient.Open();
|
|
// cM42UserInfoResult result = await m42WebClient.GetUserInfoAsync();
|
|
// rnt_userInfoFromLogin = result.UserInfo;
|
|
// await ReadConfigAsync();
|
|
// WriteRegistryUserInfo();
|
|
|
|
// var readAgain = ReadRegistryUserInfo();
|
|
// LogEntry($"Registry nach Speichern erneut gelesen: {readAgain}", LogLevels.Debug);
|
|
|
|
// // 5) Webclient mit neuem Token initialisieren
|
|
// if (readAgain && userInfo?.EncryptedApiToken != null)
|
|
// {
|
|
// LogEntry("Initialisiere WebClient mit neuem API-Token...", LogLevels.Debug);
|
|
// m42WebClient = new cM42WebClientV2(GetMatrixServer(false), GetCultureName(), DisableDNSCache: true);
|
|
|
|
// var retVal = await m42WebClient.LogonWithApiKeyAsync(userInfo.EncryptedApiToken);
|
|
// LogEntry($"LogonWithApiKeyAsync (nach Formular-Anmeldung) => {retVal}", LogLevels.Debug);
|
|
|
|
// if (retVal == eM42ApiReason.ok)
|
|
// {
|
|
// // Jetzt analog zum bereits existierenden Code Konfiguration laden:
|
|
// await ReadConfigAsync();
|
|
|
|
// authorizationState = true;
|
|
// usingGeneralAPIToken = true;
|
|
// LogEntry("Formular-Anmeldung mit neuem Token erfolgreich. authorizationState=true", LogLevels.Debug);
|
|
// }
|
|
// else
|
|
// {
|
|
// // Falls hier wieder ein Problem auftritt, können Sie weitere Logik einbauen
|
|
// LogEntry("Anmeldung mit neuem Token fehlgeschlagen. " +
|
|
// $"Grund: {retVal}", LogLevels.Debug);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// LogEntry("Registry konnte nicht erneut gelesen werden oder Token war null.", LogLevels.Debug);
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
// else
|
|
// {
|
|
// // Falls abgebrochen oder Auth. fehlgeschlagen:
|
|
// LogEntry("Forms-Authentifizierung fehlgeschlagen oder abgebrochen. Setze App in Offline-Modus.", LogLevels.Debug);
|
|
// MainWindow.MainInstance.OnlineState = MainWindow.enumOnlineState.Offline;
|
|
// MainWindow.MainInstance.InitializeOrUpdateTrayMenu();
|
|
// }
|
|
// }
|
|
|
|
// else
|
|
// {
|
|
// // Es existiert bereits ein Fenster dieses Typs - nach vorne holen
|
|
// existingWindow.Activate();
|
|
// existingWindow.Focus();
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// LogEntry($"Ausnahme in {methodInfo.Name}: {ex.Message}", LogLevels.Debug);
|
|
// LogException(ex);
|
|
// }
|
|
// finally
|
|
// {
|
|
// LogMethodEnd(methodInfo);
|
|
// }
|
|
// MainWindow.MainInstance.OnlineState = authorizationState ? MainWindow.enumOnlineState.Online : MainWindow.enumOnlineState.Offline;
|
|
// MainWindow.MainInstance.OnlineStatusChanged();
|
|
// MainWindow.MainInstance.UpdateTimer();
|
|
// return authorizationState;
|
|
//}
|
|
|
|
|
|
private void FailureSetup(string message)
|
|
{
|
|
LogEntry(message, LogLevels.Error);
|
|
SetDefault();
|
|
|
|
rnt_tryCounter++;
|
|
cpConfig._timerIntervalTicket = 1;
|
|
cpConfig._timerIntervalRegularAnnouncements = 1;
|
|
cpConfig._timerIntervalAdHocAnnouncements = 1;
|
|
if (rnt_tryCounter > 200)
|
|
{
|
|
rnt_tryCounter = 6;
|
|
}
|
|
}
|
|
|
|
/*
|
|
private void SetValues(System.Data.DataTable setupDic)
|
|
{
|
|
try
|
|
{
|
|
_announcementDataView = new Guid(setupDic.Rows[0]["announcementGUID"].ToString());
|
|
}
|
|
catch
|
|
{
|
|
_announcementDataView = new Guid("05168130-f347-c548-aabe-08d390803da6");
|
|
}
|
|
try
|
|
{
|
|
_incidentDataView = new Guid(setupDic.Rows[0]["incidentGUID"].ToString());
|
|
}
|
|
catch
|
|
{
|
|
_incidentDataView = new Guid("375fe36d-83b3-c490-ae69-08d29106a41c");
|
|
}
|
|
|
|
try
|
|
{
|
|
var strVersion = setupDic.Rows[0]["Version"]?.ToString();
|
|
Version.TryParse(strVersion, out _ServerVersion);
|
|
}
|
|
catch
|
|
{
|
|
_ServerVersion = new Version(0, 0, 0, 0);
|
|
}
|
|
|
|
foreach (var Entry in MainFunctionM42Column)
|
|
{
|
|
try
|
|
{
|
|
if (setupDic.Columns.Contains(Entry.Value))
|
|
MainFunctionActivation[Entry.Key] = bool.Parse(setupDic.Rows[0][Entry.Value].ToString());
|
|
}
|
|
catch
|
|
{
|
|
MainFunctionActivation[Entry.Key] = true;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
IsStartApplicationMinimized = bool.Parse(setupDic.Rows[0]["startMinimized"].ToString());
|
|
}
|
|
catch
|
|
{
|
|
IsStartApplicationMinimized = false;
|
|
}
|
|
|
|
try
|
|
{
|
|
IsUUX = bool.Parse(setupDic.Rows[0]["UseUuxLinksInEmails"].ToString());
|
|
WriteUserSetup();
|
|
}
|
|
catch
|
|
{
|
|
IsUUX = false;
|
|
}
|
|
|
|
try
|
|
{
|
|
isDraggable = bool.Parse(setupDic.Rows[0]["isDraggable"].ToString());
|
|
WriteUserSetup();
|
|
}
|
|
catch
|
|
{
|
|
isDraggable = false;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!String.IsNullOrEmpty(setupDic.Rows[0]["activeButtonColor"].ToString()))
|
|
{
|
|
uiColors["activeButtonColor"] = setupDic.Rows[0]["activeButtonColor"].ToString();
|
|
}
|
|
else
|
|
{
|
|
uiColors["activeButtonColor"] = Properties.Resources.activeButtonColor;
|
|
}
|
|
|
|
Application.Current.Resources["activeButtonColor"] = new SolidColorBrush((Color)ColorConverter.ConvertFromString(uiColors["activeButtonColor"]));
|
|
WriteUserSetup();
|
|
}
|
|
catch
|
|
{
|
|
uiColors["activeButtonColor"] = Properties.Resources.activeButtonColor;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!String.IsNullOrEmpty(setupDic.Rows[0]["inactiveButtonColor"].ToString()))
|
|
{
|
|
uiColors["inactiveButtonColor"] = setupDic.Rows[0]["inactiveButtonColor"].ToString();
|
|
}
|
|
else
|
|
{
|
|
uiColors["inactiveButtonColor"] = Properties.Resources.inactiveButtonColor;
|
|
}
|
|
|
|
Application.Current.Resources["inactiveButtonColor"] = new SolidColorBrush((Color)ColorConverter.ConvertFromString(uiColors["inactiveButtonColor"]));
|
|
WriteUserSetup();
|
|
}
|
|
catch
|
|
{
|
|
uiColors["inactiveButtonColor"] = Properties.Resources.inactiveButtonColor;
|
|
}
|
|
try
|
|
{
|
|
if (!String.IsNullOrEmpty(setupDic.Rows[0]["backgroundColor"].ToString()))
|
|
{
|
|
uiColors["backgroundColor"] = setupDic.Rows[0]["backgroundColor"].ToString();
|
|
}
|
|
else
|
|
{
|
|
uiColors["backgroundColor"] = Properties.Resources.backgroundColor;
|
|
}
|
|
|
|
Application.Current.Resources["backgroundColor"] = new SolidColorBrush((Color)ColorConverter.ConvertFromString(uiColors["backgroundColor"]));
|
|
WriteUserSetup();
|
|
}
|
|
catch
|
|
{
|
|
uiColors["backgroundColor"] = Properties.Resources.backgroundColor;
|
|
}
|
|
try
|
|
{
|
|
if (!String.IsNullOrEmpty(setupDic.Rows[0]["headerColor"].ToString()))
|
|
{
|
|
uiColors["headerColor"] = setupDic.Rows[0]["headerColor"].ToString();
|
|
}
|
|
else
|
|
{
|
|
uiColors["headerColor"] = Properties.Resources.headerColor;
|
|
}
|
|
|
|
Application.Current.Resources["headerColor"] = new SolidColorBrush((Color)ColorConverter.ConvertFromString(uiColors["headerColor"]));
|
|
WriteUserSetup();
|
|
}
|
|
catch
|
|
{
|
|
uiColors["headerColor"] = Properties.Resources.headerColor;
|
|
}
|
|
try
|
|
{
|
|
_timerInterval = Int32.Parse(setupDic.Rows[0]["updateInterval"].ToString());
|
|
}
|
|
catch
|
|
{
|
|
_timerInterval = 10;
|
|
}
|
|
try
|
|
{
|
|
_iconColor = Int32.Parse(setupDic.Rows[0]["iconColor"].ToString());
|
|
SetButtonForeground(_iconColor);
|
|
WriteUserSetup();
|
|
}
|
|
catch
|
|
{
|
|
_iconColor = 10;
|
|
SetButtonForeground(_iconColor);
|
|
}
|
|
|
|
try
|
|
{
|
|
_mainIconTextColor = Int32.Parse(setupDic.Rows[0]["mainIconTextColor"].ToString());
|
|
SetButtonForeground(_mainIconTextColor, true);
|
|
WriteUserSetup();
|
|
}
|
|
catch
|
|
{
|
|
_mainIconTextColor = 10;
|
|
SetButtonForeground(_mainIconTextColor, true);
|
|
}
|
|
try
|
|
{
|
|
LogoUrl = setupDic.Rows[0]["logoUrl"].ToString();
|
|
}
|
|
catch
|
|
{
|
|
// ignored
|
|
}
|
|
try
|
|
{
|
|
RemoteAppPath = setupDic.Rows[0]["remoteApp"].ToString();
|
|
WriteUserSetup();
|
|
}
|
|
catch (Exception)
|
|
{ }
|
|
try
|
|
{
|
|
TrayIconUrl = setupDic.Rows[0]["trayIcon"].ToString();
|
|
}
|
|
catch (Exception)
|
|
{ }
|
|
|
|
try
|
|
{
|
|
_linkList = new List<Tuple<string, string>>();
|
|
try
|
|
{
|
|
var L = setupDic.Rows[0]["customLinks"].ToString();
|
|
if (L.Length > 0)
|
|
{
|
|
FillCustomLinkList(L.Split(';'));
|
|
}
|
|
else
|
|
{
|
|
MainFunctionActivation[enumMainFunctions.CustomLinks] = false;
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{ }
|
|
}
|
|
catch (Exception)
|
|
{
|
|
|
|
}
|
|
|
|
MainFunctionActivation[enumMainFunctions.CustomLinks] = cpConfig._linkList.Count > 0;
|
|
|
|
try
|
|
{
|
|
disableClosing = bool.Parse(setupDic.Rows[0]["DisableClosing"].ToString());
|
|
WriteUserSetup();
|
|
}
|
|
catch
|
|
{
|
|
disableClosing = true;
|
|
}
|
|
|
|
} */
|
|
|
|
private void SetValues()
|
|
{
|
|
try
|
|
{
|
|
var uiColors = cpConfig?._uiColors;
|
|
|
|
Color backgroundColor = TryGetConfiguredUiColor(uiColors, "backgroundColor", out Color configuredBackground)
|
|
? configuredBackground
|
|
: ConverterHelper.ColorConvertFromString(Properties.Resources.backgroundColor);
|
|
Color headerColor = TryGetConfiguredUiColor(uiColors, "headerColor", out Color configuredHeader)
|
|
? configuredHeader
|
|
: ConverterHelper.ColorConvertFromString(Properties.Resources.headerColor);
|
|
|
|
bool hasConfiguredActiveColor = TryGetConfiguredUiColor(uiColors, "activeButtonColor", out Color configuredActiveButtonColor);
|
|
bool hasConfiguredInactiveColor = TryGetConfiguredUiColor(uiColors, "inactiveButtonColor", out Color configuredInactiveButtonColor);
|
|
|
|
System.Windows.Application.Current.Resources["headerColor"] = new SolidColorBrush(headerColor);
|
|
ApplyBackgroundDerivedResources(backgroundColor);
|
|
|
|
// Active/Inactive button colors must come directly from config (WebAPI), not be overridden by derived background shades.
|
|
System.Windows.Application.Current.Resources["activeButtonColor"] = new SolidColorBrush(
|
|
hasConfiguredActiveColor ? configuredActiveButtonColor : ConverterHelper.ColorConvertFromString(Properties.Resources.activeButtonColor));
|
|
System.Windows.Application.Current.Resources["inactiveButtonColor"] = new SolidColorBrush(
|
|
hasConfiguredInactiveColor ? configuredInactiveButtonColor : ConverterHelper.ColorConvertFromString(Properties.Resources.inactiveButtonColor));
|
|
|
|
ApplyHeaderDerivedResources(headerColor);
|
|
|
|
LogEntry($"[Theme] activeButtonColor source={(hasConfiguredActiveColor ? "webapi" : "default")} value={((SolidColorBrush)System.Windows.Application.Current.Resources["activeButtonColor"]).Color}", LogLevels.Debug);
|
|
}
|
|
catch
|
|
{
|
|
Color fallbackBackground = ConverterHelper.ColorConvertFromString(Properties.Resources.backgroundColor);
|
|
Color fallbackHeader = ConverterHelper.ColorConvertFromString(Properties.Resources.headerColor);
|
|
Color fallbackActive = ConverterHelper.ColorConvertFromString(Properties.Resources.activeButtonColor);
|
|
Color fallbackInactive = ConverterHelper.ColorConvertFromString(Properties.Resources.inactiveButtonColor);
|
|
|
|
System.Windows.Application.Current.Resources["headerColor"] = new SolidColorBrush(fallbackHeader);
|
|
ApplyBackgroundDerivedResources(fallbackBackground);
|
|
System.Windows.Application.Current.Resources["activeButtonColor"] = new SolidColorBrush(fallbackActive);
|
|
System.Windows.Application.Current.Resources["inactiveButtonColor"] = new SolidColorBrush(fallbackInactive);
|
|
ApplyHeaderDerivedResources(fallbackHeader);
|
|
}
|
|
|
|
try
|
|
{
|
|
// SetButtonThemens();
|
|
//SetButtonForeground(cpConfig._iconColor);
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
cpConfig._iconColor = 10;
|
|
cpConfig._mainIconTextColor = 10;
|
|
var k = e.Message;
|
|
// SetButtonThemens();
|
|
|
|
//SetButtonForeground(cpConfig._iconColor);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
private void FillCustomLinkList(string[] input)
|
|
{
|
|
if (input.Length > 0)
|
|
{
|
|
try
|
|
{
|
|
foreach (string s in input)
|
|
{
|
|
var temp = s.Split(',');
|
|
cpConfig._linkList.Add(temp[1].Trim(), temp[0].Trim());
|
|
temp = null;
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{ }
|
|
}
|
|
}
|
|
*/
|
|
|
|
public async Task<HttpResponseMessage> DownLoadFileAsync(string fileUrl, string destinationPath)
|
|
{
|
|
var CM = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(CM);
|
|
|
|
try
|
|
{
|
|
HttpResponseMessage response = null;
|
|
|
|
using (var _http = m42WebClient.GetHttp())
|
|
{
|
|
response = await _http.GetAsync(fileUrl);
|
|
}
|
|
|
|
if (response != null && response.IsSuccessStatusCode)
|
|
{
|
|
var content = await response.Content.ReadAsByteArrayAsync();
|
|
System.IO.File.WriteAllBytes(destinationPath, content);
|
|
}
|
|
|
|
return response;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
LogMethodEnd(CM);
|
|
}
|
|
}
|
|
|
|
public async Task DownloadLogoAsync()
|
|
{
|
|
if (cpConfig._logoUrl == rnt_LogoUrlPrev)
|
|
return;
|
|
|
|
var CM = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(CM);
|
|
try
|
|
{
|
|
rnt_LogoUrlPrev = cpConfig._logoUrl;
|
|
var LogoFile = GetLogoFilePath(withoutAlternate: true);
|
|
if (!string.IsNullOrEmpty(cpConfig._logoUrl))
|
|
{
|
|
try
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(LogoFile));
|
|
await DownLoadFileAsync(cpConfig._logoUrl, LogoFile);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
System.IO.File.Delete(LogoFile);
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
if (System.IO.File.Exists(LogoFile))
|
|
{
|
|
var FI = new FileInfo(LogoFile);
|
|
if (FI.Length == 0)
|
|
FI.Delete();
|
|
}
|
|
|
|
MainWindow.MainInstance?.RefreshLogo();
|
|
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
finally
|
|
{
|
|
LogMethodEnd(CM);
|
|
}
|
|
|
|
}
|
|
|
|
public async Task DownloadTrayIconAsync()
|
|
{
|
|
if (cpConfig._trayIconUrl == rnt_TrayIconUrlPrev)
|
|
return;
|
|
|
|
var CM = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(CM);
|
|
|
|
try
|
|
{
|
|
var IconFile = GetTrayIconFilePath(true);
|
|
if (!string.IsNullOrEmpty(cpConfig._trayIconUrl))
|
|
{
|
|
try
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(IconFile));
|
|
await DownLoadFileAsync(cpConfig._trayIconUrl, IconFile);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
System.IO.File.Delete(IconFile);
|
|
}
|
|
|
|
if (System.IO.File.Exists(IconFile))
|
|
{
|
|
var FI = new FileInfo(IconFile);
|
|
if (FI.Length == 0)
|
|
FI.Delete();
|
|
}
|
|
|
|
MainWindow.MainInstance?.RefreshTrayIcon();
|
|
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
finally
|
|
{
|
|
LogMethodEnd(CM);
|
|
}
|
|
|
|
}
|
|
|
|
public bool ReadRegistryUserInfo()
|
|
{
|
|
var CM = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(CM);
|
|
|
|
try
|
|
{
|
|
// 1) Registry-Wert lesen
|
|
var regResult = Registry.GetValue(registryHKCUPath, registryUserInformationValueName, null);
|
|
|
|
if (string.IsNullOrEmpty(regResult?.ToString()))
|
|
{
|
|
LogEntry($"Registry Key oder Wert nicht gefunden: {registryHKCUPath}\\{registryUserInformationValueName}", LogLevels.Warning);
|
|
return false;
|
|
}
|
|
|
|
// 2) Dekodieren
|
|
var decodedUserInfo = PrivateCustomerPanelSecurePassword.Instance.Decode(regResult.ToString());
|
|
if (string.IsNullOrEmpty(decodedUserInfo))
|
|
{
|
|
LogEntry("Der dekodierte Registry-Inhalt ist leer.", LogLevels.Warning);
|
|
return false;
|
|
}
|
|
|
|
// 3) Deserialisieren
|
|
var deserialized = JsonConvert.DeserializeObject<UserInfo>(decodedUserInfo);
|
|
if (deserialized == null)
|
|
{
|
|
LogEntry("Deserialisierung von UserInfo aus der Registry fehlgeschlagen.", LogLevels.Warning);
|
|
return false;
|
|
}
|
|
|
|
// 4) Wenn erfolgreich, in `userInfo` übernehmen
|
|
userInfo = deserialized;
|
|
// Zur Debug-Übersicht nur teilweise den Token anzeigen
|
|
LogEntry($"Deserialisierte UserInfo: {userInfo}", LogLevels.Debug);
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogException(ex);
|
|
}
|
|
finally
|
|
{
|
|
LogMethodEnd(CM);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void WriteRegistryUserInfo()
|
|
{
|
|
var methodInfo = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(methodInfo);
|
|
|
|
string userInfoAsJson;
|
|
var userInfoAsObject = JsonConvert.DeserializeObject<UserInfo>(rnt_userInfoFromLogin);
|
|
|
|
try
|
|
{
|
|
|
|
RegistryKey hkcuSoftwareC4It = Registry.CurrentUser.CreateSubKey(hKeyUserPath);
|
|
|
|
LogEntry($"Userinformationen in Registry schreiben:{hKeyUserPath}", LogLevels.Debug);
|
|
|
|
if (hkcuSoftwareC4It != null)
|
|
{
|
|
userInfo.Id = userInfoAsObject.Id;
|
|
userInfo.Email = userInfoAsObject.Email;
|
|
userInfo.EncryptedApiToken = cpConfig._encryptedApiToken;
|
|
userInfo.LoginDate = DateTime.UtcNow;
|
|
userInfo.ExpirationDate = userInfo.LoginDate.AddDays(cpConfig._reloginIntervalDays);
|
|
|
|
userInfoAsJson = JsonConvert.SerializeObject(userInfo);
|
|
|
|
var encryptedUser = PrivateCustomerPanelSecurePassword.Instance.Encode(userInfoAsJson);
|
|
|
|
hkcuSoftwareC4It.SetValue(registryUserInformationValueName, encryptedUser, RegistryValueKind.String);
|
|
}
|
|
else
|
|
{
|
|
LogEntry($"Schreiben der Userinformationen in Registry fehlgeschlagen: {methodInfo.Name}:{hkcuSoftwareC4It}", LogLevels.Debug);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogException(ex);
|
|
LogMethodEnd(methodInfo);
|
|
}
|
|
}
|
|
public bool ClearRegistryUserInfo()
|
|
{
|
|
var CM = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(CM);
|
|
|
|
try
|
|
{
|
|
// Versuche, den Registry-Schlüssel mit Schreibzugriff zu öffnen
|
|
using (var key = Registry.CurrentUser.OpenSubKey(hKeyUserPath, writable: true))
|
|
{
|
|
if (key == null)
|
|
{
|
|
LogEntry($"Registry-Pfad nicht gefunden: {hKeyUserPath}", LogLevels.Warning);
|
|
return false;
|
|
}
|
|
|
|
// Prüfen, ob der Wert überhaupt existiert
|
|
var existingValue = key.GetValue(registryUserInformationValueName);
|
|
if (existingValue == null)
|
|
{
|
|
LogEntry($"Kein UserInfo-Wert zum Löschen gefunden: {hKeyUserPath}\\{registryUserInformationValueName}", LogLevels.Warning);
|
|
return false;
|
|
}
|
|
|
|
// Wert löschen
|
|
key.DeleteValue(registryUserInformationValueName);
|
|
LogEntry($"Registry-Wert gelöscht: {hKeyUserPath}\\{registryUserInformationValueName}", LogLevels.Debug);
|
|
|
|
// Im Speicher gehaltene UserInfo zurücksetzen
|
|
userInfo = new UserInfo();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogException(ex);
|
|
return false;
|
|
}
|
|
finally
|
|
{
|
|
LogMethodEnd(CM);
|
|
}
|
|
}
|
|
|
|
public async Task<bool> ReadConfigAsync(bool force = false)
|
|
{
|
|
try
|
|
{
|
|
string json = null;
|
|
try
|
|
{
|
|
using (var _http = m42WebClient.GetHttp())
|
|
{
|
|
json = await _http.GetApiJsonAsync(String.Format(ApiConfigBaseUrl, local_MatrixServer, force), "");
|
|
}
|
|
|
|
|
|
if (string.IsNullOrEmpty(json) || JsonConvert.DeserializeObject<CustomerPanelConfig>(json) == null)
|
|
return false;
|
|
|
|
cpConfig = JsonConvert.DeserializeObject<CustomerPanelConfig>(json);
|
|
cpConfig._encryptedApiToken = CustomerPanelSecurePassword.Instance.Decode(cpConfig._encryptedApiToken);
|
|
LogEntry($"[Config API] _isDraggable={cpConfig?._isDraggable}", LogLevels.Debug);
|
|
|
|
if (cpConfig?._uiColors != null && cpConfig._uiColors.TryGetValue("activeButtonColor", out string apiActiveColor) && !string.IsNullOrWhiteSpace(apiActiveColor))
|
|
LogEntry($"[Config API] activeButtonColor={apiActiveColor}", LogLevels.Debug);
|
|
else
|
|
LogEntry("[Config API] activeButtonColor missing or empty", LogLevels.Warning);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
throw;
|
|
}
|
|
|
|
SetValues();
|
|
|
|
rnt_tryCounter = 0;
|
|
|
|
return true;
|
|
|
|
}
|
|
catch (WebException webClientException)
|
|
{
|
|
LogException(webClientException);
|
|
FailureSetup(webClientException.Message);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void SetDefault()
|
|
{
|
|
|
|
}
|
|
|
|
private bool WriteUserSetup(bool windowPosChanged=false)
|
|
{
|
|
bool setupOk = true;
|
|
|
|
try
|
|
{
|
|
|
|
RegistryKey hkcuSoftwareC4It = Registry.CurrentUser.CreateSubKey(hKeyUserPath);
|
|
|
|
if (windowPosChanged && hkcuSoftwareC4It != null)
|
|
{
|
|
hkcuSoftwareC4It.SetValue("windowPosition", JsonConvert.SerializeObject(usr_windowPosition), RegistryValueKind.String);
|
|
return true;
|
|
}
|
|
|
|
|
|
RegistryKey hkcuSoftwareC4ItAuth = Registry.CurrentUser.CreateSubKey(hKeyAuthPath);
|
|
|
|
if (hkcuSoftwareC4It != null)
|
|
{
|
|
hkcuSoftwareC4It.SetValue("userLanguage", usr_userLanguage, RegistryValueKind.DWord);
|
|
hkcuSoftwareC4It.SetValue("PresentationMode", (int)usr_PresentationMode, RegistryValueKind.DWord);
|
|
hkcuSoftwareC4It.SetValue("notifierEnabled", usr_enableNotifier, RegistryValueKind.DWord);
|
|
}
|
|
|
|
RegistryKey hkcuSoftwareC4ItConfig = Registry.CurrentUser.CreateSubKey(hKeyConfigPath);
|
|
if (hkcuSoftwareC4ItConfig != null)
|
|
{
|
|
var configJson = JsonConvert.SerializeObject(cpConfig);
|
|
hkcuSoftwareC4ItConfig.SetValue("config", configJson, RegistryValueKind.String);
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
setupOk = false;
|
|
}
|
|
return setupOk;
|
|
|
|
}
|
|
|
|
private void SetButtonForeground(int iconColor, bool mainColor = false)
|
|
{
|
|
|
|
if (mainColor)
|
|
{
|
|
if (iconColor != 0)
|
|
{
|
|
if (iconColor == 10)
|
|
{
|
|
|
|
System.Windows.Application.Current.Resources.MergedDictionaries.Add(MainWindow.MainInstance?._darkThemeMain);
|
|
|
|
|
|
|
|
|
|
|
|
// Application.Current.Resources["mainForeground"] = new SolidColorBrush((Color)System.Windows.Media.Colors.Black);
|
|
}
|
|
else if (iconColor == 20)
|
|
{
|
|
|
|
System.Windows.Application.Current.Resources.MergedDictionaries.Add(MainWindow.MainInstance?._lightThemeMain);
|
|
|
|
|
|
// Application.Current.Resources["mainForeground"] = new SolidColorBrush((Color)System.Windows.Media.Colors.White);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Application.Current.Resources["mainForeground"] = new SolidColorBrush((Color)System.Windows.Media.Colors.White);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (iconColor != 0)
|
|
{
|
|
if (iconColor == 10)
|
|
{
|
|
|
|
System.Windows.Application.Current.Resources.MergedDictionaries.Add(MainWindow.MainInstance?._darkThemeNav);
|
|
//Application.Current.Resources["navForeground"] = new SolidColorBrush((Color)System.Windows.Media.Colors.Black);
|
|
}
|
|
else if (iconColor == 20)
|
|
{
|
|
|
|
System.Windows.Application.Current.Resources.MergedDictionaries.Add(MainWindow.MainInstance?._lightThemeNav);
|
|
|
|
//Application.Current.Resources["navForeground"] = new SolidColorBrush((Color)System.Windows.Media.Colors.White);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Application.Current.Resources["navForeground"] = new SolidColorBrush((Color)System.Windows.Media.Colors.White);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public static void SaveAsJson(string Name, object O, string subKey = null)
|
|
{
|
|
var CM = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(CM);
|
|
try
|
|
{
|
|
var strValue = JsonConvert.SerializeObject(O);
|
|
RegistryKey hkcuSoftware;
|
|
if (String.IsNullOrEmpty(subKey))
|
|
{
|
|
hkcuSoftware = Registry.CurrentUser.OpenSubKey("Software\\Consulting4IT GmbH\\Customer Panel", true);
|
|
}
|
|
else
|
|
{
|
|
hkcuSoftware = Registry.CurrentUser.OpenSubKey("Software\\Consulting4IT GmbH\\Customer Panel\\" + subKey, true);
|
|
}
|
|
if (hkcuSoftware != null)
|
|
{
|
|
hkcuSoftware.SetValue(Name, strValue);
|
|
}
|
|
else
|
|
{
|
|
hkcuSoftware = Registry.CurrentUser.CreateSubKey("Software\\Consulting4IT GmbH\\Customer Panel\\" + subKey, true);
|
|
hkcuSoftware.SetValue(Name, strValue);
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
finally
|
|
{
|
|
LogMethodEnd(CM);
|
|
}
|
|
}
|
|
|
|
public static T LoadFromJson<T>(string Name, string subKey = null)
|
|
{
|
|
var CM = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(CM);
|
|
try
|
|
{
|
|
RegistryKey hkcuSoftware;
|
|
if (String.IsNullOrEmpty(subKey))
|
|
{
|
|
hkcuSoftware = Registry.CurrentUser.OpenSubKey("Software\\Consulting4IT GmbH\\Customer Panel", true);
|
|
}
|
|
else
|
|
{
|
|
hkcuSoftware = Registry.CurrentUser.OpenSubKey("Software\\Consulting4IT GmbH\\Customer Panel\\" + subKey, true);
|
|
}
|
|
|
|
if (hkcuSoftware != null)
|
|
{
|
|
var objValue = hkcuSoftware.GetValue(Name);
|
|
var strValue = objValue?.ToString();
|
|
if (!string.IsNullOrEmpty(strValue))
|
|
{
|
|
var RetVal = JsonConvert.DeserializeObject<T>(strValue);
|
|
return RetVal;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
finally
|
|
{
|
|
LogMethodEnd(CM);
|
|
}
|
|
|
|
return default;
|
|
}
|
|
|
|
public T getConfigSetting<T>(string setting)
|
|
{
|
|
return (T)cpConfig.GetType().GetProperty(setting).GetValue(cpConfig, null);
|
|
}
|
|
|
|
private string getStringFromRegistry(RegistryKey Key, string Name)
|
|
{
|
|
try
|
|
{
|
|
var _regVal = Key.GetValue(Name);
|
|
if (_regVal is string regValue && !string.IsNullOrEmpty(regValue))
|
|
return regValue;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private bool? getBoolFromRegistry(RegistryKey Key, string Name)
|
|
{
|
|
try
|
|
{
|
|
var _regVal = Key.GetValue(Name);
|
|
if (_regVal != null)
|
|
return ConverterHelper.ObjectToBoolConverter(_regVal);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void ReadUserSetup()
|
|
{
|
|
try
|
|
{
|
|
RegistryKey hkcuSoftware = Registry.CurrentUser.CreateSubKey(hKeyAppPath, true);
|
|
RegistryKey hkcuSoftwareUsr = Registry.CurrentUser.CreateSubKey(hKeyUserPath, true);
|
|
RegistryKey hkcuSoftwareConfig = Registry.CurrentUser.CreateSubKey(hKeyConfigPath, true);
|
|
RegistryKey hkcuSoftwareAuth = Registry.CurrentUser.CreateSubKey(hKeyAuthPath, true);
|
|
RegistryKey hkcuDPI = Registry.CurrentUser.CreateSubKey("Control Panel\\Desktop\\WindowMetrics", true);
|
|
RegistryKey hklmDefaultUserKey = GetLocalMaschineHive().OpenSubKey(hKeyDefaultUserSettingsPath, false);
|
|
|
|
if (hkcuSoftware != null)
|
|
{
|
|
|
|
if (Int32.TryParse(hkcuSoftware.GetValue("isInternalTesting")?.ToString(), out var iTesting))
|
|
if (iTesting > 0)
|
|
_isInternalTesting = true;
|
|
|
|
object objLang = hkcuSoftwareUsr.GetValue("userLanguage");
|
|
if (objLang == null && hklmDefaultUserKey != null)
|
|
objLang = hklmDefaultUserKey.GetValue("userLanguage");
|
|
if (!Int32.TryParse((objLang ?? "0").ToString(), out usr_userLanguage))
|
|
usr_userLanguage = 0;
|
|
|
|
object objNotifier = hkcuSoftwareUsr.GetValue("notifierEnabled");
|
|
if (objNotifier == null && hklmDefaultUserKey != null)
|
|
objNotifier = hklmDefaultUserKey.GetValue("notifierEnabled");
|
|
usr_enableNotifier = ConverterHelper.ObjectToBoolConverter(objNotifier);
|
|
|
|
object objPres = hkcuSoftwareUsr.GetValue("PresentationMode");
|
|
if (objPres == null && hklmDefaultUserKey != null)
|
|
objPres = hklmDefaultUserKey.GetValue("PresentationMode");
|
|
|
|
if (objPres != null && Int32.TryParse(objPres.ToString(), out var iPresMode))
|
|
{
|
|
switch (iPresMode)
|
|
{
|
|
case (int)enumPresentationMode.On:
|
|
usr_PresentationMode = enumPresentationMode.On;
|
|
break;
|
|
case (int)enumPresentationMode.Off:
|
|
usr_PresentationMode = enumPresentationMode.Off;
|
|
break;
|
|
default:
|
|
usr_PresentationMode = enumPresentationMode.OS;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fallback auf dndMode (alt)
|
|
if (Int32.TryParse(hkcuSoftwareUsr.GetValue("dndMode")?.ToString(), out var intDND)
|
|
&& intDND == 1)
|
|
{
|
|
usr_PresentationMode = enumPresentationMode.On;
|
|
}
|
|
}
|
|
try
|
|
{
|
|
|
|
var configJson = hkcuSoftwareConfig.GetValue("config")?.ToString();
|
|
if (!String.IsNullOrEmpty(configJson))
|
|
{
|
|
cpConfig = JsonConvert.DeserializeObject<CustomerPanelConfig>(configJson);
|
|
|
|
}
|
|
|
|
}
|
|
catch
|
|
{
|
|
//windowPosition = JsonConvert.DeserializeObject<Point>(tmpPos);
|
|
|
|
}
|
|
foreach (KeyValuePair<String, String> co in cpConfig._uiColors)
|
|
{
|
|
try
|
|
{
|
|
System.Windows.Application.Current.Resources[co.Key] = new SolidColorBrush((Color)ColorConverter.ConvertFromString(co.Value));
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
var User = (hkcuSoftware.GetValue("UserName") ?? "").ToString();
|
|
var Password = (hkcuSoftware.GetValue("Password") ?? "").ToString();
|
|
if (!string.IsNullOrEmpty(User) && !string.IsNullOrEmpty(Password))
|
|
{
|
|
var Creds = new NetworkCredential(User, Password);
|
|
App.DefaultCredentials = Creds;
|
|
}
|
|
|
|
//if (!Int32.TryParse((hkcuSoftware.GetValue("disableClosing") ?? "0").ToString(), out tmpInt))
|
|
// tmpInt = 0;
|
|
//disableClosing = tmpInt != 0;
|
|
}
|
|
if (hkcuDPI != null)
|
|
{
|
|
local_currentDPI = Int32.Parse(hkcuDPI.GetValue("AppliedDPI").ToString());
|
|
}
|
|
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
public static RegistryKey GetLocalMaschineHive()
|
|
{
|
|
return RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32);
|
|
}
|
|
|
|
private void ReadMachineSetup(bool fromUser)
|
|
{
|
|
try
|
|
{
|
|
RegistryKey baseHive = fromUser ? Registry.CurrentUser : GetLocalMaschineHive();
|
|
RegistryKey hklmC4ItSetupPath = baseHive.OpenSubKey(hKeyAppPath, false);
|
|
|
|
if (hklmC4ItSetupPath == null)
|
|
{
|
|
if (!fromUser)
|
|
LogEntry($"Configuration registry path not found: {hKeyAppPath}", LogLevels.Error);
|
|
return;
|
|
}
|
|
|
|
var _regVal = hklmC4ItSetupPath.GetValue("MatrixServer");
|
|
if (_regVal != null)
|
|
{
|
|
string rawValue = _regVal.ToString();
|
|
string fqdn = rawValue; // Default: so übernehmen, wie es in der Registry steht
|
|
|
|
if (Uri.IsWellFormedUriString(rawValue, UriKind.Absolute))
|
|
{
|
|
try
|
|
{
|
|
var uri = new Uri(rawValue);
|
|
fqdn = uri.Host;
|
|
LogEntry($"Registry-Wert MatrixServer war eine URL. Nur Hostnamen '{fqdn}' wird verwendet.", LogLevels.Debug);
|
|
}
|
|
catch (UriFormatException)
|
|
{
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (rawValue.Contains("/"))
|
|
{
|
|
string attempt = "https://" + rawValue;
|
|
if (Uri.IsWellFormedUriString(attempt, UriKind.Absolute))
|
|
{
|
|
try
|
|
{
|
|
var uri = new Uri(attempt);
|
|
fqdn = uri.Host;
|
|
LogEntry($"Registry-Wert MatrixServer enthielt Pfad ohne Schema. Nur Hostnamen '{fqdn}' wird verwendet.", LogLevels.Debug);
|
|
}
|
|
catch (UriFormatException)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
local_MatrixServer = fqdn;
|
|
}
|
|
|
|
_regVal = hklmC4ItSetupPath.GetValue("ShowIpInfoOnlyInCorporateNetwork");
|
|
if (_regVal != null)
|
|
{
|
|
ShowIpInfoOnlyInCorporateNetwork = ConverterHelper.ObjectToBoolConverter(_regVal);
|
|
}
|
|
|
|
_regVal = hklmC4ItSetupPath.GetValue("CustomerPanelTitle");
|
|
if (_regVal is string regValue && !string.IsNullOrEmpty(regValue))
|
|
{
|
|
CustomerPanelTitle = regValue;
|
|
}
|
|
|
|
_regVal = hklmC4ItSetupPath.GetValue("AnnouncementView");
|
|
if (_regVal is int regValue_AnnView)
|
|
{
|
|
AnnouncementView = regValue_AnnView;
|
|
}
|
|
|
|
_regVal = hklmC4ItSetupPath.GetValue("CustomAnnouncementText");
|
|
if (_regVal is string regValue_AnnText && !string.IsNullOrEmpty(regValue_AnnText))
|
|
{
|
|
CustomAnnouncementText = regValue_AnnText;
|
|
}
|
|
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public class ConfigClassV2
|
|
{
|
|
public const string constRegPathConfig = @"SOFTWARE\Consulting4IT GmbH\Customer Panel";
|
|
|
|
[RegConfig(ReadOnly: true)]
|
|
public string MsGateway_TenantId { get; private set; } = string.Empty;
|
|
|
|
[RegConfig(ReadOnly: true)]
|
|
public string MsGateway_ApplicationId { get; private set; } = string.Empty;
|
|
|
|
[RegConfig(ReadOnly: true)]
|
|
public string MsGateway_Scope { get; private set; } = string.Empty;
|
|
|
|
[RegConfigSubItem("authentication")]
|
|
public ConfigAuthentication Authentication { get; set; } = new ConfigAuthentication();
|
|
|
|
public static ConfigClassV2 Instance = null;
|
|
|
|
static ConfigClassV2()
|
|
{
|
|
Instance = new ConfigClassV2();
|
|
Instance.Load();
|
|
Instance.Save();
|
|
}
|
|
|
|
public void Load()
|
|
{
|
|
cConfigRegistryHelper.Load(constRegPathConfig, this);
|
|
}
|
|
|
|
public void Save(string fullPropertyName = null)
|
|
{
|
|
cConfigRegistryHelper.Save(constRegPathConfig, this, fullPropertyName);
|
|
}
|
|
|
|
public bool MsGateway_Enabled
|
|
{
|
|
get
|
|
{
|
|
return !string.IsNullOrEmpty(MsGateway_TenantId) &&
|
|
!string.IsNullOrEmpty(MsGateway_ApplicationId) &&
|
|
!string.IsNullOrEmpty(MsGateway_Scope);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ConfigAuthentication
|
|
{
|
|
[RegConfig]
|
|
public bool noPassthrough { get; set; } = default;
|
|
|
|
[RegConfig]
|
|
public bool noLogonAtAll { get; set; } = default;
|
|
|
|
[RegConfig]
|
|
public enumAlternateAuthMethods additionalMethod { get; set; } = default;
|
|
|
|
[RegConfig]
|
|
public string BasicUsername { get; set; } = string.Empty;
|
|
|
|
[RegConfig]
|
|
public string BasicPassword { get; set; } = string.Empty;
|
|
|
|
[RegConfig]
|
|
public string M42AccessToken { get; set; } = string.Empty;
|
|
|
|
|
|
}
|
|
}
|