1041 lines
37 KiB
C#
1041 lines
37 KiB
C#
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;
|
||
|
||
if (!String.IsNullOrEmpty(pin))
|
||
{
|
||
|
||
}
|
||
|
||
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('_'));
|
||
// 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.IsUsed.Value ||
|
||
// supportPIN.ExpirationDate < DateTime.Now ||
|
||
// supportPIN.UsingDate != null)
|
||
// {
|
||
// 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.Archived)
|
||
//{
|
||
//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
|
||
{
|
||
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 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);
|
||
}
|
||
}
|
||
}
|
||
} |