BeWoPlaner/Shared/Core/Utils.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using DevExpress.XtraScheduler;

namespace BS.Shared.Core
{
    public class Utils
    {
        private static readonly Dictionary<char, string> criticals = new Dictionary<char, string>
        {
                { '"', "&quot;" }, 
                { '€', "&euro;" }, 
                { '¡', "&iexcl;" }, 
                { '¢', "&cent;" }, 
                { '£', "&pound;" }, 
                { '¤', "&curren;" }, 
                { '¥', "&yen;" }, 
                { '¦', "&brvbar;" }, 
                { '§', "&sect;" }, 
                { '¨', "&uml;" }, 
                { '©', "&copy;" }, 
                { 'ª', "&ordf;" }, 
                { '«', "&laquo;" }, 
                { '¬', "&not;" }, 
                { '­', "&shy;" }, 
                { '®', "&reg;" }, 
                { '¯', "&macr;" }, 
                { '°', "&deg;" }, 
                { '±', "&plusmn;" }, 
                { '²', "&sup2;" }, 
                { '³', "&sup3;" }, 
                { '´', "&acute;" }, 
                { 'µ', "&micro;" }, 
                { '¶', "&para;" }, 
                { '·', "&middot;" }, 
                { '¸', "&cedil;" }, 
                { '¹', "&sup1;" }, 
                { 'º', "&ordm;" }, 
                { '»', "&raquo;" }, 
                { '¼', "&frac14;" }, 
                { '½', "&frac12;" }, 
                { '¾', "&frac34;" }, 
                { '¿', "&iquest;" }, 
                { 'À', "&Agrave;" }, 
                { 'Á', "&Aacute;" }, 
                { 'Â', "&Acirc;" }, 
                { 'Ã', "&Atilde;" }, 
                { 'Ä', "&Auml;" }, 
                { 'Å', "&Aring;" }, 
                { 'Æ', "&AElig;" }, 
                { 'Ç', "&Ccedil;" }, 
                { 'È', "&Egrave;" }, 
                { 'É', "&Eacute;" }, 
                { 'Ê', "&Ecirc;" }, 
                { 'Ë', "&Euml;" }, 
                { 'Ì', "&Igrave;" }, 
                { 'Í', "&Iacute;" }, 
                { 'Î', "&Icirc;" }, 
                { 'Ï', "&Iuml;" }, 
                { 'Ð', "&ETH;" }, 
                { 'Ñ', "&Ntilde;" }, 
                { 'Ò', "&Ograve;" }, 
                { 'Ó', "&Oacute;" }, 
                { 'Ô', "&Ocirc;" }, 
                { 'Õ', "&Otilde;" }, 
                { 'Ö', "&Ouml;" }, 
                { '×', "&times;" }, 
                { 'Ø', "&Oslash;" }, 
                { 'Ù', "&Ugrave;" }, 
                { 'Ú', "&Uacute;" }, 
                { 'Û', "&Ucirc;" }, 
                { 'Ü', "&Uuml;" }, 
                { 'Ý', "&Yacute;" }, 
                { 'Þ', "&THORN;" }, 
                { 'ß', "&szlig;" }, 
                { 'à', "&agrave;" }, 
                { 'á', "&aacute;" }, 
                { 'â', "&acirc;" }, 
                { 'ã', "&atilde;" }, 
                { 'ä', "&auml;" }, 
                { 'å', "&aring;" }, 
                { 'æ', "&aelig;" }, 
                { 'ç', "&ccedil;" }, 
                { 'è', "&egrave;" }, 
                { 'é', "&eacute;" }, 
                { 'ê', "&ecirc;" }, 
                { 'ë', "&euml;" }, 
                { 'ì', "&igrave;" }, 
                { 'í', "&iacute;" }, 
                { 'î', "&icirc;" }, 
                { 'ï', "&iuml;" }, 
                { 'ð', "&eth;" }, 
                { 'ñ', "&ntilde;" }, 
                { 'ò', "&ograve;" }, 
                { 'ó', "&oacute;" }, 
                { 'ô', "&ocirc;" }, 
                { 'õ', "&otilde;" }, 
                { 'ö', "&ouml;" }, 
                { '÷', "&divide;" }, 
                { 'ø', "&oslash;" }, 
                { 'ù', "&ugrave;" }, 
                { 'ú', "&uacute;" }, 
                { 'û', "&ucirc;" }, 
                { 'ü', "&uuml;" }, 
                { 'ý', "&yacute;" }, 
                { 'þ', "&thorn;" }, 
                { 'ÿ', "&yuml;" }
                
                
                // {'>', "&lt;"},
                
                
                
                // {'<', "&gt;"},
            };

        public static bool AreAllNull(params object[] pObjects)
        {
            foreach (object iO in pObjects)
            {
                if (iO != null)
                {
                    return false;
                }
            }

            return true;
        }

        public static bool AreAllNullOrEmpty(params object[] pObjects)
        {
            foreach (object iObject in pObjects)
            {
                if (iObject is string)
                {
                    if (!String.IsNullOrEmpty(iObject as string))
                    {
                        return false;
                    }
                }
                else if (iObject is IEnumerable)
                {
                    if ((iObject as IEnumerable).GetEnumerator().MoveNext())
                    {
                        return false;
                    }
                }
                else if (iObject != null)
                {
                    return false;
                }
            }

            return true;
        }

        public static string Compress(string text)
        {
            byte[] buffer = Encoding.UTF8.GetBytes(text);
            MemoryStream ms = new MemoryStream();
            using (GZipStream zip = new GZipStream(ms, CompressionMode.Compress, true))
            {
                zip.Write(buffer, 0, buffer.Length);
            }

            ms.Position = 0;
            MemoryStream outStream = new MemoryStream();

            byte[] compressed = new byte[ms.Length];
            ms.Read(compressed, 0, compressed.Length);

            byte[] gzBuffer = new byte[compressed.Length + 4];
            Buffer.BlockCopy(compressed, 0, gzBuffer, 4, compressed.Length);
            Buffer.BlockCopy(BitConverter.GetBytes(buffer.Length), 0, gzBuffer, 0, 4);
            return Convert.ToBase64String(gzBuffer);
        }

        public static string Decompress(string compressedText)
        {
            byte[] gzBuffer = Convert.FromBase64String(compressedText);
            using (MemoryStream ms = new MemoryStream())
            {
                int msgLength = BitConverter.ToInt32(gzBuffer, 0);
                ms.Write(gzBuffer, 4, gzBuffer.Length - 4);

                byte[] buffer = new byte[msgLength];

                ms.Position = 0;
                using (GZipStream zip = new GZipStream(ms, CompressionMode.Decompress))
                {
                    zip.Read(buffer, 0, buffer.Length);
                }

                return Encoding.UTF8.GetString(buffer);
            }
        }

        public static string EnumName<T>(T pObject)
        {
            return Enum.GetName(typeof(T), pObject);
        }

        public static T EnumParse<T>(string pValue)
        {
            return (T)Enum.Parse(typeof(T), pValue);
        }

        public static IEnumerable<T> GetAllEnumValues<T>()
        {
            return Enum.GetValues(typeof(T)).Cast<T>();
        }

        public static List<DayOfWeek> GetDayOfWeeks(DayOfWeek lFirst)
        {
            var lResult = new List<DayOfWeek>();

            DateTime lStart = DateTime.Now;
            while (lStart.DayOfWeek != lFirst)
            {
                lStart = lStart.AddDays(1);
            }

            for (int i = 1; i < 8; i++)
            {
                lResult.Add(lStart.DayOfWeek);
                lStart = lStart.AddDays(1);
            }

            return lResult;
        }

        public static int GetWholeWorkWeekCount(DateTime pStart, DateTime pEnd)
        {
            return GetWholeWorkWeeks(pStart, pEnd).Count();
        }

        public static List<DateTimeSpan> GetWholeWorkWeeks(DateTime pStart, DateTime pEnd)
        {
            while (pStart.DayOfWeek != DayOfWeek.Monday)
            {
                pStart = pStart.AddDays(1);
            }

            List<DateTimeSpan> lResult = new List<DateTimeSpan>();
            while ((pStart = pStart.AddDays(4)) <= pEnd.Date)
            {
                lResult.Add(new DateTimeSpan { StartDateTime = pStart.AddDays(-4), EndDateTime = pStart.AddDays(1).AddMilliseconds(-1) });
                pStart = pStart.AddDays(3);
            }

            return lResult;
        }

        public static bool IsAnyNull(params object[] pObjects)
        {
            foreach (object iO in pObjects)
            {
                if (iO == null)
                {
                    return true;
                }
            }

            return false;
        }

        public static bool IsAnyNullOrEmpty(params string[] pStrings)
        {
            foreach (string iString in pStrings)
            {
                if (String.IsNullOrEmpty(iString))
                {
                    return true;
                }
            }

            return false;
        }

        public static Queue<T> MakeQueue<T>(params T[] items)
        {
            return new Queue<T>(items);
        }

        public static string MyHtmlEncode(string pString)
        {
            StringBuilder htmlk = new StringBuilder();
            int ia = 0;
            for (int i = 0; i < pString.Length; i++)
            {
                char c = pString[i];
                if (criticals.ContainsKey(c))
                {
                    htmlk.Append(pString.Substring(ia, i - ia));
                    htmlk.Append(criticals[c]);
                    ia = i + 1;
                }
            }

            htmlk.Append(pString.Substring(ia));
            return htmlk.ToString();
        }

        public static NullCompareResult NullCompare(object pO1, object pO2)
        {
            NullCompareResult lResult = new NullCompareResult();

            lResult.Different = (pO1 == null && pO2 != null) || (pO1 != null && pO2 == null);
            lResult.BothNotNull = pO1 != null && pO2 != null;

            return lResult;
        }

        public static byte[] ReadFully(Stream stream)
        {
            byte[] buffer = new byte[32768];
            using (MemoryStream ms = new MemoryStream())
            {
                while (true)
                {
                    int read = stream.Read(buffer, 0, buffer.Length);
                    if (read <= 0)
                    {
                        return ms.ToArray();
                    }

                    ms.Write(buffer, 0, read);
                }
            }
        }

        public static void ReadWriteStream(Stream readStream, Stream writeStream)
        {
            int Length = 256;
            byte[] buffer = new byte[Length];
            int bytesRead = readStream.Read(buffer, 0, Length);

            while (bytesRead > 0)
            {
                writeStream.Write(buffer, 0, bytesRead);
                bytesRead = readStream.Read(buffer, 0, Length);
            }

            readStream.Close();
            writeStream.Close();
        }

        public static T XMLDeserialize<T>(string pPath)
        {
            T lResult = default(T);
            using (var uFS = File.Open(pPath, FileMode.Open))
            {
                var lSerialzer = new XmlSerializer(typeof(T));
                lResult = (T)lSerialzer.Deserialize(uFS);
            }

            return lResult;
        }

        public static T XMLDeserializeFromString<T>(string serializedXML)
        {
            T lResult = default(T);

            if (!String.IsNullOrEmpty(serializedXML))
            {
                var lSerialzer = new XmlSerializer(typeof(T));
                StringReader r = new StringReader(serializedXML);
                lResult = (T)lSerialzer.Deserialize(r);
            }

            return lResult;
        }

        public static object XMLDeserializeFromString(string serializedXML, Type type)
        {
            object lResult = null;

            if (!String.IsNullOrEmpty(serializedXML))
            {
                var lSerialzer = new XmlSerializer(type);
                StringReader r = new StringReader(serializedXML);
                lResult = lSerialzer.Deserialize(r);
            }

            return lResult;
        }

        public static void XMLSerialize<T>(string pPath, T pObject)
        {
            if (!Directory.Exists(Path.GetDirectoryName(pPath)))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(pPath));
            }

            using (var uFS = File.Create(pPath))
            {
                var lSerialzer = new XmlSerializer(typeof(T));
                lSerialzer.Serialize(uFS, pObject);
            }
        }

        public static string XMLSerializeToString(object pObject)
        {
            var lSerialzer = new XmlSerializer(pObject.GetType());
            StringWriter strw = new StringWriter();
            lSerialzer.Serialize(strw, pObject);

            string str = strw.ToString();
            int test = str.Length;
            return str;
        }

	    public static void SaveExceptionAsTextFile(string pPath, Exception e)
	    {
#if DEBUG
		    var directoryName = Path.GetDirectoryName(pPath);
			if (directoryName != null)
		    {
				if (!Directory.Exists(directoryName))
				    return;
		    }
		    var innerException = e.InnerException;
		    var sw = new StreamWriter(pPath, true);

			sw.WriteLine(e.Message);
			sw.WriteLine(e.StackTrace + "\n");

		    while (innerException != null)
		    {
			    sw.WriteLine(innerException.Message);
				sw.WriteLine(innerException.StackTrace + "\n");
			    innerException = innerException.InnerException;
		    }

			sw.Flush();
			sw.Close();
#endif
	    }

		public static int ToInt<T>(T e) where T : struct, IComparable, IFormattable, IConvertible // where T : Enum is not possible
		{
			return (int)(Object)e;
		}

        public static byte[] ErstelleThumbnail(byte[] data, int width, int height)
        {
            var imageOriginal = CreateImageFromByteArray(data);
            if (imageOriginal == null)
            {
                return null;
            }

            var originalW = imageOriginal.Width;
            var originalH = imageOriginal.Height;

            DateTime? originRecordDateTime;

            var smallImage = ResizeImage(imageOriginal, new Size(width, height));
            var smallData = CreateByteArrayFromImage(smallImage);

            smallImage.Dispose();

            return smallData;
        }

        public static Image CreateImageFromByteArray(byte[] data)
        {
            try
            {
                using (var ms = new MemoryStream(data))
                {
                    ms.Position = 0;
                    var image = Image.FromStream(ms);
                    return image;
                }
            }
            catch (Exception)
            {
                return null;
            }
        }

        public static Image ResizeImage(Image original, Size size)
        {
            var newSize = CalcSize(original.Width, original.Height, size.Width, size.Height);

            var newImage = new Bitmap(newSize.Width, newSize.Height);

            using (var graphicsHandle = Graphics.FromImage(newImage))
            {
                graphicsHandle.InterpolationMode = InterpolationMode.HighQualityBicubic;
                graphicsHandle.DrawImage(original, 0, 0, newSize.Width, newSize.Height);
            }
            return newImage;
        }

        public static byte[] CreateByteArrayFromImage(Image image)
        {
            if (image != null)
            {
                using (var memoryStream = new MemoryStream())
                {
                    image.Save(memoryStream, ImageFormat.Jpeg);
                    return memoryStream.ToArray();
                }
            }
            return null;
        }

        public static Bitmap CropImage(Image image)
        {
            Bitmap originalBitmap = new Bitmap(image);

            Point min = new Point(Int32.MaxValue, Int32.MaxValue);
            Point max = new Point(Int32.MinValue, Int32.MinValue);

            for (int x = 0; x < originalBitmap.Width; ++x)
            {
                for (int y = 0; y < originalBitmap.Height; ++y)
                {
                    Color pixelColor = originalBitmap.GetPixel(x, y);
                    if (!(pixelColor.R == 255 && pixelColor.G == 255 && pixelColor.B == 255)
                        && pixelColor.A > 0)
                    {
                        if (x < min.X) min.X = x;
                        if (y < min.Y) min.Y = y;

                        if (x > max.X) max.X = x;
                        if (y > max.Y) max.Y = y;
                    }
                 }
            }

            // Create a new bitmap from the crop rectangleig
            if (min.X < Int32.MaxValue && min.Y < Int32.MaxValue && max.X > Int32.MinValue && max.Y > Int32.MinValue)
            {
                Rectangle cropRectangle = new Rectangle(min.X, min.Y, max.X - min.X, max.Y - min.Y);
                if (cropRectangle.Width > 0 && cropRectangle.Height > 0)
                {
                    Bitmap newBitmap = new Bitmap(cropRectangle.Width, cropRectangle.Height);
                    using (Graphics g = Graphics.FromImage(newBitmap))
                    {
                        g.DrawImage(originalBitmap, 0, 0, cropRectangle, GraphicsUnit.Pixel);
                    }

                    return newBitmap;
                }
            }
            
            return originalBitmap;
            
        }

        private static Size CalcSize(int originalWidth, int originalHeight, int desiredWidth, int desiredHeight)
        {
            var percentWidth = desiredWidth / (float)originalWidth;
            var percentHeight = desiredHeight / (float)originalHeight;
            var percent = percentHeight < percentWidth ? percentHeight : percentWidth;

            var width = (int)Math.Round(originalWidth * percent, MidpointRounding.AwayFromZero);
            var height = (int)Math.Round(originalHeight * percent, MidpointRounding.AwayFromZero);
            if (width == 0)
            {
                width = 1;
            }
            if (height == 0)
            {
                height = 1;
            }

            return new Size(width, height);
        }

        public static List<TextModuleDC> GetParentTextModules(List<TextModuleDC> childTextModules)
        {
            _Parents.Clear();

            foreach(var textModule in childTextModules)
            {
                GetParentTextModule(textModule);
            }

            return _Parents;
        }

        private static readonly List<TextModuleDC> _Parents = new List<TextModuleDC>();
        private static void GetParentTextModule(TextModuleDC textModule)
        {
            if(textModule.Parent != null)
            {
                _Parents.AddIfNotIn(textModule.Parent);

                if(textModule.Parent.Parent != null)
                {
                    GetParentTextModule(textModule.Parent.Parent);
                }
            }
        }

        public static string CollectionToString(string pSeperator, IEnumerable pCollection)
        {
            pSeperator += " ";
            var result = "";
            var enumerator = pCollection.GetEnumerator();
            
            while(enumerator.MoveNext())
            {
                var currentString = enumerator.Current?.ToString();
                result += currentString + pSeperator;
            }
            
            return result.Trim(pSeperator?.ToCharArray());
        }

        public static long? ParseObjectToNullableLong(object object2Parse)
        {
            if(object2Parse == null)
            {
                return null;
            }
            
            var wasSuccessful = Int64.TryParse(object2Parse.ToString(), out var output);

            if(wasSuccessful)
            {
                return output;
            }
            
            return null;
        }

        /// <summary>
        /// Schreibt einen String in eine Textdatei im Debug-Modus, die auf dem Desktop gespeichert wird.
        /// </summary>
        /// <param name="pFilename">Name der Textdatei. Existiert die Datei bereits, wird der Text angefügt.</param>
        /// <param name="pMessage">Text, der in der Datei gepeichert wird.</param>
        public static void WriteToLogFile(string pFilename, string pMessage)
        {
#if DEBUG

            const string path = @"C:\Users\lyndo\Desktop\";

            var exists = Directory.Exists(path);

            if (exists)
            {
                using (var file = new StreamWriter(path + pFilename, true))
                {
                    file.WriteLine($"{pMessage}");
                }
            }

#endif
        }

        public static bool CheckSchedulerRights(List<CompactCustomerDC> pCustomerList, List<ResourceDC> pResourceList, List<Employee2SchedulerAppointmentDC> pEmployeeList, CompactEmployeeDC pOriginator, bool pIsNew, SchedulerRightsCheckType pCheckType, UserDC pLoggedOnUser)
        {
            var loggedInEmployee = pLoggedOnUser.Employee;

            var isAllowedToViewEverything = pLoggedOnUser.HasRight(UserRightType.ViewAll);
            var isAllowedToEditEverything = pLoggedOnUser.HasRight(UserRightType.EditAll);
            var isAllowedToCreateEverything = pLoggedOnUser.HasRight(UserRightType.CreateAll);

            var isAllowedToViewCustomers = pLoggedOnUser.HasRight(UserRightType.CustomerView_View);

            var isAllowedToViewAllCustomerAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderKliententermineAlleAnsehen);
            var isAllowedToCreateCustomerAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderKliententermineAnlegen);
            var isAllowedToEditCustomerAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderKliententermineAendern);

            var isAllowedToViewEmployeeAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderMitarbeitertermineAnsehen);
            var isAllowedToCreateEmployeeAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderMitarbeitertermineAnlegen);
            var isAllowedToEditEmployeeAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderMitarbeitertermineAendern);

            var isAllowedToViewResourceAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderRessourcentermineAnsehen);
            var isAllowedToCreateResourceAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderRessourcentermineAnlegen);
            var isAllowedToEditResourceAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderRessourcentermineAendern);
            var isAllowedToEditOtherEmployeesResourceAppointments = pLoggedOnUser.HasRight(UserRightType.KalenderRessourcentermineAndererAendern);

            var hasEmployees = pEmployeeList?.Count > 0;
            var hasCustomers = pCustomerList?.Count > 0;
            var hasResources = pResourceList?.Count > 0;

            var hasOnlyOwnCustomers = pCustomerList?.All(c => c.IsRelatedToEmployee) ?? false;

            var isOwnAppointment = Equals(pOriginator, loggedInEmployee);
            var employeeListOnlyContainsEmployee = pEmployeeList?.Count == 1 && pEmployeeList[0].Employee.Equals(loggedInEmployee);

            var employeeIsInList = pEmployeeList?.Any(a => Equals(loggedInEmployee, a.Employee)) ?? false;

            var result = true;

            switch(pCheckType)
            {
                case SchedulerRightsCheckType.View:
                    if(isAllowedToViewEverything || employeeIsInList)
                    {
                        return true;
                    }

                    if(hasEmployees)
                    {
                        if(!employeeListOnlyContainsEmployee)
                        {
                            result = isAllowedToViewEmployeeAppointments;
                        }
                    }

                    if(!result)
                    {
                        return false;
                    }

                    if(hasCustomers)
                    {
                        if(isAllowedToViewCustomers)
                        {
                            result = hasOnlyOwnCustomers || isAllowedToViewAllCustomerAppointments;
                        }
                        else
                        {
                            return false;
                        }
                    }

                    if(!result)
                    {
                        return false;
                    }

                    if(hasResources)
                    {
                        result = isAllowedToViewResourceAppointments;
                    }

                    break;
                case SchedulerRightsCheckType.Create:
                    if(isAllowedToCreateEverything)
                    {
                        return true;
                    }

                    if(hasEmployees)
                    {
                        result = isAllowedToCreateEmployeeAppointments;
                        if(!result)
                        {
                            return false;
                        }
                    }

                    if(hasCustomers)
                    {
                        result = !hasOnlyOwnCustomers ? isAllowedToViewAllCustomerAppointments : isAllowedToCreateCustomerAppointments;

                        if(!result)
                        {
                            return false;
                        }
                    }

                    if(hasResources)
                    {
                        result = isAllowedToCreateResourceAppointments;
                    }

                    break;
                case SchedulerRightsCheckType.Edit:
                    if(isAllowedToEditEverything)
                    {
                        return true;
                    }

                    if(!isOwnAppointment || hasEmployees)
                    {
                        result = isAllowedToEditEmployeeAppointments;

                        if(hasResources)
                        {
                            result = isAllowedToEditResourceAppointments;
                        }

                        if(!result)
                        {
                            return false;
                        }
                    }

                    if(hasCustomers)
                    {
                        result = isAllowedToEditCustomerAppointments;

                        if(!result)
                        {
                            return false;
                        }
                    }

                    if(hasResources)
                    {
                        result = hasEmployees ? isAllowedToEditOtherEmployeesResourceAppointments : isAllowedToEditResourceAppointments;
                    }

                    break;
                default:
                    return false;
            }

            return result;
        }

        public static bool CheckSchedulerRights(SchedulerAppointmentDC pAppointment, SchedulerRightsCheckType pCheckType, UserDC pLoggedOnUser)
        {
            return CheckSchedulerRights(pAppointment.CustomerList, pAppointment.ResourceList, pAppointment.EmployeeList, pAppointment.Originator, !pAppointment.SchedulerAppointmentOid.HasValue, pCheckType, pLoggedOnUser);
        }

        public static bool IsPowerOfTwo(int number)
        {
            return ((number - 1) & number) == 0;
        }

        public static int FindClosestPowerOfTwo(int number)
        {
            if (IsPowerOfTwo(number))
            {
                return number;
            }

            while (!IsPowerOfTwo(number))
            {
                number--;
            }

            return number;
        }

        public static List<DayOfWeek> GetWeekDaysFromNumber(int number)
        {
            var weekDays = new List<DayOfWeek>();

            if (number % 2 != 0)
            {
                number--;
                weekDays.Add(DayOfWeek.Sunday);
            }

            var closestPowerOfTwo = FindClosestPowerOfTwo(number);
            var rest = number - closestPowerOfTwo;
            weekDays.Add(DateTimeUtils.ConvertWeekDaysToDayOfWeek(DateTimeUtils.GetWeekDays(closestPowerOfTwo)));

            if (rest > 0)
            {
                do
                {
                    closestPowerOfTwo = FindClosestPowerOfTwo(rest);
                    rest -= closestPowerOfTwo;
                    weekDays.Add(DateTimeUtils.ConvertWeekDaysToDayOfWeek(DateTimeUtils.GetWeekDays(closestPowerOfTwo)));
                } while (!IsPowerOfTwo(rest) || rest > 0);
            }

            return weekDays.OrderBy(day => (int)day).ToList();
        }

        public static DateTime GetNextDateTime(DateTime pDate, DayOfWeek pDayOfWeek, int pPeriodicity, RecurrenceType pType)
        {
            var dow = pDate.DayOfWeek;

            if (dow > pDayOfWeek)
            {
                var date = pDate;

                do
                {
                    date = date.AddDays(1);
                } while (date.DayOfWeek != pDayOfWeek);

                return CalculateNextDateTime(pType, date, pType == RecurrenceType.Weekly ? 7 * pPeriodicity - 1 : pPeriodicity - 1);
            }

            return CalculateNextDateTime(pType, pDate, pDayOfWeek - dow);
        }

        private static DateTime CalculateNextDateTime(RecurrenceType recurrenceType, DateTime date, int timeToAdd)
        {
            switch(recurrenceType)
            {
                case RecurrenceType.Daily:
                    return date.AddDays(timeToAdd);
                case RecurrenceType.Weekly:
                    return date.AddDays(timeToAdd);
                case RecurrenceType.Monthly:
                    return date.AddMonths(timeToAdd);
                default:
                    return date.AddYears(timeToAdd);
            }

            
        }

        public static readonly string TestAppointmentNotice = "k9Rx2mU4y";

        public static string GetSexAbbrevation(Sex? sex)
        {
            switch (sex)
            {
                case Sex.Male:
                    return "m";
                case Sex.Female:
                    return "w";
                case Sex.Divers:
                    return "d";
                default:
                    return string.Empty;
            }
        }

        public static string GetSexTranslation(Sex? sex, bool lowerCase = false)
        {
            string result;

            switch (sex)
            {
                case Sex.Male:
                    result = "Männlich";
                    break;
                case Sex.Female:
                    result = "Weiblich";
                    break;
                case Sex.Divers:
                    result = "Divers";
                    break;
                default:
                    result = string.Empty;
                    break;
            }

            return lowerCase ? result.ToLowerInvariant() : result;
        }
        public static bool ContainsKey(string[] array, string key)
        {
            return array.Any(keyEntry => keyEntry.Equals(key));
        }
    }

    public struct NullCompareResult
    {
        public bool BothNotNull;

        public bool Different;
    }

    public struct ArbeitszeitEintragDateTimeObject
    {
        public DateTime Start { get; set; }
        public DateTime End { get; set; }

        public ArbeitszeitEintragDateTimeObject(DateTime start, DateTime end)
        {
            Start = start;
            End = end;
        }
    }
}