BeWoPlaner/Service/ServiceImplementations/LauncherServiceImp.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using BeWo.Data;
using BeWo.Service.Plugins;
using BS.Shared.DataContracts.Compact;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.Core;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.ServiceContracts;

using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.SharedLauncher;

using BeWo.Service.Invoicing;
using System.IO;
using System.Configuration;
using System.Diagnostics;
using BeWo.Service.Configuration;
using Castle.Core;
using BS.SharedLauncher.DataContract;
using BS.SharedLauncher.Information;
using BS.SharedLauncher.Enums;

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

        private Dictionary<BS.Shared.UserValidationResult, BS.SharedLauncher.Enums.UserValidationResult> UserValidationMapper = new Dictionary<BS.Shared.UserValidationResult, BS.SharedLauncher.Enums.UserValidationResult>()
        {
            { BS.Shared.UserValidationResult.EmployeeDeleted, BS.SharedLauncher.Enums.UserValidationResult.UnknownError},
            { BS.Shared.UserValidationResult.IncorrectPin, BS.SharedLauncher.Enums.UserValidationResult.IncorrectPin},
            { BS.Shared.UserValidationResult.PasswordExpired, BS.SharedLauncher.Enums.UserValidationResult.PasswordExpired},
            { BS.Shared.UserValidationResult.PinAlreadyUsed, BS.SharedLauncher.Enums.UserValidationResult.PinAlreadyUsed},
            { BS.Shared.UserValidationResult.PinExpired, BS.SharedLauncher.Enums.UserValidationResult.PinExpired},
            { BS.Shared.UserValidationResult.TenantUnknown, BS.SharedLauncher.Enums.UserValidationResult.TenantUnknown},
            { BS.Shared.UserValidationResult.UnkownError, BS.SharedLauncher.Enums.UserValidationResult.UnknownError},
            { BS.Shared.UserValidationResult.UserValid, BS.SharedLauncher.Enums.UserValidationResult.UserValid},
            { BS.Shared.UserValidationResult.UserValidTwoFactorAuthenticationNeeded, BS.SharedLauncher.Enums.UserValidationResult.UnknownError},
            { BS.Shared.UserValidationResult.EmployeeDeleted, BS.SharedLauncher.Enums.UserValidationResult.EmployeeDeleted},
        };

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

                if (pNewPassword.Equals(pOldPassword))
                {
                    return PasswordValidationResult.AreTheSame;
                }

                if (!DAOFactory.UserDAO.CheckPassword(user, pOldPassword))
                {
                    return PasswordValidationResult.NotCorrect;
                }

                var settings = AppSettings.CreateSettings();
                if (settings.IsPasswordSecurityActiv)
                {
                    if (pNewPassword.Length < 8)
                    {
                        return PasswordValidationResult.NotLongEnough;
                    }

                    if (pNewPassword.Equals("bewo"))
                    {
                        return PasswordValidationResult.ImFunnyAndUsingBewoAsPasswordSmile;
                    }

                    if (!CheckPasswordStrongEnough(pNewPassword))
                    {
                        return PasswordValidationResult.NotSpecialEnough;
                    }
                }

                return PasswordValidationResult.Succesful;
            }
            catch (Exception e)
            {
                throw Core.Utils.CreateBeWoFaultException(e);
            }
        }
        public PasswordValidationResult CheckPassword2(string userName, string pOldPassword, string pNewPassword)
        {
            try
            {
                var allAppUser = DAOFactory.GenericDAO.GetAllActive<ApplicationUser>();

                var id = allAppUser.ToList().Find(x => x.LoginName == userName).Oid.Value;

                return CheckPassword(id, pOldPassword, pNewPassword);
            }
            catch (Exception e)
            {
                throw Core.Utils.CreateBeWoFaultException(e);
            }
        }
        private bool CheckPasswordStrongEnough(string password)
        {
            return true;

            //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 PasswordValidationResult.NotSpecialEnough;
            //}
        }
        public long ChangePassword(string pUserName, string pOldPassword, string pNewPassword)
        {
            try
            {
                var user = DAOFactory.UserDAO.FindUserByLoginName(SessionInformation.Login.Username);

                var version = (new UserServiceImp()).ChangePassword(pUserName, user.Version.Value, pOldPassword, pNewPassword);

                ResetPasswordInfo(pUserName, pOldPassword);

                return 0;
            }
            catch (Exception e)
            {
                throw Core.Utils.CreateBeWoFaultException(e);
            }
        }
        public void ResetPasswordInfo(string pUserName, string pPassword)
        {
            try
            {
                var user = DAOFactory.UserDAO.FindUserByLoginName(SessionInformation.Login.Username);

                user.ResetPasswordInfos.ForEach(f => f.HasToChangePW = false);

                DAOFactory.GenericDAO.Update(user);
            }
            catch (Exception e)
            {
                throw Core.Utils.CreateBeWoFaultException(e);
            }

        }

        public BS.SharedLauncher.Enums.UserValidationResult IsUserValid(string pUserName, string pPassword, string pPIN, string clientId, bool checkTenant)
                => UserValidationMapper[(new UserServiceImp()).IsUserValid(pUserName, pPassword, pPIN)];

        public void ResetTenant(string tenant)
                => (new OperationsServiceImp()).ResetTenant(tenant);

        public void ResetAllTenant()
                => (new OperationsServiceImp()).ResetAllTenants();
        
        public bool GetEmailForUserName(string pUserName, Uri serverName, out string email)
                => (new UserServiceImp()).GetEmailForUserName(pUserName, serverName, out email);

        public Dictionary<string, string> GetTranslationDictionary()
            => (new OperationsServiceImp()).GetTranslationDictionary();
    }
}