SettingsFactoryBase
using kCura.WinEDDS.Service;
using kCura.WinEDDS.Service.Replacement;
using Microsoft.VisualBasic.CompilerServices;
using Relativity.DataExchange;
using System;
using System.Net;
using System.Net.Security;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Security.Cryptography.X509Certificates;
namespace kCura.WinEDDS
{
public abstract class SettingsFactoryBase
{
public enum OverwriteType
{
Append,
Overlay,
AppendOverlay
}
[Serializable]
public class InvalidCredentialsException : Exception
{
public InvalidCredentialsException()
{
}
public InvalidCredentialsException(string message)
: base(message)
{
}
public InvalidCredentialsException(string message, Exception innerException)
: base(message, innerException)
{
}
protected InvalidCredentialsException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
}
[Serializable]
[CompilerGenerated]
internal sealed class _Closure$__
{
public static readonly _Closure$__ $I;
public static RemoteCertificateValidationCallback $I25-0;
static _Closure$__()
{
$I = new _Closure$__();
}
internal bool _Lambda$__25-0(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return true;
}
}
private NetworkCredential _credential;
private CookieContainer ;
private ICaseManager _caseManager;
private IFolderManager _folderManager;
private IFieldManager _fieldManager;
private IFieldQuery _fieldQuery;
private IProductionManager _productionManager;
private Func<string> _correlationIdFunc;
protected NetworkCredential Credential => _credential;
protected CookieContainer CookieContainer => _cookieContainer;
protected ICaseManager CaseManager {
get {
if (_caseManager == null)
_caseManager = ManagerFactory.CreateCaseManager(_credential, _cookieContainer, _correlationIdFunc);
return _caseManager;
}
}
protected IFolderManager FolderManager {
get {
if (_folderManager == null)
_folderManager = ManagerFactory.CreateFolderManager(_credential, _cookieContainer, _correlationIdFunc);
return _folderManager;
}
}
protected IFieldManager FieldManager {
get {
if (_fieldManager == null)
_fieldManager = ManagerFactory.CreateFieldManager(_credential, _cookieContainer, _correlationIdFunc);
return _fieldManager;
}
}
protected IFieldQuery FieldQuery {
get {
if (_fieldQuery == null)
_fieldQuery = ManagerFactory.CreateFieldQuery(_credential, _cookieContainer, _correlationIdFunc);
return _fieldQuery;
}
}
protected IProductionManager ProductionManager {
get {
if (_productionManager == null)
_productionManager = ManagerFactory.CreateProductionManager(_credential, _cookieContainer, _correlationIdFunc);
return _productionManager;
}
}
protected SettingsFactoryBase(string login, string password, Func<string> correlationIdFunc)
: this(new NetworkCredential(login, password), correlationIdFunc)
{
}
protected SettingsFactoryBase(NetworkCredential credential, Func<string> correlationIdFunc)
: this(credential, new CookieContainer(), correlationIdFunc)
{
}
protected SettingsFactoryBase(NetworkCredential credential, CookieContainer cookieContainer, Func<string> correlationIdFunc)
{
_credential = credential;
_correlationIdFunc = correlationIdFunc;
if (AppSettings.Instance.SuppressServerCertificateValidation)
ServicePointManager.ServerCertificateValidationCallback = ((_Closure$__.$I25-0 != null) ? _Closure$__.$I25-0 : (_Closure$__.$I25-0 = ((object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) => true)));
ServicePointManager.SecurityProtocol = (SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12);
_cookieContainer = cookieContainer;
IRelativityManager relativityManager = ManagerFactory.CreateRelativityManager(_credential, _cookieContainer, _correlationIdFunc, null);
bool flag;
try {
flag = relativityManager.ValidateSuccessfulLogin();
} catch (Exception ex) {
ProjectData.SetProjectError(ex);
Exception ex2 = ex;
flag = false;
ProjectData.ClearProjectError();
}
if (!flag) {
if (Operators.CompareString(_credential.Password, "", false) != 0) {
IUserManager userManager = ManagerFactory.CreateUserManager(_credential, _cookieContainer, _correlationIdFunc);
if (userManager.Login(_credential.UserName, _credential.Password)) {
Settings.AuthenticationToken = userManager.GenerateDistributedAuthenticationToken(true);
return;
}
}
throw new InvalidCredentialsException();
}
}
protected void SaveObject(string location, object settings)
{
try {
SerializationHelper.SerializeToSoapFile(RuntimeHelpers.GetObjectValue(settings), location);
} catch (Exception ex) {
ProjectData.SetProjectError(ex);
Exception innerException = ex;
throw new Exception("Settings object save failed", innerException);
}
}
public abstract void Save(string location);
}
}