1034 lines
40 KiB
C#
1034 lines
40 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 MySql.Data.MySqlClient;
|
||
using BeWo.Service.Configuration;
|
||
using BeWo.Service.OwnChat;
|
||
using BeWo.Service.Plugins;
|
||
using BeWo.Data.Security;
|
||
using System.Collections.Specialized;
|
||
|
||
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())
|
||
{
|
||
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)
|
||
{
|
||
|
||
String tfcode = CreateTwoFactorCode(lUser);
|
||
|
||
result = UserValidationResult.UserValidTwoFactorAuthenticationNeeded;
|
||
}
|
||
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;
|
||
//return Membership.ValidateUser(pUserName, pPassword);
|
||
}
|
||
|
||
return UserValidationResult.TenantUnknown;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
//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;
|
||
}
|
||
}
|
||
|
||
protected virtual String CreateTwoFactorCode(ApplicationUser user)
|
||
{
|
||
String pin = "";
|
||
|
||
/*
|
||
* Hi,
|
||
|
||
hier mal die Infos für die 2FA Implementierung.
|
||
fwev
|
||
Der POST-Request geht an
|
||
|
||
https://[SERVER-URL]/api/ownchat/sendmessage/user/[API-KEY]/[CUSTOMERID]/[USERID] oder
|
||
|
||
[SERVER-URL] = Server des Kunden (Zu finden über Dictionary -> siehe z.B. Chat-Code Erstellung im BWP)
|
||
[API-KEY] = Der Key, den du immer hinterlegst (siehe z.B. Chat-Code Erstellung im BWP)
|
||
[USERID] = interne User-ID des Users, der sich gerade anmeldet. Das ist m.W. bei euch immer "E" (=Employee) oder "C" (=Client) plus OID. Also z.B. "E123" oder "C456". Schau mal in Lyns Code beim Endpunkt [BWP-Server-URL]/Chat/LoginToken/?typ=users
|
||
|
||
Per POST-Field dann noch "text". Z.B. "Ihre 2FA-Code lautet: xyz" oder halt statt "2FA" der Begriff, der auch in deiner Login-Maske verwendet wird, damit die nicht durcheinander kommen.
|
||
|
||
Es gibt eine Sache auf die du achten musst: Nicht jeder User muss zwangsläufig ein ownChat-User sein!! Insb. bei den Kunden die pro Lizenz zahlen ist das der Fall, weil die nicht jedem eine Lizenz bezahlen wollen.
|
||
|
||
Vermutlich ist es am einfachsten, wenn du versuchst einen 2FA-Code an den User zu senden. Dann bekommst du vom ownChat-Backend in einem solchen Fall eine Fehlermeldung zurück, dass der User nicht existiert (s.u.). Außerdem wir der Request immer um 5 sec verzögert um Brute-Force zu verhindern.
|
||
|
||
Wenn das so ist, schreibst du eine Meldung a la "Eine 2-Faktor-Authentifizierung ist nicht möglich, da Sie kein(e) aktive(r) ownChat-Nutzer(in) sind. Bitte wenden Sie sich an Ihre Administratoren.". Dann lässt du den User ohne 2FA rein. Die Meldung geht denen dann hoffentlich auf den Nerv und die Inhaber/Admin versorgen Ihre Leute mit ownChat.
|
||
|
||
Als Response kommt immer ein JSON zurück. Wenn success=true, dann ist alles fein. Sonst unterhalb von errors
|
||
|
||
* error:11 -> Kundennummer unbekannt
|
||
* error:12 -> Der API-Key ist falsch -> Auth-Error
|
||
* error:13 -> Es existiert kein API-Key für die angegeben Kundennummer
|
||
* error:14 -> Ziel-Gruppe/-User existiert nicht
|
||
* error:15 -> System-User existiert nicht
|
||
|
||
LG
|
||
*/
|
||
|
||
string url = ConfigurationManager.AppSettings.Get("OwnChatUrl");
|
||
if (String.IsNullOrEmpty(url))
|
||
{
|
||
url = "https://[SERVER-URL]/api/ownchat/sendmessage/user/[API-KEY]/[CUSTOMERID]/[USERID]";
|
||
}
|
||
var m = DAOFactory.GenericDAO.LoadByID<Mandator>(1);
|
||
if (m == null || String.IsNullOrEmpty(m.Apikey))
|
||
{
|
||
return "NO API-KEY";
|
||
}
|
||
var serverUrl = OwnChatHelper.ErmittleServerURL(MultitenancyOperationContextExt.Current.Tenant);
|
||
var chatcode = DAOFactory.SearchDAO.FindAllEmployeeAppCodes(user.Employee.Oid.Value).OrderByDescending(c => c.InsTs).FirstOrDefault();
|
||
if (chatcode == null || String.IsNullOrEmpty(chatcode.EmployeeCode))
|
||
{
|
||
return "NO CHAT CODE";
|
||
}
|
||
url = url.Replace("[SERVER-URL]", serverUrl);
|
||
url = url.Replace("[API-KEY]", m.Apikey);
|
||
url = url.Replace("[USERID]", String.Format("E{0}", user.Employee.Oid));
|
||
|
||
|
||
|
||
using (var client = new WebClient())
|
||
{
|
||
var nvc = new NameValueCollection();
|
||
nvc.Add("text", "Ihr Code für die 2-Faktor Authentifizierung lautet:");
|
||
|
||
|
||
//var definition = new { mel = "", stm = new { pre = "", post = "" }, pmt = new { pre = "", post = "" } };
|
||
var response = client.UploadValues(url, "POST", nvc);
|
||
String responseStr = System.Text.Encoding.UTF8.GetString(response);
|
||
//var json = JsonConvert.DeserializeAnonymousType(responseStr, definition);
|
||
}
|
||
|
||
return pin;
|
||
}
|
||
|
||
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);
|
||
|
||
return email.Length > 0;
|
||
}
|
||
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);
|
||
}
|
||
}
|
||
}
|
||
} |