BeWoPlaner/Service/ServiceImplementations/UserServiceImp.cs

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Net;
using System.ServiceModel;
using System.Text;
using System.Threading;
using System.Web;

using BeWo.Data;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.Core;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.Security;
using BeWo.Service.ServiceContracts;

using BS.Shared;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;

using BeWo.Service.Configuration;
using BeWo.Service.OwnChat;
using BeWo.Service.Plugins;
using BeWo.Data.Security;
using System.Collections.Specialized;
using System.IO;

using BeWoFault = BS.Shared.Core.BeWoFault;
using BeWoFaultType = BS.Shared.Core.BeWoFaultType;

namespace BeWo.Service.ServiceImplementations
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]
    public class UserServiceImp : IUserService
    {
        public long ChangePassword(string pUserName, long pUserVersion, string pOldPassword, string pNewPassword)
        {
            var allowChange = false;

            var user = LoggedInUserOperationContextExt.Current?.User ?? SessionFacade.LoggedInUser;
            if (user != null)
            {
                if (user.CheckForRight(UserRightType.UserView_AllowChangePassword))
                {
                    allowChange = true;
                }
                else if (!String.IsNullOrEmpty(pOldPassword) && pUserName == user.LoginName && user.CheckForRight(UserRightType.AllowChangeOwnPassword))
                {
                    allowChange = true;
                }
            }

            if (allowChange)
            {
                ApplicationUser lOriginal = DAOFactory.UserDAO.FindUserByLoginName(pUserName);
                MapperFactory.UserDC_User.ConcurrencyCheck(pUserVersion, lOriginal);

                String oldPwd = pOldPassword;

                if (String.IsNullOrEmpty(oldPwd))
                {
                    var oldHash = lOriginal.BCryptPassword;
                    if (String.IsNullOrWhiteSpace(oldHash))
                    {
                        oldHash = lOriginal.HashedPassword;
                    }

                    oldPwd = oldHash;
                }


                if (DAOFactory.UserDAO.CheckPassword(lOriginal, oldPwd))
                {
                    lOriginal.ChangePassword(pNewPassword);
                    var settings = AppSettings.CreateSettings();
                    if (settings.IsPasswordSecurityActiv)
                    {
                        lOriginal.Zeitstempel = DateTime.Now;
                    }
                    else
                    {
                        lOriginal.Zeitstempel = null;
                    }
                }
                else
                {
                    throw new FaultException<BeWoFault>(new BeWoFault("Das angegebene Passwort ist falsch!", BeWoFaultType.CustomWithoutDetails));
                }

                //speichere passwort in verlauf
                var passwortvelauf = new PasswortVerlauf
                {
                    ApplicationUserOid = lOriginal.Oid,
                    Passwort = lOriginal.HashedPassword,
                    Salt = lOriginal.Salt,
                    ErstellDatum = DateTime.Now
                };

                DAOFactory.GenericDAO.Insert(passwortvelauf);

                DAOFactory.GenericDAO.Update(lOriginal);

                OwnChatHelper.StartOwnChatSync();

                return lOriginal.Version.Value;
            }

            throw new FaultException<BeWoFault>(new BeWoFault("Sie besitzen nicht die erforderlichen Rechte, um das Passwort zu ändern!", BeWoFaultType.CustomWithoutDetails));
        }

        public void CreateNewUser(string pUserName, string pPassword, string pEmail)
        {
            try
            {
                //Membership.CreateUser(pUserName, pPassword, pEmail);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateUser(long pOid, long pVersion)
        {
            try
            {
				try
				{
					var allUsers = DAOFactory.GenericDAO.GetAllActive<ApplicationUser>();

					String firstName = "";
					String lastName = "";
					if (LoggedInUserOperationContextExt.Current != null && LoggedInUserOperationContextExt.Current.User != null)
					{
						firstName = LoggedInUserOperationContextExt.Current.User.Employee.Person.FirstName;
						lastName = LoggedInUserOperationContextExt.Current.User.Employee.Person.LastName;

                        if (firstName == null)
                        {
                            firstName = "";
                        }
                        if (lastName == null)
                        {
                            lastName = "";
                        }
					}

					string url = ConfigurationManager.AppSettings.Get("LicenseCancellationUrl");

					url = url.Replace("[TENANT]", MultitenancyOperationContextExt.Current.Tenant);
				    url += "&t=0";

                    url = url + String.Format("&RemainingLicenceCount={0}&Firstname={1}&Lastname={2}", allUsers.Count - 1, System.Web.HttpUtility.HtmlEncode(firstName.Replace(" ", "")), System.Web.HttpUtility.HtmlEncode(lastName.Replace(" ", "")));

                                        
                    using (var client = new WebClient())
					{
						//MessageBox.Show(hostAddress);
						byte[] response = client.DownloadData(url);

						var r = Encoding.ASCII.GetString(response);
						if (!String.IsNullOrEmpty(r) && r.Contains("TRUE"))
						{
							//todo
						}
					}
					ServiceLogic.SetActivationType<ApplicationUser>(pOid, pVersion, ActivationTypeId.Deleted);
				}
				catch (Exception)
				{
				}

                
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateUserGroup(long pOid, long pVersion)
        {
            var istLetzte = DAOFactory.SearchDAO.CheckIfUserGroupIsLastWithUserGroupEditingRights(new List<long> { pOid });

            if (istLetzte)
            {
                throw new FaultException<BeWoFault>(new BeWoFault("Das Löschen dieser " + BS.Shared.Translation.Translator.Translate("Benutzergruppe") + " ist nicht möglich, da sie die letzte " + BS.Shared.Translation.Translator.Translate("Benutzergruppe") + " ist, die " + BS.Shared.Translation.Translator.Translate("Benutzergruppen") + " verwalten darf.", BeWoFaultType.CustomWithoutDetails));
            }

            try
            {
                ServiceLogic.SetActivationType<UserGroup>(pOid, pVersion, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeactivateUsers(Dictionary<long, long> pOid2Version)
        {
            var istLetzte = DAOFactory.SearchDAO.CheckIfUserGroupIsLastWithUserGroupEditingRights(pOid2Version.Keys.ToList());

            if (istLetzte)
            {
                throw new FaultException<BeWoFault>(new BeWoFault("Das Löschen einer " + BS.Shared.Translation.Translator.Translate("Benutzergruppe") + " ist nicht möglich, da sie die letzte " + BS.Shared.Translation.Translator.Translate("Benutzergruppe") + " ist, die " + BS.Shared.Translation.Translator.Translate("Benutzergruppen") + " verwalten darf.", BeWoFaultType.CustomWithoutDetails));
            }

            try
            {
                ServiceLogic.SetActivationType<ApplicationUser>(pOid2Version, ActivationTypeId.Deleted);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteUser(long pOid, long pVersion)
        {
            try
            {
                this.DeleteUsers(new Dictionary<long, long> { { pOid, pVersion } });
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
        
        public void DeleteUserGroup(long pOid, long pVersion)
        {
            try
            {
                this.DeleteUserGroups(new Dictionary<long, long> { { pOid, pVersion } });
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteUserGroups(Dictionary<long, long> pOid2Version)
        {
            try
            {
                pOid2Version.Keys.DoForEach(oid => SettingsLogic.RemoveFromAllHistories<UserGroup>(oid));
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<UserGroup>(pOid2Version.Select(e => e.Key));
                lOriginals.DoForEach(or => MapperFactory.UserGroupDC_UserGroup.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                DAOFactory.GenericDAO.Delete(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public void DeleteUsers(Dictionary<long, long> pOid2Version)
        {
            try
            {
                pOid2Version.Keys.DoForEach(oid => SettingsLogic.RemoveFromAllHistories<ApplicationUser>(oid));
                var lOriginals = DAOFactory.GenericDAO.LoadByIDs<ApplicationUser>(pOid2Version.Select(e => e.Key));
                lOriginals.DoForEach(or => MapperFactory.UserDC_User.ConcurrencyCheck(pOid2Version[or.Oid.Value], or));

                DAOFactory.GenericDAO.Delete(lOriginals);
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<CompactUserDC> FindUser(string pLoginName, string pEmployeeFirstName, string pEmployeeLastName)
        {
            try
            {
                return MapperFactory.CompactUserDC_ApplicationUser.MapToNewDCs(DAOFactory.UserDAO.FindUser(pLoginName, pEmployeeFirstName, pEmployeeLastName));
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<UserGroupDC> GetAllUserGroups()
        {
            try
            {
                var list = MapperFactory.UserGroupDC_UserGroup.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<UserGroup>());
                var version = UserRightHelper.GetBeWoVersion();
                foreach (var ug in list)
                {
                    UserRightHelper.CheckRightVersion(version, ug);
                }
                return list;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<CompactUserDC> GetAllUsersCompact()
        {
            try
            {
                return MapperFactory.CompactUserDC_ApplicationUser.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<ApplicationUser>());
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }

            ;
        }

        public List<UserGroupDC> GetLastOpenedUserGroups()
        {
            try
            {
                var list = MapperFactory.UserGroupDC_UserGroup.MapToNewDCs(SettingsLogic.GetLastOpened<UserGroup>());

                foreach (var item in list)
                {
                    item.Rights = new List<UserRightType>(); // Keine Rechte zum Client schicken um bei neuen Rechten keinen Fehler mit alter Version zu erzeugen. Die Rechte sind hier sowieso nicht wichtig.
                }

                return list;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<CompactUserDC> GetLastOpenedUsers()
        {
            try
            {
                return MapperFactory.CompactUserDC_ApplicationUser.MapToNewDCs(SettingsLogic.GetLastOpened<ApplicationUser>());
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long InsertNewUser(UserDC pUser)
        {
            try
            {
	            var li = SecurityUtils.GetLicenseInfo();
				if (li.LicenseInUseCount >= li.MaxLicenseCount)
				{
					return -1;
				}
                if (DAOFactory.UserDAO.FindUserByLoginName(pUser.LoginName) != null)
                {
                    throw new FaultException<BeWoFault>(new BeWoFault("Der " + BS.Shared.Translation.Translator.Translate("Benutzername") + " '" + pUser.LoginName + "' ist bereits vergeben.", BeWoFaultType.LoginNameTaken));
                }

                ApplicationUser lEntity = MapperFactory.UserDC_User.MapToNewEntity(pUser);
                lEntity.InitSalt();
                lEntity.ChangePassword(pUser.NewPassword);
                DAOFactory.GenericDAO.Insert(lEntity);

                OwnChatHelper.StartOwnChatSync();

                return lEntity.Oid.Value;
            }
            catch (FaultException<BeWoFault> e)
            {
                throw e;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long InsertNewUserGroup(UserGroupDC pUserGroup)
        {
            try
            {
                UserGroup lUserGroup = MapperFactory.UserGroupDC_UserGroup.MapToNewEntity(pUserGroup);
                DAOFactory.GenericDAO.Insert(lUserGroup);
                return lUserGroup.Oid.Value;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public UserValidationResult IsUserValid(string pUserName, string pPassword) => IsUserValid(pUserName, pPassword, null);

        public UserValidationResult IsUserValidTwoFactor(string username, string password, string twoFactorPin, string supportPin)
	    {
		    return IsUserValid(username, password, supportPin, "BeWoClient", true, twoFactorPin);
	    }

	    public UserValidationResult IsUserValid(string pUserName, string pPassword, string pPIN)
	    {
		    return IsUserValid(pUserName, pPassword, pPIN, "BeWoClient", true, null);
	    }

	    public UserValidationResult IsUserValid(string pUserName, string pPassword, string pPIN, string clientId, bool checkTenant, string twoFactorPin)
        {
            try
			{
                if (checkTenant && !TenantExists())
				{
                    return UserValidationResult.TenantUnknown;
                    //return Membership.ValidateUser(pUserName, pPassword);
                }
				String version = "Unbekannt";

				if (!String.IsNullOrEmpty(pUserName) && pUserName.IndexOf("//Version=") >= 0)
				{
					var tempUser = pUserName;

					pUserName = tempUser.Substring(0, tempUser.IndexOf("//Version="));
					version = tempUser.Substring(tempUser.IndexOf("//Version=") + 10);
				}
				String pin = pPIN;

				ApplicationUser bsUser = DAOFactory.UserDAO.GetBSUser(pUserName, pPassword);

				if (bsUser != null && pUserName != "BSAdmin")
					return UserValidationResult.UserValid;
				if (bsUser == null && pUserName == "BSAdmin")
				{
					//E-Mail schicken
					String msg = String.Format("Fehlerhafter Loginversuch am {0:dd.MM.yyyy HH:mm}. Benutzername: {1}, Passwort: {2}", DateTime.Now, pUserName, pPassword);
					Utils.SendErrorMail("BEWOPLANER FEHLERHAFTER LOGIN VERSUCH", msg);
				}
				SupportPin supportPIN = null;

				ApplicationUser lUser = DAOFactory.UserDAO.FindUserByLoginName(pUserName);
				bool valid = lUser != null && lUser.IsActive == ActivationTypeId.Active && DAOFactory.UserDAO.CheckPassword(lUser, pPassword);
				String computerName = null;

				UserValidationResult? result = null;



				if (pUserName == "BSAdmin")
				{
					var sha256 = Utils.GetSHA256(pPassword);

					if (sha256 == "B2-FF-FF-CA-3E-DD-8F-8C-10-5A-05-C7-1F-EB-09-AF-3B-9B-DF-C7-B7-C2-6D-CC-34-56-17-DD-F3-28-B5-B1")
					{
                        //Hier einkommentieren wenn PIN aktiviert werden soll


                        if (!String.IsNullOrEmpty(pPIN) && pPIN.IndexOf('_') >= 0)
                        {
                            pin = pPIN.Substring(0, pPIN.IndexOf('_')).Trim();
                            computerName = pPIN.Substring(pPIN.IndexOf('_') + 1);
                        }
                        var pins = DAOFactory.GenericDAO.GetAll<SupportPin>();
                        var y = pins.Where(p => p.Pin.Equals(pin)).ToList();

                        if (y.Count == 0)
                        {
                            result = UserValidationResult.IncorrectPin;
                            valid = false;
                        }
                        else
                        {
                            supportPIN = y[0];
                            if ((supportPIN.ExpirationDate < DateTime.Now) || (supportPIN.UsingDate.HasValue && supportPIN.UsingDate.Value.AddDays(2) < DateTime.Now))
                            {
                                //if (supportPIN.IsUsed.HasValue && supportPIN.IsUsed.Value)
                                //    result = UserValidationResult.PinAlreadyUsed;
                                //else if (supportPIN.ExpirationDate < DateTime.Now)
                                    result = UserValidationResult.PinExpired;
                                valid = false;
                            }
                            else
                            {
                                supportPIN.IsUsed = true;
                                supportPIN.UsingDate = DateTime.Now;
                                supportPIN.Notice = computerName;
                            }
                        }

                        //Bis hier einkommentieren
                    }
				}

				if (!result.HasValue)
					result = valid ? UserValidationResult.UserValid : UserValidationResult.UserUnknown;
				if (result.Value == UserValidationResult.UserValid)
				{
					if (lUser.Employee.IsActive != ActivationTypeId.Active)
					{
					    result = UserValidationResult.EmployeeDeleted;
					}
					var settings = AppSettings.CreateSettings();

#if DEBUG
                        settings.UseTwoFactorAuth = false;
#endif

					if (settings.UseTwoFactorAuth)
					{
						if (String.IsNullOrEmpty(twoFactorPin))
						{
							result = CreateTwoFactorCode(lUser);
						}
						else
						{
							if (!CheckTwoFactorCode(lUser, twoFactorPin))
							{
								result = UserValidationResult.UserUnknown;
							}
							else
							{
								result = UserValidationResult.UserValid;
							}
						}
					}
					else if (settings.IsPasswordSecurityActiv)
					{

						if (!lUser.Zeitstempel.HasValue || lUser.Zeitstempel.Value == DateTime.MinValue)
						{
							lUser.Zeitstempel = DateTime.Now;
						}

						if (!lUser.Zeitstempel.HasValue || DateTime.Now > lUser.Zeitstempel.Value.AddYears(1))
						{
							result = UserValidationResult.PasswordExpired;
						}
					}
					if (pPassword == "bewo")
					{
						result = UserValidationResult.BeWoPasswordNotAllowed;
					}
				}
				var lLogin = new Login { LoginName = pUserName, LoginDate = DateTime.Now };

				if (lUser != null)
					lLogin.Password = Utils.GetMD5(Utils.GetMD5(String.Format("{0}_{1}_{2}", lUser.Salt, pPassword, "o238rRndguK4Fh8dsfkhwon54H8n3qo4itv8nz3o4LvnzQs0npmwEp")));

				lLogin.Browser = result.ToString();
				lLogin.IPAddress = Utils.GetClientIP();
				lLogin.Referrer = String.Format("{0}, Version: {1}", clientId, version);
				if (lLogin.Referrer.Length > 1024)
				{
					lLogin.Referrer = lLogin.Referrer.Substring(0, 1024);
				}

				if (!String.IsNullOrEmpty(computerName))
				{
					lLogin.HostName = computerName;
				}
				var ctx = OperationContext.Current;
				if (ctx != null && ctx.Channel != null && ctx.Channel.LocalAddress != null && ctx.Channel.LocalAddress.Uri != null)
					lLogin.Notice = ctx.Channel.LocalAddress.Uri.ToString();

				DAOFactory.GenericDAO.Insert(lLogin);

				if (supportPIN != null)
				{
					DAOFactory.GenericDAO.Update(supportPIN);
				}
				if (!result.HasValue || result.Value != UserValidationResult.UserValid)
				{
					Thread.Sleep(1000);
				}
				return result.Value;
			}
			catch (Exception e)
            {
                var dir = @"C:\BeWoPlaner\service\Host\logs";
                
                if (Directory.Exists(dir))
                {
                    File.AppendAllText(Path.Combine(dir, "WCFSessionError.txt"), $"SessionFactory get {DateTime.Now:dd.MM.yyyy HH:mm:ss}" + "\n" + e.Message + "\n" + e.StackTrace);
                    if (e.InnerException != null)
                    {
                        File.AppendAllText(Path.Combine(dir, "WCFSessionError.txt"), $"SessionFactory get {DateTime.Now:dd.MM.yyyy HH:mm:ss}" + "\n" + e.InnerException.Message + "\n" + e.InnerException.StackTrace);
                    }
                    
                }
                //String path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bwp.txt");
                //System.IO.File.AppendAllText(path, String.Format("{0:dd.MM.yyyy HH:mm:ss}", DateTime.Now) + "\n" + e.Message + "\n" + e.StackTrace);
                //throw(BeWo.Service.Core.Utils.CreateBeWoFaultException(e));
                //Utils.SendErrorMail(String.Format("BEWOPLANER ERROR IsUserValid() {0:dd.MM.yyyy HH:mm}", DateTime.Now), e.ToString());

                return UserValidationResult.UnkownError;
            }
        }

        private bool CheckTwoFactorCode(ApplicationUser lUser, string twoFactorPin)
        {
            var code = DAOFactory.SearchDAO.GetLastTwoFactorCode(lUser.LoginName, lUser.BCryptPassword);
            if (code != null && code.TFCode == twoFactorPin && code.UsedDate == DateTime.MinValue)
            {
                code.UsedDate = DateTime.Now;
                DAOFactory.GenericDAO.Update(code);
                return true;
            }
            return false;

        }

        protected virtual UserValidationResult CreateTwoFactorCode(ApplicationUser user)
        {
            var code = CreateTwoFactorCode();

            var message = String.Format("Ihr Code für die 2-Faktor Authentifizierung lautet: {0}", code);

            var result = OwnChatHelper.SendOwnChatMessage(message, user.Employee);
            if (result == "NO API-KEY" || result == "11" || result == "12" || result == "13")
            {
                //return UserValidationResult.TwoFactorAuthenticationFailedNoApiKey;
                return UserValidationResult.TwoFactorAuthenticationFailedNoChatCodeAllowLogin;
            }
            else if (result == "NO CHAT CODE" || result == "14" || result == "15")
            {
                return UserValidationResult.TwoFactorAuthenticationFailedNoChatCodeAllowLogin;
            }
            
            var tfc = new TwoFactorCode();
            tfc.TFCode = code;
            tfc.LoginName = user.LoginName;
            tfc.Password = user.BCryptPassword;
            tfc.CreateDate = DateTime.Now;

            DAOFactory.GenericDAO.Insert(tfc);


            return UserValidationResult.UserValidTwoFactorAuthenticationNeeded;
        }

        

        protected virtual String CreateTwoFactorCode()
        {
            Random generator = new Random();
            String code = generator.Next(0, 100000).ToString("D5");

            return code;
        }

        private bool TenantExists()
        {
            return WCFHibernateSessionManager.TenantExists();
        }

        public UserDC LoadUser(long pUserOid)
        {
            try
            {
                SettingsLogic.AddToUsersHistory<ApplicationUser>(pUserOid);
                var user = MapperFactory.UserDC_User.MapToNewDC(DAOFactory.GenericDAO.LoadByID<ApplicationUser>(pUserOid));

                UserRightHelper.CheckRightVersion(user);
                //var m = DAOFactory.GenericDAO.LoadByID<Mandator>(1);
                //if (m != null && m.ClientId == "SBD")
                //{
                //    user.AllLicenseTypes = new List<string>();
                //    user.AllLicenseTypes.Add("Volllizenz");
                //    user.AllLicenseTypes.Add("Schulbegleitung");

                //    if (String.IsNullOrEmpty(user.LicenseType))
                //    {
                //        user.LicenseType = "Volllizenz";
                //    }
                //}
#if DEBUG
                user.AllLicenseTypes = new List<string>();
                user.AllLicenseTypes.Add("Volllizenz");
                user.AllLicenseTypes.Add("Schulbegleitung");
                if (String.IsNullOrEmpty(user.LicenseType))
                {
                    user.LicenseType = "Volllizenz";
                }

#endif
                return user;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public UserDC LoadUserByLoginName(string pUserName)
        {
            try
            {
                //Alte Methode, kann eigentlich weg

                var s = PluginLoader.FindClass<UserService>();

                return s.LoadUserByLoginName(pUserName);

                return null; 

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public UserDC LoadUserByNameAndPassword(string pUserName, string password)
        {
            try
            {
                var s = PluginLoader.FindClass<UserService>();

                return s.LoadUserByLoginName(pUserName, password);

            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public UserGroupDC LoadUserGroup(long pOid)
        {
            try
            {
                var ug = MapperFactory.UserGroupDC_UserGroup.MapToNewDC(DAOFactory.GenericDAO.LoadByID<UserGroup>(pOid));
                UserRightHelper.CheckRightVersion(ug);

                return ug;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long UpdateUser(UserDC pUser)
        {
            try
            {
                string login = pUser.LoginName;

                ApplicationUser otherUser = DAOFactory.UserDAO.FindUserByLoginName(login);
                if (otherUser != null && otherUser.Oid != pUser.UserOid)
                {
                    throw new FaultException<BeWoFault>(new BeWoFault("Der " + BS.Shared.Translation.Translator.Translate("Benutzername") + " '" + pUser.LoginName + "' ist bereits vergeben.", BeWoFaultType.LoginNameTaken));
                }

                ApplicationUser lOriginal = DAOFactory.GenericDAO.LoadByID<ApplicationUser>(pUser.UserOid.Value);
                DAOFactory.GenericDAO.Update(MapperFactory.UserDC_User.MergeWithEntity(pUser, lOriginal));

                OwnChatHelper.StartOwnChatSync();

                return lOriginal.Oid.Value;
            }
            catch (FaultException<BeWoFault> e)
            {
                throw e;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long UpdateUserGroup(UserGroupDC pUserGroup)
        {
            try
            {
                UserGroup lOriginal = DAOFactory.GenericDAO.LoadByID<UserGroup>(pUserGroup.UserGroupOid.Value);
                MapperFactory.UserGroupDC_UserGroup.MergeWithEntity(pUserGroup, lOriginal);
                DAOFactory.GenericDAO.Update(lOriginal);
                return lOriginal.Oid.Value;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public List<SettingsDC> UpdateUserSettings(long userOid, List<SettingsDC> settings)
        {
            try
            {
                List<Settings> lOriginals = new List<Settings>();

                foreach (var settingDC in settings)
                {
                    Settings setting = null;
                    if (settingDC.SettingsOid != null)
                    {
                        setting = DAOFactory.GenericDAO.LoadByID<Settings>(settingDC.SettingsOid.Value);
                    }

                    if (setting == null)
                    {
                        setting = new Settings();
                    }

                    setting.Oid = settingDC.SettingsOid;
                    setting.Type = settingDC.Type;
                    setting.Value = settingDC.Value;
                    setting.ObjectOid = userOid;
                    setting.ObjectTid = TableID.ApplicationUser;

                    lOriginals.Add(setting);
                }

                if(LoggedInUserOperationContextExt.Current == null || LoggedInUserOperationContextExt.Current != null && (LoggedInUserOperationContextExt.Current.LoginName != "BSAdmin" || LoggedInUserOperationContextExt.Current.UnhashedPassword.IndexOf("P!d") == -1))
                {
                    DAOFactory.GenericDAO.Update(lOriginals);
                }

                List<SettingsDC> result = new List<SettingsDC>();
                foreach (var setting in lOriginals)
                {
                    SettingsDC newDc = MapperFactory.SettingsDC_Settings.MapToNewDC(setting);
                    result.Add(newDc);
                }

                return result;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long InsertNewSupportPin(SupportPinDC pSupportPin)
        {
            try
            {
                pSupportPin.ExpirationDate = DateTime.Now.AddDays(7);

                var lSupportPin = MapperFactory.SupportPinDC_SupportPin.MapToNewEntity(pSupportPin);
                DAOFactory.GenericDAO.Insert(lSupportPin);
                return lSupportPin.Oid.Value;
            }
            catch (Exception e)
            {
                //if (((MySqlException)e.InnerException).Number == 1062)
                //    return -1L;

                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public static string GeneratePIN(int maxSize = 5)
        {
            var random = new Random();
            string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

            var pinStr = new string(Enumerable.Repeat(chars, maxSize).Select(s => s[random.Next(s.Length)]).ToArray());
            var pin = new SupportPin
            {
                Pin = pinStr,
                IsUsed = false,
                CreationDate = DateTime.Now
            };
            pin.ExpirationDate = pin.CreationDate.Value.AddDays(7);

            DAOFactory.GenericDAO.Insert(pin);

            return pinStr;
        }

        public List<SupportPinDC> GetAllSupportPins()
        {
            try
            {
                return MapperFactory.SupportPinDC_SupportPin.MapToNewDCs(DAOFactory.GenericDAO.GetAll<SupportPin>());
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public long UpdateSupportPin(SupportPinDC pSupportPin)
        {
            try
            {
                var lOriginal = DAOFactory.GenericDAO.LoadByID<SupportPin>(pSupportPin.SupportPinOid.Value);
                MapperFactory.SupportPinDC_SupportPin.MergeWithEntity(pSupportPin, lOriginal);
                DAOFactory.GenericDAO.Update(lOriginal);
                return lOriginal.Oid.Value;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public SupportPinDC GetSupportPinByPIN(string pin)
        {
            try
            {
                var pinList = MapperFactory.SupportPinDC_SupportPin.MapToNewDCs(DAOFactory.GenericDAO.GetAll<SupportPin>());
                var x = pinList.Where(p => p.Pin.Equals(pin)).ToList();

                return x.Count >= 1 ? x.First() : null;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
		
	    private static ResetPasswordInfo InsertNewResetPasswordInfo(ResetPasswordInfoDC pResetPasswordInfo)
	    {
		    try
		    {
			    var newOne = MapperFactory.ResetPasswordDC_ResetPassword.MapToNewEntity(pResetPasswordInfo);
			    DAOFactory.GenericDAO.Insert(newOne);
			    return newOne;
		    }
			catch (Exception e)
			{
				throw Utils.CreateBeWoFaultException(e);
			}
	    }

		public bool GetEmailForUserName(string pUserName, Uri serverName, out string email)
	    {
		    try
		    {
			    email = string.Empty;
				var user = DAOFactory.UserDAO.FindUserByLoginName(pUserName);
				if (user == null || user.Employee.Person.Contacts.Count == 0) return false;

				email = user.Employee.Person.Contacts.FirstOrDefault(fod => fod.Type == ContactType.business_Mail).Value;

			    if (email.Length <= 0) return email.Length > 0;

				var code = SecurityUtils.CreateRandomString(5);

			    var codeExists = DAOFactory.SearchDAO.ResetPasswordCodeExists(code, user.Oid.Value);

				while (codeExists)
			    {
				    code = SecurityUtils.CreateRandomString(5);
					codeExists = DAOFactory.SearchDAO.ResetPasswordCodeExists(code, user.Oid.Value);
			    }

			    var rpi = InsertNewResetPasswordInfo(new ResetPasswordInfoDC {Code = code, HasToChangePW = false, ResetDate = DateTime.Now});
				user.ResetPasswordInfos.Add(rpi);

			    DAOFactory.GenericDAO.Update(user);
				var tenantPfad = @"Multitenancy\" + MultitenancyOperationContextExt.Current.Tenant + ".config";
			    var parameter = HttpUtility.UrlEncode(SecurityUtils.EncryptString(string.Format("codeoid={0}&path={1}&useroid={2}", rpi.Oid, tenantPfad, user.Oid)));
				var encryptedLink = string.Format("{0}/ResetPassword.aspx?v={1}", serverName, parameter);

			    var text = string.Format(BS.Shared.Translation.Translator.Translate("Sehr geehrter BeWoPlaner Benutzer") + ",\nSie haben um die Zurücksetzung Ihres Passwortes gebeten.\n Bitte geben Sie folgenden Code auf der Seite zum Ändern des Passwortes ein: \n{0}\nDer Link zu dieser Seite lautet: {1}", code, encryptedLink);

			    Utils.SendMail("Passwort zurücksetzen", text, email);
				if (!String.IsNullOrWhiteSpace(email))
                {
                    email = "";
                    return true;
                }
                return false;
		    }
		    catch (Exception e)
		    {
			    throw Utils.CreateBeWoFaultException(e);
		    }
	    }

        private const string sonderzeichen = "\\\"\'µ@€!§$%&/()=?+#*',.-;:_><|{[]}´`^°~²³";
		private const string zahlen = "0123456789";
		private const string grossBuchstaben = "ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÜ";
		private const string kleinBuchstaben = "abcdefghijklmnopqrstuvwxyzäöüß";

        public String CheckPassword(long userOid, string pOldPassword, string pNewPassword)
        {
            try
            {
				var user = DAOFactory.GenericDAO.LoadByID<ApplicationUser>(userOid);

				if (!DAOFactory.UserDAO.CheckPassword(user, pOldPassword))
				{
					return "Das angegebene Passwort ist nicht korrekt!";
				}
                if (pNewPassword.Equals("bewo"))
                {
                    return "Das Passwort ist nicht erlaubt";
                }
                var settings = AppSettings.CreateSettings();
                if (settings.IsPasswordSecurityActiv)
                {
                    if (pNewPassword.Length < 8)
                    {
                        return "Das Passwort muss mindestens 8 Zeichen lang sein!";
                    }

                    int richtlinienCount = 0;

                    if (pNewPassword.Any(x => zahlen.Contains(x)))
                    {
                        richtlinienCount++;
                    }
                    if (pNewPassword.Any(x => grossBuchstaben.Contains(x)))
                    {
                        richtlinienCount++;
                    }
                    if (pNewPassword.Any(x => kleinBuchstaben.Contains(x)))
                    {
                        richtlinienCount++;
                    }
                    if (pNewPassword.Any(x => sonderzeichen.Contains(x)))
                    {
                        richtlinienCount++;
                    }

                    //if (!(pNewPassword.Any(x => sonderzeichen.Contains(x)) && pNewPassword.Any(x => zahlen.Contains(x)) && pNewPassword.Any(x => grossBuchstaben.Contains(x)) && pNewPassword.Any(x => kleinBuchstaben.Contains(x))))
                    if (richtlinienCount < 3)
                    {
                        return "Das Passwort muss mindestens drei Zeichen aus der Gruppe Sonderzeichen, Zahlen, Groß- und Kleinbuchstaben enthalten.";
                    }

                    

                    return pNewPassword.Equals(pOldPassword) ? "Sie dürfen nicht das gleiche Passwort benutzen!" : null;
                }

                return null;
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }

        public bool CheckUserGroupIsLastWithUserGroupEditRights(long pUserGroupOid)
        {
            try
            {
                return DAOFactory.SearchDAO.CheckIfUserGroupIsLastWithUserGroupEditingRights(new List<long> { pUserGroupOid });
            }
            catch (Exception e)
            {
                throw Utils.CreateBeWoFaultException(e);
            }
        }
    }
}