1213 lines
40 KiB
C#
1213 lines
40 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Data.SqlClient;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Text.RegularExpressions;
|
|
using System.Runtime.InteropServices;
|
|
using System.Security.Principal;
|
|
using System.Net;
|
|
using System.Diagnostics;
|
|
using System.Security.Cryptography;
|
|
using System.Globalization;
|
|
using System.DirectoryServices;
|
|
using System.DirectoryServices.Protocols;
|
|
using System.Management;
|
|
using System.Linq;
|
|
using System.Net.Sockets;
|
|
using System.Threading;
|
|
|
|
namespace De.Lambertz.Essentials
|
|
{
|
|
public class EssentialTools
|
|
{
|
|
//private static String smtpServer = "MAIL01AC"; //StandortIndex 1
|
|
private static String smtpServer = "mail.intra.lambertz.de"; //StandortIndex 1
|
|
private static String smtpServerPolen = "mail.intra.lambertz.de"; //StandortIndex 2
|
|
private static int standortIndex = 0;
|
|
private static CultureInfo germanCultureInfo = new CultureInfo("de-DE");
|
|
private static bool isDeveleoperPC = false;
|
|
private static bool isDeveleoperPCGeprüft = false;
|
|
private const string ERLAUBTE_SUBNETZE = "|20|21|22|23|24|25|1|4|14|8|33|0|9|44|5|111|115|116|118|112|119|114|117|22|24|10|11|12|199|";
|
|
//private const int ERROR_LOGON_FAILURE = 0x31;
|
|
|
|
public static bool ValidatePassword(string password)
|
|
{
|
|
String usernameWithDomain = WindowsIdentity.GetCurrent().Name;
|
|
return ValidateCredentials(usernameWithDomain, password);
|
|
}
|
|
|
|
public static string MaximalLängePrüfen(String text, int maximalLänge, bool istDateiname = false)
|
|
{
|
|
string result = text;
|
|
|
|
if(result.Length>maximalLänge)
|
|
{
|
|
if(istDateiname)
|
|
{
|
|
String endung = Path.GetExtension(result);
|
|
result = result.Substring(0, maximalLänge-endung.Length);
|
|
result = result + endung;
|
|
}
|
|
else
|
|
{
|
|
result = result.Substring(0, maximalLänge);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static bool IsFileReady(string filePath, int retryCount, int delay)
|
|
{
|
|
for (int i = 0; i < retryCount; i++)
|
|
{
|
|
try
|
|
{
|
|
// Versuche die Datei exklusiv zu öffnen
|
|
using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None))
|
|
{
|
|
if (stream.Length > 0)
|
|
{
|
|
// Datei konnte exklusiv geöffnet werden
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
catch (IOException)
|
|
{
|
|
// Warte, falls Datei noch in Benutzung ist
|
|
Thread.Sleep(delay);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool IsDeveloperPC()
|
|
{
|
|
if (!isDeveleoperPCGeprüft)
|
|
{
|
|
if ((Environment.MachineName == "NAC666" && EssentialTools.GetCpuID() == "BFEBFBFF000A0652") || (Environment.MachineName == "NAC521" && EssentialTools.GetCpuID() == "BFEBFBFF000806EC"))
|
|
{
|
|
isDeveleoperPC = true;
|
|
}
|
|
isDeveleoperPCGeprüft = true;
|
|
}
|
|
return isDeveleoperPC;
|
|
}
|
|
public static string GetCpuID()
|
|
{
|
|
string cpuid = string.Empty;
|
|
ManagementClass man = new ManagementClass("win32_processor");
|
|
ManagementObjectCollection moc = man.GetInstances();
|
|
foreach (ManagementObject mob in moc)
|
|
{
|
|
if (cpuid == "")
|
|
{
|
|
// Nimmt vom ersten CPU die ID und bricht dann ab.
|
|
cpuid = mob.Properties["processorID"].Value.ToString();
|
|
break;
|
|
}
|
|
}
|
|
return cpuid;
|
|
}
|
|
public static int CountWeekdays(DateTime startTime, DateTime endTime)
|
|
{
|
|
TimeSpan timeSpan = endTime - startTime;
|
|
DateTime dateTime;
|
|
int weekdays = 0;
|
|
for (int i = 0; i < timeSpan.Days; i++)
|
|
{
|
|
dateTime = startTime.AddDays(i);
|
|
if (IsWeekDay(dateTime))
|
|
weekdays++;
|
|
}
|
|
return weekdays;
|
|
}
|
|
|
|
public static bool IsWeekDay(DateTime dateTime)
|
|
{
|
|
return ((dateTime.DayOfWeek != DayOfWeek.Saturday) && (dateTime.DayOfWeek != DayOfWeek.Sunday));
|
|
}
|
|
|
|
public static IPAddress LokaleIPAdresse(bool bereichPrüfen = true)
|
|
{
|
|
IPAddress result = null;
|
|
|
|
try
|
|
{
|
|
string[] adressen = null;
|
|
|
|
ManagementObjectSearcher NetworkInfo = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled = 'TRUE'");
|
|
ManagementObjectCollection MOC = NetworkInfo.Get();
|
|
foreach (ManagementObject mo in MOC)
|
|
{
|
|
adressen = (string[])mo["IPAddress"];
|
|
}
|
|
|
|
if (adressen != null)
|
|
{
|
|
foreach (String adresse in adressen)
|
|
{
|
|
if (adresse.Contains("."))
|
|
{
|
|
try
|
|
{
|
|
String[] x = adresse.ToString().Split(".".ToCharArray());
|
|
if (!bereichPrüfen || ERLAUBTE_SUBNETZE.Contains("|" + x[2] + "|"))
|
|
{
|
|
result = new IPAddress(ipToByteArray(adresse));
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
System.Net.IPHostEntry host = System.Net.Dns.GetHostEntry("");
|
|
//System.Net.IPAddress myIP = null;
|
|
foreach (System.Net.IPAddress a in host.AddressList)
|
|
{
|
|
if (a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
|
|
{
|
|
String[] x = a.ToString().Split(".".ToCharArray());
|
|
if (!bereichPrüfen || ERLAUBTE_SUBNETZE.Contains("|" + x[2] + "|"))
|
|
{
|
|
result = a;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static byte[] ipToByteArray(string Value)
|
|
{
|
|
string[] Temp = Value.Split('.');
|
|
int Length = Temp.Length;
|
|
byte[] Rueckgabe = new byte[Length];
|
|
for (int i = 0; i < Length; i++)
|
|
{
|
|
Rueckgabe[i] = Convert.ToByte(Convert.ToInt32(Temp[i]));
|
|
}
|
|
return Rueckgabe;
|
|
}
|
|
|
|
public static bool ValidateCredentials(string usernameWithDomain, string password)
|
|
{
|
|
String username = usernameWithDomain.Substring(usernameWithDomain.IndexOf("\\") + 1);
|
|
String domain = usernameWithDomain.Substring(0, usernameWithDomain.IndexOf("\\"));
|
|
|
|
return ValidateCredentials(username, password, domain);
|
|
}
|
|
public static bool ValidateCredentials(string username, string password, string domain)
|
|
{
|
|
if (!String.IsNullOrEmpty(username) && !String.IsNullOrEmpty(password) && !String.IsNullOrEmpty(domain))
|
|
{
|
|
NetworkCredential credentials = new NetworkCredential(username, password, domain);
|
|
|
|
LdapDirectoryIdentifier id = new LdapDirectoryIdentifier(domain);
|
|
|
|
using (LdapConnection connection = new LdapConnection(id, credentials, AuthType.Kerberos))
|
|
{
|
|
connection.SessionOptions.Sealing = true;
|
|
connection.SessionOptions.Signing = true;
|
|
|
|
try
|
|
{
|
|
connection.Bind();
|
|
}
|
|
catch (LdapException)
|
|
{
|
|
//if (ERROR_LOGON_FAILURE == lEx.ErrorCode)
|
|
//{
|
|
return false;
|
|
//}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static CultureInfo GermanCultureInfo
|
|
{
|
|
get { return EssentialTools.germanCultureInfo; }
|
|
}
|
|
|
|
//public static void SetFont(Form f)
|
|
//{
|
|
// // f.Font = new System.Drawing.Font("Arial", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
|
|
//}
|
|
|
|
public static float Scalefont(float originalSize, IntPtr handle)
|
|
{
|
|
float result = originalSize;
|
|
|
|
|
|
Graphics g = Graphics.FromHwnd(handle);
|
|
float dx = g.DpiX;
|
|
|
|
if (dx > 110)
|
|
{
|
|
result = result * 110 / dx;
|
|
}
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
public static DateTime TagAnfang(DateTime datum)
|
|
{
|
|
return new DateTime(datum.Year, datum.Month, datum.Day, 0, 0, 0);
|
|
}
|
|
|
|
public static DateTime TagEnde(DateTime datum)
|
|
{
|
|
return new DateTime(datum.Year, datum.Month, datum.Day, 23, 59, 59);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prüft ob eine Date mit selben Namen schon vorhanden ist
|
|
/// und hängt ggfs. eine laufende Nummer an
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <returns></returns>
|
|
public static string CheckFileName(string name)
|
|
{
|
|
name = cleanFilename(name);
|
|
|
|
bool nameOK = false;
|
|
int i = 0;
|
|
while (!nameOK)
|
|
{
|
|
nameOK = true;
|
|
FileInfo fi = new FileInfo(name);
|
|
if (fi.Exists)
|
|
{
|
|
//Datei vorhanden. Name muss verändert werden...
|
|
i++;
|
|
string part2 = name.Substring(name.LastIndexOf("."));
|
|
|
|
string part1 = name.Substring(0, name.Length - part2.Length);
|
|
int c = extractCounter(name);
|
|
if (c > 0)
|
|
{
|
|
string temp = part1.Substring(0, part1.Length - c.ToString().Length);
|
|
if (temp.EndsWith("_"))
|
|
{
|
|
part1 = part1.Substring(0, part1.LastIndexOf("_"));
|
|
i = c + 1;
|
|
}
|
|
}
|
|
StringBuilder neuerName = new StringBuilder();
|
|
neuerName.Append(part1);
|
|
neuerName.Append("_");
|
|
neuerName.Append(i.ToString());
|
|
neuerName.Append(part2);
|
|
//
|
|
name = neuerName.ToString();
|
|
nameOK = false;
|
|
}
|
|
}
|
|
return name;
|
|
}
|
|
|
|
private static int extractCounter(string filename)
|
|
{
|
|
string pattern = @"_(\d+)\.[a-zA-Z0-9]+$";
|
|
|
|
Match match = Regex.Match(filename, pattern);
|
|
if (match.Success)
|
|
{
|
|
// Extrahiere die gefundene Zahl und gib sie als Integer zurück
|
|
return int.Parse(match.Groups[1].Value);
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
private static string cleanFilename(string filename)
|
|
{
|
|
string result;
|
|
|
|
String pfad = Path.GetDirectoryName(filename);
|
|
|
|
String datei = Path.GetFileName(filename);
|
|
// Definiere das Muster für ungültige Zeichen
|
|
string pattern = @"[\\/:*?""<>|]";
|
|
//Ersetze ungültige Zeichen durch einen Unterstrich
|
|
datei = Regex.Replace(datei, pattern, " ");
|
|
|
|
result = Path.Combine(pfad, datei);
|
|
|
|
return result;
|
|
}
|
|
|
|
public static bool IsNumeric(object expression)
|
|
{
|
|
bool isNum = false;
|
|
if (expression != null)
|
|
{
|
|
double retNum;
|
|
isNum = double.TryParse(Convert.ToString(expression), out retNum);
|
|
}
|
|
return isNum;
|
|
}
|
|
|
|
public static bool IsNumericInteger(object expression)
|
|
{
|
|
bool isNum = false;
|
|
if (expression != null)
|
|
{
|
|
int retNum;
|
|
isNum = int.TryParse(Convert.ToString(expression), out retNum);
|
|
}
|
|
return isNum;
|
|
}
|
|
|
|
public static string ZeilenUmbrücheEntfernen(String text, String token = " ")
|
|
{
|
|
String result = text.Replace("\r\n", token);
|
|
result = result.Replace("\n\n", token);
|
|
result = result.Replace("\n\n\n", token);
|
|
result = result.Replace("\r", "");
|
|
result = result.Replace("\n", token);
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string AbweichungBerechnen(double aktuell, double vorjahr)
|
|
{
|
|
string result = null;
|
|
|
|
if (aktuell != 0 && vorjahr != 0)
|
|
{
|
|
double e;
|
|
if (vorjahr == 0)
|
|
{
|
|
e = 0;
|
|
}
|
|
else
|
|
{
|
|
e = (aktuell - vorjahr) / vorjahr * 100;
|
|
}
|
|
|
|
if (e > 500)
|
|
{
|
|
result = "-";
|
|
}
|
|
else if (e < -100)
|
|
{
|
|
result = "-";
|
|
}
|
|
else
|
|
{
|
|
result = e.ToString("0.0");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = "0";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string GetBaseTempPath()
|
|
{
|
|
return GetBaseTempPath(null);
|
|
}
|
|
|
|
public static string GetBaseTempPath(string add)
|
|
{
|
|
string userBasePath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
|
|
userBasePath = Path.Combine(userBasePath, "LambertzPortal");
|
|
//MessageBox.Show(userBasePath);
|
|
if (!String.IsNullOrEmpty(add))
|
|
{
|
|
userBasePath = Path.Combine(userBasePath, add);
|
|
}
|
|
DirectoryInfo di = new DirectoryInfo(userBasePath);
|
|
if (!di.Exists)
|
|
{
|
|
di.Create();
|
|
}
|
|
|
|
return userBasePath;
|
|
}
|
|
|
|
//public static DataGridViewCellStyle FormatiereZeile(System.Drawing.Color hintergrundfarbe, System.Drawing.Color schriftfarbe, bool fett)
|
|
//{
|
|
// DataGridViewCellStyle result = new DataGridViewCellStyle();
|
|
// result.BackColor = hintergrundfarbe;
|
|
// result.ForeColor = schriftfarbe;
|
|
// if (fett)
|
|
// {
|
|
// System.Drawing.Font f = new System.Drawing.Font("Arial", 8.25f, FontStyle.Bold);
|
|
// result.Font = f;
|
|
// }
|
|
// else
|
|
// {
|
|
// System.Drawing.Font f = new System.Drawing.Font("Arial", 8.25f, FontStyle.Regular);
|
|
// result.Font = f;
|
|
// }
|
|
// return result;
|
|
//}
|
|
|
|
public static bool IsEmail(string inputEmail)
|
|
{
|
|
bool result = false;
|
|
if (!String.IsNullOrEmpty(inputEmail))
|
|
{
|
|
string strRegex = @"^([a-zA-Z0-9|ü|ä|ö|Ü|Ä|Ö_\-\.]+)@((\[[0-9]{1,3}" +
|
|
@"\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\" +
|
|
@".)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$";
|
|
Regex re = new Regex(strRegex);
|
|
if (re.IsMatch(inputEmail))
|
|
{
|
|
result = true;
|
|
}
|
|
//Zusatz für ExchangeMails...
|
|
if (!result)
|
|
{
|
|
inputEmail = inputEmail.ToLower();
|
|
if (inputEmail.Contains(@"/cn=") && inputEmail.Contains(@"/ou=") && inputEmail.Substring(0, 3) == "/o=")
|
|
{
|
|
result = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
[DllImport("User32.dll")]
|
|
static extern bool SetForegroundWindow(IntPtr hWnd);
|
|
|
|
[DllImport("User32.dll")]
|
|
public static extern int AttachThreadInput(IntPtr idAttach, IntPtr idAttachTo, bool fAttach);
|
|
|
|
[DllImport("User32.dll")]
|
|
public static extern IntPtr GetForegroundWindow();
|
|
|
|
[DllImport("User32.dll")]
|
|
public static extern IntPtr GetWindowThreadProcessId(IntPtr hwnd, IntPtr lpdwProcessId);
|
|
|
|
[DllImport("user32.dll")]
|
|
static extern bool AllowSetForegroundWindow(int procID);
|
|
|
|
//public static void SetForegroundWindowEx(Form window)
|
|
//{
|
|
// IntPtr hndl = window.Handle;
|
|
// IntPtr threadID1 = GetWindowThreadProcessId(GetForegroundWindow(), IntPtr.Zero);
|
|
// IntPtr threadID2 = GetWindowThreadProcessId(hndl, IntPtr.Zero);
|
|
// window.TopMost = true;
|
|
|
|
// if (threadID1 == threadID2)
|
|
// {
|
|
// SetForegroundWindow(hndl);
|
|
// }
|
|
// else
|
|
// {
|
|
// AttachThreadInput(threadID2, threadID1, true);
|
|
// SetForegroundWindow(hndl); ;
|
|
// AttachThreadInput(threadID2, threadID1, false);
|
|
// }
|
|
//}
|
|
|
|
public static void SetForegroundWindowEx(IntPtr hndl)
|
|
{
|
|
IntPtr threadID1 = GetWindowThreadProcessId(GetForegroundWindow(), IntPtr.Zero);
|
|
IntPtr threadID2 = GetWindowThreadProcessId(hndl, IntPtr.Zero);
|
|
|
|
if (threadID1 == threadID2)
|
|
{
|
|
SetForegroundWindow(hndl);
|
|
}
|
|
else
|
|
{
|
|
AttachThreadInput(threadID2, threadID1, true);
|
|
SetForegroundWindow(hndl); ;
|
|
AttachThreadInput(threadID2, threadID1, false);
|
|
}
|
|
}
|
|
|
|
public static String AlleIPAdressen()
|
|
{
|
|
String result = "";
|
|
String token = "";
|
|
bool weg2 = true;
|
|
|
|
try
|
|
{
|
|
string[] adressen = null;
|
|
ManagementObjectSearcher NetworkInfo = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled = 'TRUE'");
|
|
ManagementObjectCollection MOC = NetworkInfo.Get();
|
|
foreach (ManagementObject mo in MOC)
|
|
{
|
|
adressen = (string[])mo["IPAddress"];
|
|
}
|
|
foreach (String a in adressen)
|
|
{
|
|
if (a.Contains("."))
|
|
{
|
|
result = result + token + a;
|
|
token = ", ";
|
|
|
|
weg2 = false;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
if(String.IsNullOrEmpty(result))
|
|
{
|
|
weg2 = true;
|
|
}
|
|
}
|
|
|
|
if(weg2)
|
|
{
|
|
System.Net.IPHostEntry host = System.Net.Dns.GetHostEntry("");
|
|
foreach (System.Net.IPAddress a in host.AddressList)
|
|
{
|
|
if (a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
|
|
{
|
|
|
|
try
|
|
{
|
|
result = result + token + a.ToString();
|
|
token = ", ";
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string WindowsLogin()
|
|
{
|
|
WindowsIdentity windowsUserIndentity = WindowsIdentity.GetCurrent();
|
|
return windowsUserIndentity.Name;
|
|
}
|
|
|
|
//public static ActiveDirectoryUser GetActiveDirectoryUserInfoFromLogin(String login)
|
|
//{
|
|
// ActiveDirectoryUser result = new ActiveDirectoryUser();
|
|
|
|
// DirectoryEntry de = new DirectoryEntry();
|
|
// DirectorySearcher ds = new DirectorySearcher(de);
|
|
// ds.Filter = "(samaccountname=" + login + ")";
|
|
|
|
// string[] requiredProperties = new string[] { "cn", "samaccountname", "displayname", "telephonenumber", "mobile", "mail", "givenname" };
|
|
|
|
// foreach (String property in requiredProperties)
|
|
// {
|
|
// ds.PropertiesToLoad.Add(property);
|
|
// }
|
|
|
|
// SearchResult sr = ds.FindOne();
|
|
// if (sr != null)
|
|
// {
|
|
// ResultPropertyCollection fields = sr.Properties;
|
|
|
|
// foreach (String ldapField in fields.PropertyNames)
|
|
// {
|
|
// foreach (Object myCollection in fields[ldapField])
|
|
// {
|
|
// switch (ldapField)
|
|
// {
|
|
// case "displayname":
|
|
// result.DisplayName = myCollection.ToString();
|
|
// break;
|
|
// case "telephonenumber":
|
|
// result.TelefonNummer = myCollection.ToString();
|
|
// break;
|
|
// case "mobile":
|
|
// result.MobilNummer = myCollection.ToString();
|
|
// break;
|
|
// case "mail":
|
|
// result.EMail = myCollection.ToString().Replace("@LAMBERTZ.DE", "@Lambertz.com");
|
|
// break;
|
|
// case "givenname":
|
|
// result.NachName = myCollection.ToString();
|
|
// break;
|
|
// case "cn":
|
|
// result.Login = myCollection.ToString();
|
|
// break;
|
|
// }
|
|
|
|
// //Console.WriteLine(String.Format("{0,-20} : {1}", ldapField, myCollection.ToString()));
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
|
|
// return result;
|
|
//}
|
|
|
|
public static string FürDateiNamenBereinigen(String name)
|
|
{
|
|
name = name.Replace("\"","");
|
|
name = name.Replace("/", "");
|
|
name = name.Replace("\\", "");
|
|
name = name.Replace(":", "");
|
|
name = name.Replace("*", "");
|
|
name = name.Replace("?", "");
|
|
name = name.Replace(">", "");
|
|
name = name.Replace("|", "");
|
|
|
|
return name;
|
|
}
|
|
|
|
public static DateTime ConvertToDate(object datum)
|
|
{
|
|
DateTime result = DateTime.MinValue;
|
|
|
|
if (datum != null)
|
|
{
|
|
result = ConvertToDate(datum.ToString());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static DateTime ConvertToDate(String datum)
|
|
{
|
|
DateTime result = DateTime.MinValue;
|
|
if(!String.IsNullOrEmpty(datum))
|
|
{
|
|
System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo("de-DE");
|
|
System.Globalization.DateTimeFormatInfo usaDateFormatInfo = culture.DateTimeFormat;
|
|
|
|
DateTime temp;
|
|
if (DateTime.TryParse(datum, usaDateFormatInfo, System.Globalization.DateTimeStyles.None, out temp))
|
|
{
|
|
result = temp;
|
|
}
|
|
else
|
|
{
|
|
if (DateTime.TryParse(datum, out temp))
|
|
{
|
|
result = temp;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//public static void ShowDgvWidths(DataGridView dataGridView)
|
|
//{
|
|
// foreach (DataGridViewColumn col in dataGridView.Columns)
|
|
// {
|
|
// System.Diagnostics.Debugger.Log(0, null, col.Width.ToString() + " ");
|
|
// }
|
|
//}
|
|
|
|
public static Process StartFile(string fileName)
|
|
{
|
|
if (!String.IsNullOrWhiteSpace(fileName))
|
|
{
|
|
return StartFile("", fileName);
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
//public static void LoadDgvLayout(String formName, DataGridView dgv)
|
|
//{
|
|
// DgvLayoutManager.Load(formName, dgv);
|
|
//}
|
|
|
|
//public static void SaveDgvLayout(String formName, DataGridView dgv)
|
|
//{
|
|
// DgvLayoutManager.Save(formName, dgv);
|
|
//}
|
|
|
|
//public static void DgvDrucker(String title, DataGridViewColumnCollection columns, DataGridViewRowCollection rows, String user, String folderName, String fileName)
|
|
//{
|
|
// DgvDrucker drucker = new DgvDrucker(title, columns, rows, user, folderName, fileName);
|
|
// drucker.PDFErstellen(false);
|
|
//}
|
|
|
|
public static Process StartFile(string option1, string fileName)
|
|
{
|
|
Process result = null;
|
|
String ext = Path.GetExtension(fileName).ToLower();
|
|
String parameter = (option1 + " " + "\"" + fileName.Trim() + "\"").Trim() ;
|
|
String pf = KernParameterSingelton.GetInstance().ProgrammVerknüpfung(ext);
|
|
if (String.IsNullOrEmpty(pf))
|
|
{
|
|
switch (ext)
|
|
{
|
|
case ".xls":
|
|
case ".xml":
|
|
result = System.Diagnostics.Process.Start("EXCEL.EXE", parameter);
|
|
break;
|
|
case ".xlsx":
|
|
case ".xlsm":
|
|
String prgPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
|
|
|
|
String prg;
|
|
if (File.Exists(Path.Combine(prgPath, @"Microsoft Office\Office12\MOC.EXE")) && !File.Exists(Path.Combine(prgPath, @"Microsoft Office\Office12\Excel.EXE")))
|
|
{
|
|
prg = Path.Combine(prgPath, @"Microsoft Office\Office12\MOC.EXE");
|
|
}
|
|
else
|
|
{
|
|
prg = "EXCEL.EXE";
|
|
}
|
|
result = System.Diagnostics.Process.Start(prg, parameter);
|
|
break;
|
|
default:
|
|
result = System.Diagnostics.Process.Start(fileName);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = System.Diagnostics.Process.Start(pf, parameter);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static String GetSmtpServer()
|
|
{
|
|
string result = smtpServer;
|
|
|
|
if (standortIndex == 0)
|
|
{
|
|
String login = WindowsIdentity.GetCurrent().Name;
|
|
if (login.ToUpper().StartsWith("LAMBERTZPL"))
|
|
{
|
|
standortIndex = 2;
|
|
}
|
|
else
|
|
{
|
|
standortIndex = 1;
|
|
}
|
|
}
|
|
|
|
if (standortIndex == 2)
|
|
{
|
|
result = smtpServerPolen;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static DateTime DayStartDate(DateTime date)
|
|
{
|
|
return (new DateTime(date.Year, date.Month, date.Day, 0, 0, 0));
|
|
}
|
|
|
|
public static DateTime DayEndDate(DateTime date)
|
|
{
|
|
return (new DateTime(date.Year, date.Month, date.Day, 23, 59, 59));
|
|
}
|
|
|
|
public static string KennwortVerschlüsseln(string text)
|
|
{
|
|
string result = null;
|
|
|
|
if (!String.IsNullOrEmpty(text))
|
|
{
|
|
byte[] wert;
|
|
byte[] hash;
|
|
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
|
|
|
|
wert = Encoding.UTF8.GetBytes(text);
|
|
hash = md5.ComputeHash(wert);
|
|
result = Convert.ToBase64String(hash);
|
|
}
|
|
else
|
|
{
|
|
result = "";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string EncryptODAL(string text)
|
|
{
|
|
string result;
|
|
int zeichen;
|
|
|
|
result = "";
|
|
if (!String.IsNullOrEmpty(text))
|
|
{
|
|
for (int i = 0; i < text.Length; i++)
|
|
{
|
|
zeichen = (int)char.Parse(text.Substring(i, 1));
|
|
zeichen = zeichen - 16;
|
|
result = result + (char)zeichen;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Entschlüsselt ein übergebenes Kennwort
|
|
/// </summary>
|
|
/// <param name="text"></param>
|
|
/// <returns></returns>
|
|
public static string DecryptODAL(string text)
|
|
{
|
|
string result = "";
|
|
int zeichen;
|
|
|
|
if (!String.IsNullOrEmpty(text))
|
|
{
|
|
for (int i = 0; i < text.Length; i++)
|
|
{
|
|
|
|
zeichen = (int)char.Parse(text.Substring(i, 1));
|
|
zeichen = zeichen + 16;
|
|
result = result + (char)zeichen;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
public static object NullZuLeer(string text)
|
|
{
|
|
if (text == null)
|
|
{
|
|
text = "";
|
|
}
|
|
return text;
|
|
}
|
|
|
|
public static Version GetVersion(String text)
|
|
{
|
|
Version result = null;
|
|
|
|
int major = 0;
|
|
int minor = 0;
|
|
int built = 0;
|
|
int revision = 0;
|
|
|
|
if (!String.IsNullOrEmpty(text))
|
|
{
|
|
String[] arr = text.Split(".".ToCharArray());
|
|
|
|
if (arr.Length > 0)
|
|
{
|
|
Int32.TryParse(arr[0], out major);
|
|
}
|
|
|
|
if (arr.Length > 1)
|
|
{
|
|
Int32.TryParse(arr[1], out minor);
|
|
}
|
|
|
|
if (arr.Length > 2)
|
|
{
|
|
Int32.TryParse(arr[2], out built);
|
|
}
|
|
|
|
if (arr.Length > 3)
|
|
{
|
|
Int32.TryParse(arr[3], out revision);
|
|
}
|
|
}
|
|
|
|
result = new Version(major, minor, built, revision);
|
|
|
|
return result;
|
|
}
|
|
|
|
public static byte[] IconToBytes(Icon icon)
|
|
{
|
|
using (MemoryStream ms = new MemoryStream())
|
|
{
|
|
icon.Save(ms);
|
|
return ms.ToArray();
|
|
}
|
|
}
|
|
|
|
public static Icon BytesToIcon(byte[] bytes)
|
|
{
|
|
using (MemoryStream ms = new MemoryStream(bytes))
|
|
{
|
|
return new Icon(ms);
|
|
}
|
|
}
|
|
|
|
public static String Get9400AnfrageSchlüssel(string satzArt, int appId, string userName, string server, string workstation, string select)
|
|
{
|
|
StringBuilder result = new StringBuilder(satzArt);
|
|
|
|
if (userName == null)
|
|
{
|
|
userName = "";
|
|
}
|
|
if (server == null)
|
|
{
|
|
server = "";
|
|
}
|
|
if (workstation == null)
|
|
{
|
|
workstation = "";
|
|
}
|
|
if (select == null)
|
|
{
|
|
select = "";
|
|
}
|
|
|
|
result.Append(appId.ToString("000"));
|
|
if (userName.Length <= 30)
|
|
{
|
|
result.Append(userName.ToUpper().PadRight(30));
|
|
}
|
|
else
|
|
{
|
|
result.Append(userName.Substring(0,30));
|
|
}
|
|
if (server.Length <= 30)
|
|
{
|
|
result.Append(server.PadRight(30));
|
|
}
|
|
else
|
|
{
|
|
result.Append(server.Substring(0, 30));
|
|
}
|
|
if (workstation.Length <= 30)
|
|
{
|
|
result.Append(workstation.PadRight(30));
|
|
}
|
|
else
|
|
{
|
|
result.Append(workstation.Substring(0, 30));
|
|
}
|
|
if (select.Length <= 1)
|
|
{
|
|
result.Append(select.PadRight(1));
|
|
}
|
|
else
|
|
{
|
|
result.Append(select.Substring(0, 1));
|
|
}
|
|
|
|
return result.ToString();
|
|
}
|
|
|
|
public static Version GetVersionVonFile(string pfad)
|
|
{
|
|
Version result = null;
|
|
if (File.Exists(pfad))
|
|
{
|
|
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(pfad);
|
|
if (fvi.FileVersion != null)
|
|
{
|
|
result = GetVersion(fvi.FileVersion);
|
|
}
|
|
else
|
|
{
|
|
result = new Version(0, 0, 0, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = new Version(0, 0, 0, 0);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static String TextZuDatumsText(String text)
|
|
{
|
|
String result = text;
|
|
if (text.Length > 0)
|
|
{
|
|
if (text == "..")
|
|
{
|
|
result = DateTime.Now.ToString("d", germanCultureInfo);
|
|
}
|
|
else
|
|
{
|
|
if (text.StartsWith("..+") || text.StartsWith("..-"))
|
|
{
|
|
String text3b = text.Substring(2);
|
|
int x = 0;
|
|
if (Int32.TryParse(text3b, out x))
|
|
{
|
|
result = DateTime.Now.AddDays(x).ToString("d", germanCultureInfo); ;
|
|
}
|
|
else
|
|
{
|
|
result = DateTime.Now.ToString("d", germanCultureInfo); ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (text.Length == 4)
|
|
{
|
|
text = text.Substring(0, 1) + "." + text.Substring(1, 1) + "." + text.Substring(2);
|
|
}
|
|
if ((text.Length == 5 || text.Length == 7) && text.IndexOf(".") < 0)
|
|
{
|
|
text = "0" + text;
|
|
}
|
|
if ((text.Length == 6 || text.Length == 8) && text.IndexOf(".") < 0)
|
|
{
|
|
text = text.Substring(0, 2) + "." + text.Substring(2, 2) + "." + text.Substring(4);
|
|
}
|
|
DateTime temp;
|
|
if (DateTime.TryParse(text, out temp))
|
|
{
|
|
result = temp.ToString("d", germanCultureInfo); ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Macht aus den lustigen negativen Zahlen der AS400 wieder
|
|
/// Vernünftige. Wenn mit der Falschen Codepage gearbeitet wird
|
|
/// hat man hier ein Problem weil -0 -> ü ist und dann nur als ?
|
|
/// geliefert wird.
|
|
/// </summary>
|
|
/// <param name="zahl"></param>
|
|
/// <returns></returns>
|
|
public static String NegativeCheck(String zahl)
|
|
{
|
|
String result = zahl;
|
|
String last = null;
|
|
bool build = false;
|
|
//Nachsehen nach letzter "Ziffer"
|
|
|
|
if(!String.IsNullOrEmpty(zahl))
|
|
{
|
|
switch (zahl.Substring(zahl.Length - 1))
|
|
{
|
|
case "ü":
|
|
last = "0";
|
|
build = true;
|
|
break;
|
|
case "J":
|
|
last = "1";
|
|
build = true;
|
|
break;
|
|
case "K":
|
|
last = "2";
|
|
build = true;
|
|
break;
|
|
case "L":
|
|
last = "3";
|
|
build = true;
|
|
break;
|
|
case "M":
|
|
last = "4";
|
|
build = true;
|
|
break;
|
|
case "N":
|
|
last = "5";
|
|
build = true;
|
|
break;
|
|
case "O":
|
|
last = "6";
|
|
build = true;
|
|
break;
|
|
case "P":
|
|
last = "7";
|
|
build = true;
|
|
break;
|
|
case "Q":
|
|
last = "8";
|
|
build = true;
|
|
break;
|
|
case "R":
|
|
last = "9";
|
|
build = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (build)
|
|
{
|
|
result = "-" + zahl.Substring(0, zahl.Length - 1) + last;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static string GetDatePath()
|
|
{
|
|
return GetDatePath(DateTime.Now);
|
|
}
|
|
|
|
public static string GetDatePath(DateTime datum)
|
|
{
|
|
String result = datum.Year.ToString("0000");
|
|
|
|
result = Path.Combine(result, datum.Month.ToString("00"));
|
|
result = Path.Combine(result, datum.Day.ToString("00"));
|
|
|
|
return result;
|
|
}
|
|
|
|
public static String RechnerName()
|
|
{
|
|
return Environment.MachineName;
|
|
}
|
|
|
|
public static string ExcelIndexZuSpalte(int index)
|
|
{
|
|
String prefix = "";
|
|
String result = "";
|
|
|
|
int temp = index + 65;
|
|
|
|
int counter = 0;
|
|
while (temp - 25 > 65)
|
|
{
|
|
temp = temp - 25;
|
|
counter++;
|
|
}
|
|
|
|
if (counter > 0)
|
|
{
|
|
prefix = Convert.ToChar(64 + counter).ToString();
|
|
result = prefix + result;
|
|
}
|
|
else
|
|
{
|
|
result = Convert.ToChar(temp).ToString();
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
public static String ToShortDateFormat(DateTime date)
|
|
{
|
|
return date.ToString("dd.MM.yyyy");
|
|
}
|
|
}
|
|
}
|