public void SendRequestTest()
{
var fakePackage = new Package();
ModSicProxy.SendRequest(fakePackage, FAKE_TOKEN);
FakeCollectService
.AssertWasCalled<ICollectService>(
modSIC => modSIC.SendRequest(fakePackage, FAKE_TOKEN));
}
public CollectRequestValidator(Package collectPackage)
{
this.VerifyIfCollectPackageIsNull(collectPackage);
this.VerifyIfCollectRequestParameterIsNull(collectPackage.CollectRequests);
this.VerifyIfExistsANullRequesCollectItemInCollection(collectPackage.CollectRequests);
this.VerifyIfRequestIdsIsNotNull(collectPackage.CollectRequests);
this.VerifyIfExistsDuplicatedRequestIDs(collectPackage.CollectRequests);
this.RequestedDefinitions = collectPackage.Definitions;
}
public CollectPackage CreateCollectPackageFromDTO(IDocumentSession session, Package collectPackageDTO)
{
CollectPackage collectPackage = new CollectPackage();
collectPackage.Date = collectPackageDTO.Date;
collectPackage.ScheduleInformation = new CollectScheduleInformation() { ExecutionDate = collectPackageDTO.ScheduleInformation.ScheduleDate };
session.Store(collectPackage);
session.SaveChanges();
return collectPackage;
}
private void VerifyIfCollectPackageIsNull(Package collectPackage)
{
if (collectPackage == null)
throw new ArgumentNullException("The CollectPackage parameter of CollectRequest method cannot be null.");
}
public virtual SendRequestResult SendRequest(Package collectPackage, string token)
{
return this.ModSicChannel.SendRequest(collectPackage, token);
}
private Package CreatePackage(string ovalDefinitions, Request newRequest)
{
var package = new Package()
{
CollectRequests = new Request[] { newRequest },
Date = DateTime.UtcNow,
Definitions = new DefinitionInfo[] { new DefinitionInfo() { Id = newRequest.DefinitionId, Text = ovalDefinitions } },
ScheduleInformation = new ScheduleInformation() { ScheduleDate = DateTime.UtcNow }
};
return package;
}
/// <summary>
/// It requests a new collection to modSIC Server.
/// </summary>
/// <param name="fakePackage">
/// <see cref="http://modsic.codeplex.com/wikipage?title=Contract&referringTitle=Documentation#package"/>
/// </param>
/// <returns><see cref="http://modsic.codeplex.com/wikipage?title=Contract&referringTitle=Documentation#sendRequestResult"/></returns>
public virtual SendRequestResult SendCollect(Package fakePackage)
{
var token = LogonModSic();
try
{
return ModSicProxyService.SendRequest(fakePackage, token);
}
finally
{
ModSicProxyService.Logout(token);
}
}
public SendRequestResult SendRequest(Package collectPackage, string token)
{
var result = new SendRequestResult();
try
{
string clientId;
if (!CollectController.Authenticate(token, out clientId))
{
throw new FaultException(INVALID_AUTHORIZATION_TOKEN);
}
var requestIds = CollectController.CollectRequest(collectPackage, clientId);
result.Requests =
requestIds
.Select(x => new RequestInfo() { ClientRequestId = x.Key, ServiceRequestId = x.Value }).ToArray();
}
catch (Exception ex)
{
var logMessage = String.Format(EXECUTION_ERROR_MESSAGE, ex.Message, ex.StackTrace);
Logger.Error(logMessage);
result.HasErrors = true;
result.Message = ex.Message;
}
return result;
}
/// <summary>
/// Schedules the execution using schedule information from CollectPackage.
/// </summary>
/// <param name="collectPackage">The collect package.</param>
private void ScheduleExecution(Dictionary<string, string> ids, Package collectPackage)
{
foreach (var collectRequest in collectPackage.CollectRequests)
{
var collectRequestId = ids[collectRequest.RequestId];
var collectionDueTo = collectPackage.ScheduleInformation.ScheduleDate;
ScheduleController.ScheduleCollection(collectRequestId, collectRequest.Address, collectionDueTo);
Wait();
}
}
private Dictionary<string, string> SaveTheCollectRequest(IDocumentSession session, Package collectPackageDTO, string clientId)
{
try
{
var collectPackage = PackageAssembler.CreateCollectPackageFromDTO(session, collectPackageDTO);
var identifiers = this.SaveListOfCollectRequest(session, collectPackage, collectPackageDTO.CollectRequests, collectPackageDTO.Definitions, clientId);
return identifiers;
}
catch (Exception ex)
{
throw new Exception(string.Format("An error ocurred when saving the Collect: {0}", ex.Message), ex);
}
}
private void ValidatePackage(Package collectPackage)
{
var validateSchematron = ModsicConfigurationHelper.IsSchematronValidationSet();
var collectRequestValidator = new CollectRequestValidator(collectPackage);
collectRequestValidator.ValidateOvalDefinitions(validateSchematron);
}
/// <summary>
/// Requests the service to execute the collect and return the data of requested collect.
/// The format of data is: [RequestID], [CollectID], where:
/// - RequestId - Identifier the origin of collect
/// - CollectId - Identifier of collect requested
/// </summary>
/// <param name="collectRequest">The collect request.</param>
/// <returns></returns>
public Dictionary<string, string> CollectRequest(Package collectPackage, string clientId)
{
using (var session = Repository.GetSession())
{
ValidatePackage(collectPackage);
var result = SaveTheCollectRequest(session, collectPackage, clientId);
ScheduleExecution(result, collectPackage);
return result;
}
}
private Package CreatePackage(Request request, DefinitionInfo definitionInfo, DateTime? fakeDate = null)
{
var date = fakeDate ?? DateTime.Now;
var fakePackage = new Package()
{
Date = date,
Definitions = new DefinitionInfo[] { definitionInfo },
CollectRequests = new Request[] { request },
ScheduleInformation = new ScheduleInformation() { ScheduleDate = date }
};
return fakePackage;
}
public static Package CreateCollectPackageDTO()
{
Package collectPackage = new Package();
collectPackage.ScheduleInformation = new ScheduleInformation() { ScheduleDate = DateTime.Now };
return collectPackage;
}
