public async Task <IActionResult> ComparePackages([FromBody] string body)
{
var requestData = body;
try
{
CompareRequest compareRequest = JsonConvert.DeserializeObject <CompareRequest>(body);
foreach (var sourceComparer in compareRequest.SourceComparers)
{
foreach (var package in sourceComparer.Packages)
{
package.SourceA = sourceComparer.SourceA;
package.SourceB = sourceComparer.SourceB;
package.SourceAVersion = await m_nugetService.GetLatestVersionAsync(package.Name, package.SourceA, package.ComparePrerelease);
package.SourceBVersion = await m_nugetService.GetLatestVersionAsync(package.Name, package.SourceB, package.ComparePrerelease);
}
}
var packages = MergePackages(compareRequest.SourceComparers);
var orderedpackages = packages.OrderBy(p => p.SourceAVersion != p.SourceBVersion);
return(Ok(orderedpackages));
}
catch (Exception e)
{
return(NotFound(e));
}
}
public void TestCompareRequestTheory(object value, object assertion, ResultCode compareResult)
{
using (LdapConnection connection = GetConnection())
{
string ouName = "ProtocolsGroup10";
string rdn = "ou=" + ouName;
DeleteEntry(connection, rdn);
AddOrganizationalUnit(connection, rdn);
string dn = rdn + "," + LdapConfiguration.Configuration.SearchDn;
// set description to value
var mod = new ModifyRequest(dn, DirectoryAttributeOperation.Replace, "description", value);
var response = connection.SendRequest(mod);
Assert.Equal(ResultCode.Success, response.ResultCode);
// compare description to assertion
var cmp = new CompareRequest(dn, new DirectoryAttribute("description", assertion));
response = connection.SendRequest(cmp);
// assert compare result
Assert.Equal(compareResult, response.ResultCode);
// compare description to value
cmp = new CompareRequest(dn, new DirectoryAttribute("description", value));
response = connection.SendRequest(cmp);
// compare result always true
Assert.Equal(ResultCode.CompareTrue, response.ResultCode);
}
}
private static Comparer CompareFiles(CompareRequest compareRequest, string resultGuid)
{
string firstPath = compareRequest.guids[0].GetGuid();
string secondPath = compareRequest.guids[1].GetGuid();
// create new comparer
Comparer comparer = new Comparer(firstPath, GetLoadOptions(compareRequest.guids[0].GetPassword()));
comparer.Add(secondPath, GetLoadOptions(compareRequest.guids[1].GetPassword()));
CompareOptions compareOptions = new CompareOptions {
CalculateCoordinates = true
};
if (Path.GetExtension(resultGuid) == ".pdf")
{
compareOptions.DetalisationLevel = DetalisationLevel.High;
}
using (FileStream outputStream = File.Create(Path.Combine(resultGuid)))
{
comparer.Compare(outputStream, compareOptions);
}
return(comparer);
}
public HttpResponseMessage Compare(CompareRequest compareRequest)
{
try
{
// check formats
if (comparisonService.CheckFiles(compareRequest))
{
// compare
CompareResultResponse result = comparisonService.Compare(compareRequest);
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.ContractResolver = new LowercaseContractResolver();
string json = JsonConvert.SerializeObject(result, Formatting.Indented, settings);
var compareResult = JsonConvert.DeserializeObject(json);
return(Request.CreateResponse(HttpStatusCode.OK, compareResult));
}
else
{
return(Request.CreateResponse(HttpStatusCode.OK, new Resources().GenerateException(new Exception("Document types are different"))));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, new Resources().GenerateException(ex)));
}
}
public async Task <IActionResult> Compare([FromBody] CompareRequest request)
{
var input = new CompareInput(request.Text, request.Expression);
await compareUseCase.Execute(input);
return(comparePresenter.Result);
}
public void DistinguishedName_Set_GetReturnsExpected()
{
var request = new CompareRequest {
DistinguishedName = "Name"
};
Assert.Equal("Name", request.DistinguishedName);
}
public void Ctor_Default()
{
var request = new CompareRequest();
Assert.Empty(request.Assertion);
Assert.Empty(request.Controls);
Assert.Null(request.DistinguishedName);
Assert.Null(request.RequestId);
}
public void TestCompareRequest()
{
using (LdapConnection connection = GetConnection())
{
// negative case: ou=NotFound does not exist
var cmp = new CompareRequest("ou=NotFound," + LdapConfiguration.Configuration.SearchDn, "ou", "NotFound");
Assert.Throws <DirectoryOperationException>(() => connection.SendRequest(cmp));
}
}
public static bool validateUser(LdapConnection connection, string username, string password)
{
var request = new CompareRequest(username,
"userPassword",
password
);
var response = (CompareResponse)connection.SendRequest(request);
return(response.ResultCode == ResultCode.CompareTrue);
}
/// <summary>
/// Searches for a user and compares the password.
/// We assume all users are at base DN ou=users,dc=example,dc=com and that passwords are
/// hashed using SHA1 (no salt) in OpenLDAP format.
/// </summary>
/// <param name="username">Username</param>
/// <param name="password">Password</param>
/// <returns>true if the credentials are valid, false otherwise</returns>
public bool validateUser(string username, string password)
{
var sha1 = new SHA1Managed();
var digest = Convert.ToBase64String(sha1.ComputeHash(System.Text.Encoding.UTF8.GetBytes(password)));
var request = new CompareRequest(string.Format("CN={0},CN=Users,DC=dq,DC=com,DC=lb", username),
"sAMAccountName", username); //"{SHA}" + digest
var response = (CompareResponse)connection.SendRequest(request);
return(response.ResultCode == ResultCode.CompareTrue);
}
/// <summary>
/// Searches for a user and compares the password.
/// We assume all users are at base DN ou=users,dc=example,dc=com and that passwords are
/// hashed using SHA1 (no salt) in OpenLDAP format.
/// </summary>
/// <param name="connection">An OPEN connection to LDAP server</param>
/// <param name="username">Username</param>
/// <param name="password">Password</param>
/// <returns>True if the credentials are valid, false otherwise</returns>
public static bool ValidateUser(LdapConnection connection, string username, string password)
{
var sha1 = new SHA1Managed();
var digest = Convert.ToBase64String(sha1.ComputeHash(System.Text.Encoding.UTF8.GetBytes(password)));
var request = new CompareRequest(string.Format("uid={0},ou=users,dc=example,dc=com", username),
"userPassword", "{SHA}" + digest);
var response = (CompareResponse)connection.SendRequest(request);
return(response.ResultCode == ResultCode.CompareTrue);
}
public void Ctor_DistinguishedName_AttributeName_ByteArrayValue(string distinguishedName, string attributeName, byte[] value)
{
var request = new CompareRequest(distinguishedName, attributeName, value);
Assert.Equal(attributeName, request.Assertion.Name);
Assert.Equal(new byte[][] { value }, request.Assertion.GetValues(typeof(byte[])));
Assert.Empty(request.Controls);
Assert.Equal(distinguishedName, request.DistinguishedName);
Assert.Null(request.RequestId);
}
public void Ctor_DistinguishedName_AttributeName_Uri()
{
var uri = new Uri("http://microsoft.com");
var request = new CompareRequest("DistinguishedName", "AttributeName", uri);
Assert.Equal("AttributeName", request.Assertion.Name);
Assert.Equal(uri, Assert.Single(request.Assertion));
Assert.Empty(request.Controls);
Assert.Equal("DistinguishedName", request.DistinguishedName);
Assert.Null(request.RequestId);
}
public void Ctor_DistinguishedName_Assertion()
{
var assertion = new DirectoryAttribute {
"value"
};
var request = new CompareRequest("DistinguishedName", assertion);
Assert.NotSame(assertion, request.Assertion);
Assert.Equal(assertion, request.Assertion);
Assert.Empty(request.Controls);
Assert.Equal("DistinguishedName", request.DistinguishedName);
Assert.Null(request.RequestId);
}
static void Main(string[] args)
{
try
{
var serverLdap = "172.16.10.82";
//var serverLdap = "172.16.10.42";
//var serverLdap = "172.16.10.44:389";
var organization = "garrahan";
var usuarioConexionDN = $"cn=ldap_usr,o={organization}";
var claveConexion = "usuldap";
var usuario = "ldaptester1";
var clave = "12ClaveAB";
//var usuarioDN = $"cn={usuario},ou=UsuariosLDAP,o={organization}";
using (var ldap = new LdapConnection(serverLdap))
{
ldap.AuthType = AuthType.Basic;
ldap.SessionOptions.ProtocolVersion = 3;
ldap.AuthType = AuthType.Basic;
var credential = new System.Net.NetworkCredential(usuarioConexionDN, claveConexion);
ldap.Bind(credential);
BuscarUsuarioEnOU(ldap);
var searcher = new SearchRequest
{
Filter = $"(&(objectClass=user)(uid={usuario}))"
};
var searchResult = (SearchResponse)ldap.SendRequest(searcher);
// Debe haber una unica entrada porque se supone que los usuarios son únicos sin importar en que lugar del arbol se encuentren
if (searchResult.Entries.Count == 1)
{
var usuarioDN = searchResult.Entries[0].DistinguishedName;// "CN=soLopez,OU=DDESARROL,OU=GSISTEMAS,OU=ADM,O=GARRAHAN";//$"cn={usuario},ou=UsuariosLDAP,o={organization}";
var request = new CompareRequest(usuarioDN, "userPassword", clave);
var response = (CompareResponse)ldap.SendRequest(request);
var esClaveValida = response.ResultCode == ResultCode.CompareTrue
? "Valida"
: "Invalida";
Console.WriteLine($"La clave es: {esClaveValida}");
}
else
{
Console.WriteLine($"Usuario no encontrado");
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException?.Message ?? ex.Message);
}
Console.WriteLine("termino");
Console.ReadKey();
}
/// <summary>
///
/// </summary>
/// <param name=""></param>
public OperationResult <CompareReply> Compare(CompareRequest r)
{
OperationResult <CompareReply> res;
try
{
var entityBase = DataContext
.Dashboards
.Find(r.BaseDashboardId);
var entityNew = DataContext
.Dashboards
.Find(r.NewDashboardId);
if (null == entityBase || null == entityNew)
{
return(OperationResult <CompareReply> .Create(ErrorCode.BadGetDashboard));
}
var verEntityBase = DataContext
.DashboardVersions
.FirstOrDefault(x => x.DashboardId == r.BaseDashboardId && x.Version == r.BaseVersion);
var verEntityNew = DataContext
.DashboardVersions
.FirstOrDefault(x => x.DashboardId == r.NewDashboardId && x.Version == r.NewVersion);
if (null == verEntityBase || null == verEntityNew)
{
return(OperationResult <CompareReply> .Create(ErrorCode.BadGetDashboardVersion));
}
var jdp = new JsonDiffPatch();
var diff = jdp.Diff(verEntityBase.Data, verEntityNew.Data);
var reply = new CompareReply()
{
Base = verEntityBase.Data,
New = verEntityNew.Data,
Diff = diff
};
res = OperationResult <CompareReply> .Create(reply);
}
catch (Exception e)
{
res = OperationResult <CompareReply> .Create(ErrorCode.BadDashboardRestore, e);
}
return(res);
}
public bool CheckFiles(CompareRequest files)
{
string extension = Path.GetExtension(files.guids[0].GetGuid());
// check if files extensions are the same and support format file
if (!CheckSupportedFiles(extension))
{
return(false);
}
foreach (CompareFileDataRequest path in files.guids)
{
if (!extension.Equals(Path.GetExtension(path.GetGuid())))
{
return(false);
}
}
return(true);
}
private CompareResultResponse CompareTwoDocuments(CompareRequest compareRequest)
{
// to get correct coordinates we will compare document twice
// this is a first comparing to get correct coordinates of the insertions and style changes
string extension = Path.GetExtension(compareRequest.guids[0].GetGuid());
string guid = Guid.NewGuid().ToString();
//save all results in file
string resultGuid = Path.Combine(globalConfiguration.Comparison.GetResultDirectory(), guid + extension);
Comparer compareResult = CompareFiles(compareRequest, resultGuid);
ChangeInfo[] changes = compareResult.GetChanges();
CompareResultResponse compareResultResponse = GetCompareResultResponse(changes, resultGuid);
compareResultResponse.SetExtension(extension);
return(compareResultResponse);
}
static void Compare()
{
string attributeName = "description";
string valueToCompareAgainst = "This is a sample OU";
// create a request to do compare on the object
CompareRequest compareRequest = new CompareRequest(
ou1,
attributeName,
valueToCompareAgainst
);
// send the request through the connection
CompareResponse compareResponse =
(CompareResponse)dsmlConnection.SendRequest(compareRequest);
Console.WriteLine("The result of the comparison is:" +
compareResponse.ResultCode);
}
public async Task <ActionResult> CompareImages(string userid, CompareRequest request)
{
IFaceClient client = Authenticate(ENDPOINT, SUBSCRIPTION_KEY);
var response = new UploadResponse()
{
UserId = userid.ToString()
};
IList <Guid?> targetFaceIds = new List <Guid?>();
targetFaceIds.Add(Guid.Parse(request.ComparasionFaceId));
var result = await FindSimilar(client, Guid.Parse(request.BaseFaceId), targetFaceIds);
var json = JsonConvert.SerializeObject(result.FirstOrDefault());
response.Response = json;
return(Ok(response));
}
public HttpResponseMessage CompareString([FromBody] CompareRequest request)
{
try
{
Log.Info("initialiing compare");
var httpResponseMessage = new HttpResponseMessage()
{
Content = new ObjectContent <int[]>(StringCompare.Compare(request.SourceString, request.SubString).ToArray(),
Configuration.Formatters.JsonFormatter),
StatusCode = HttpStatusCode.OK,
};
return(httpResponseMessage);
}
catch (Exception ex)
{
var errorMessage = Helper.HttpResponseErrorMessage(ex.Message, _correlationId);
Log.Error(string.Format("{0} - {1}", _correlationId, "Exception occurred: Unable to determine traingle type"), ex);
throw new HttpResponseException(
Request.CreateErrorResponse(HttpStatusCode.InternalServerError, errorMessage));
}
}
//var username = $"cn=ldap_usr,o={organization}";
//var password = "******";
//var username = $"cn=solopez,ou=DDESARROL,ou=GSISTEMAS,ou=ADM,o={organization}";
//var password = "******";
//var usuario = "lestrada";
//var usuario = "solopez";
//var clave = "1qaz2WSfX";
//var username = $"cn=ldap_portal,ou=DDESARROL,ou=GSISTEMAS,ou=ADM,o={organization}";
//var claveConexion = "G4rr4h4n19";
/*
* Console.WriteLine($"Usuario {usuarioConexion} valida clave {validateUser(ldap, usuarioConexion, claveConexion)}");
* Console.WriteLine($"Usuario {usuario} valida clave {validateUser(ldap, $"cn={usuario},ou=UsuariosLDAP,o={organization}", clave)}");
*
* var searcher = new System.DirectoryServices.DirectorySearcher();
* searcher.Filter = String.Format("sAMAccountName={0}", usuario);
* searcher.SearchScope = System.DirectoryServices.SearchScope.Subtree;
* searcher.CacheResults = false;
*
* var searchResult = searcher.FindOne();
* if (searchResult == null)
* {
* Console.WriteLine($"Usuario {usuario} no encontrado");
* }
*
* var userEntry = searchResult.GetDirectoryEntry();
* Console.WriteLine($"Usuario encontrado: {usuario} - {userEntry.Properties["givenName"].Value}");
* Console.WriteLine($"clave {userEntry.Properties["userPassword"].Value}");
* Console.WriteLine("The Child ADS objects are:");
* foreach (System.DirectoryServices.DirectoryEntry myChildDirectoryEntry in userEntry.Children)
* Console.WriteLine(myChildDirectoryEntry.Path);
*
* Console.WriteLine("Prueba cambio de clave");
*
* userEntry.Properties["givenName"].Value = "hola";// $"\"{clave}2\"";
* userEntry.CommitChanges();
*/
/*
* LdapAttribute attributePassword = new LdapAttribute("userPassword",
* newPassword);
* lc.Modify(modifyDN, new LdapModification(
* LdapModification.REPLACE, attributePassword));
*/
/*
* var resultValueC = userEntry.Invoke("ChangePassword", new object[] { "1234Clave1", $"\"{clave}2\"" });
* userEntry.CommitChanges();
* Console.WriteLine($"cambio clave - resultValue: {resultValueC}");
*/
/*
* var resultValue = userEntry.Invoke("SetPassword", new object[] { clave });
* userEntry.Properties["LockOutTime"].Value = 0;
* userEntry.Close();
* userEntry.CommitChanges();
* Console.WriteLine($"set clave - resultValue: {resultValue}");
*/
/*
* //string newPassword = Membership.GeneratePassword(12, 4);
* string quotePwd = String.Format(@"""{0}""", clave);
* byte[] pwdBin = System.Text.Encoding.Unicode.GetBytes(quotePwd);
* userEntry.Properties["unicodePwd"].Value = pwdBin;
* userEntry.CommitChanges();
* Console.WriteLine($"set unicodePwd");
*/
static void _Main(string[] args)
{
try
{
var serverLdap = "172.16.10.82";
//var serverLdap = "172.16.10.42";
//var serverLdap = "172.16.10.44:389";
var organization = "garrahan";
var usuarioConexionDN = $"cn=ldap_usr,o={organization}";
var claveConexion = "usuldap";
var usuario = "ldaptester1";
var clave = "12ClaveAB";
var usuarioDN = $"cn={usuario},ou=UsuariosLDAP,o={organization}";
using (var ldap = new LdapConnection(serverLdap))
{
ldap.AuthType = AuthType.Basic;
ldap.SessionOptions.ProtocolVersion = 3;
ldap.AuthType = AuthType.Basic;
var credential = new System.Net.NetworkCredential(usuarioConexionDN, claveConexion);
ldap.Bind(credential);
var request = new CompareRequest(usuarioDN, "userPassword", clave);
var response = (CompareResponse)ldap.SendRequest(request);
var esClaveValida = response.ResultCode == ResultCode.CompareTrue
? "Valida"
: "Invalida";
Console.WriteLine($"La clave es: {esClaveValida}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.InnerException?.Message ?? ex.Message);
}
Console.WriteLine("termino");
Console.ReadKey();
}
/// <summary>
/// Creates a CompareRequest packet.
/// </summary>
/// <param name="context">The user context which contains message ID.</param>
/// <param name="objectDn">The DN of the object to be compared.</param>
/// <param name="attributeName">The name of the attribute.</param>
/// <param name="attributeValue">The value of the attribute.</param>
/// <returns>The packet that contains the request.</returns>
internal override AdtsCompareRequestPacket CreateCompareRequest(
AdtsLdapContext context,
string objectDn,
string attributeName,
string attributeValue)
{
CompareRequest compareRequest = new CompareRequest(
new LDAPDN(objectDn ?? string.Empty),
new AttributeValueAssertion(
new AttributeType(attributeName ?? string.Empty),
new AttributeValue(attributeValue ?? string.Empty)));
LDAPMessage_protocolOp operation = new LDAPMessage_protocolOp();
operation.SetData(LDAPMessage_protocolOp.compareDNRequest, compareRequest);
LDAPMessage message = new LDAPMessage(new MessageID(context.MessageId), operation);
AdtsCompareRequestPacket packet = new AdtsCompareRequestPacket();
packet.ldapMessagev2 = message;
packet.messageId = context.MessageId;
return(packet);
}
/// <summary>
/// Creates a CompareRequest packet.
/// </summary>
/// <param name="context">The user context which contains message ID.</param>
/// <param name="objectDn">The DN of the object to be compared.</param>
/// <param name="attributeName">The name of the attribute.</param>
/// <param name="attributeValue">The value of the attribute.</param>
/// <returns>The packet that contains the request.</returns>
internal override AdtsCompareRequestPacket CreateCompareRequest(
AdtsLdapContext context,
string objectDn,
string attributeName,
string attributeValue)
{
CompareRequest compareRequest = new CompareRequest(
new LDAPDN(objectDn ?? string.Empty),
new AttributeValueAssertion(
new AttributeDescription(attributeName ?? string.Empty),
new AssertionValue(attributeValue ?? string.Empty)));
LDAPMessage_protocolOp operation = new LDAPMessage_protocolOp();
operation.SetData(LDAPMessage_protocolOp.extendedReq, compareRequest);
LDAPMessage message = new LDAPMessage(new MessageID(context.MessageId), operation, null);
AdtsCompareRequestPacket packet = new AdtsCompareRequestPacket();
packet.ldapMessagev3 = message;
packet.messageId = context.MessageId;
return packet;
}
public CreateCompareParameter(CompareRequest request)
{
Request = request;
}
static void SendBatchRequest()
{
DsmlRequestDocument batchRequest = new DsmlRequestDocument();
AddRequest addRequest;
ModifyRequest modifyRequest;
CompareRequest compareRequest;
DeleteRequest deleteRequest;
// create new OUs under the specified OU
ou1 = "OU=sampleOU1," + targetOU;
ou2 = "OU=sampleOU2," + targetOU;
ou3 = "OU=sampleOU3," + targetOU;
string objectClass = "organizationalUnit";
// add multiple requests (make sure )
addRequest = new AddRequest(ou1, objectClass);
addRequest.RequestId = "Add1";
batchRequest.Add(addRequest);
addRequest = new AddRequest(ou2, objectClass);
addRequest.RequestId = "Add2";
batchRequest.Add(addRequest);
addRequest = new AddRequest(ou3, objectClass);
addRequest.RequestId = "Add3";
batchRequest.Add(addRequest);
compareRequest = new CompareRequest(ou1, "distinguishedName", ou1);
compareRequest.RequestId = "Compare1";
batchRequest.Add(compareRequest);
deleteRequest = new DeleteRequest(ou1);
deleteRequest.RequestId = "Delete1";
batchRequest.Add(deleteRequest);
compareRequest = new CompareRequest(ou2, "distinguishedName", ou2);
compareRequest.RequestId = "Compare2";
batchRequest.Add(compareRequest);
modifyRequest = new ModifyRequest(ou2,
DirectoryAttributeOperation.Replace,
"description",
"Testing BatchRequest");
modifyRequest.RequestId = "Modify1";
batchRequest.Add(modifyRequest);
deleteRequest = new DeleteRequest(ou2);
deleteRequest.RequestId = "Delete2";
batchRequest.Add(deleteRequest);
deleteRequest = new DeleteRequest(ou3);
deleteRequest.RequestId = "Delete3";
batchRequest.Add(deleteRequest);
DsmlResponseDocument batchResponse =
dsmlConnection.SendRequest(batchRequest);
foreach (DirectoryResponse response in batchResponse)
{
Console.WriteLine(response.GetType().Name + ": \tId=" +
response.RequestId + ",\tResultCode=" +
response.ResultCode);
}
Console.WriteLine("Batch request has been processed successfully.");
}
public static DERProtocolOperation Extract(ICollection <byte> buffer)
{
var result = new DERProtocolOperation();
result.ExtractTagAndLength(buffer);
switch (result.Tag.LdapCommand)
{
case LdapCommands.SearchRequest:
result.Operation = SearchRequest.Extract(buffer);
break;
case LdapCommands.BindRequest:
result.Operation = BindRequest.Extract(buffer);
break;
case LdapCommands.UnbindRequest:
result.Operation = UnbindRequest.Extract(buffer);
break;
case LdapCommands.AddRequest:
result.Operation = AddRequest.Extract(buffer);
break;
case LdapCommands.DelRequest:
result.Operation = DelRequest.Extract(buffer, result.Length);
break;
case LdapCommands.ModifyDNRequest:
result.Operation = ModifyDNRequest.Extract(buffer);
break;
case LdapCommands.CompareRequest:
result.Operation = CompareRequest.Extract(buffer);
break;
case LdapCommands.AbandonRequest:
result.Operation = AbandonRequest.Extract(buffer);
break;
case LdapCommands.ModifyRequest:
result.Operation = ModifyRequest.Extract(buffer);
break;
case LdapCommands.SearchResultDone:
result.Operation = SearchResultDone.Extract(buffer);
break;
case LdapCommands.BindResponse:
result.Operation = BindResponse.Extract(buffer);
break;
case LdapCommands.AddResponse:
result.Operation = AddResponse.Extract(buffer);
break;
case LdapCommands.SearchResultEntry:
result.Operation = SearchResultEntry.Extract(buffer);
break;
}
return(result);
}
public IActionResult Compare(CompareRequest r) => Repo .Compare(r.ToModel()) .ToActionResult(x => ToCompareReply(x));
public CompareResultResponse Compare(CompareRequest compareRequest)
{
CompareResultResponse compareResultResponse = CompareTwoDocuments(compareRequest);
return(compareResultResponse);
}
