/// <summary>
/// The date rule parser.
/// </summary>
/// <param name="cache"></param>
/// <param name="calendars"></param>
/// <param name="nameSpace"></param>
/// <returns></returns>
public static IDateRuleParser GetDateRuleParser(ICoreCache cache, string[] calendars, string nameSpace)
{
if (calendars != null)
{
var path = nameSpace + "." + BusinessCentreDateRulesProp.GenericName;
var loadedObject = cache.LoadObject <DateRules>(path);
var dps = new DateRuleParser(calendars, loadedObject.DateRuleProfile);
return(dps);
}
return(null);
}
/// <summary>
/// Tries to get the algorithm.
/// </summary>
/// <param name="nameSpace"></param>
/// <param name="pricingStructureType"></param>
/// <param name="algorithmName"></param>
/// <param name="logger"></param>
/// <param name="cache">The value</param>
/// <returns>Whether the property existed or not</returns>
public Algorithm GetAlgorithm(ILogger logger, ICoreCache cache, String nameSpace, PricingStructureTypeEnum pricingStructureType, string algorithmName)
{
Algorithm algorithm = null;
if (cache != null)
{
try
{
algorithm = cache.LoadObject <Algorithm>(nameSpace + "." + AlgorithmsProp.GenericName + "." + pricingStructureType + "." + algorithmName);
}
catch (Exception ex)
{
logger.Log(ex);
}
}
return(algorithm);
}
private static void HandleSpecificRequest <R, W>(ILogger logger, ICoreCache cache, string requestItemName)
where R : RequestBase
where W : WorkstepBase <RequestBase, HandlerResponse>, IRequestHandler <RequestBase, HandlerResponse>, new()
{
R request = cache.LoadObject <R>(requestItemName);
if (request == null)
{
throw new ApplicationException(String.Format("Request not found (type={0},name='{1}')", typeof(R).Name, requestItemName));
}
// publish 'initial' status
HandlerResponse response = new HandlerResponse()
{
RequestId = request.RequestId,
RequesterId = request.RequesterId,
Status = RequestStatusEnum.Commencing,
CommenceTime = DateTimeOffset.Now.ToString("o")
};
cache.SaveObject <HandlerResponse>(response);
try
{
using (IRequestHandler <RequestBase, HandlerResponse> handler = new W() as IRequestHandler <RequestBase, HandlerResponse>)
{
handler.InitialiseRequest(logger, cache);
handler.ProcessRequest(request, response);
}
}
catch (OperationCanceledException cancelExcp)
{
response.Status = RequestStatusEnum.Cancelled;
response.CancelReason = cancelExcp.Message;
}
catch (Exception outerExcp)
{
response.Status = RequestStatusEnum.Faulted;
response.FaultDetail = new ExceptionDetail(outerExcp);
logger.Log(outerExcp);
}
// publish 'completed' status
cache.SaveObject <HandlerResponse>(response);
}
/// <summary>
/// Significant date.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="businessCenters">The city names.</param>
/// <param name="nameSpace">The clients namespace</param>
/// <returns></returns>
private static List <SignificantDay> GetBusinessCentreHolidayDates(ICoreCache cache, IEnumerable <string> businessCenters, string nameSpace)
{
var dateList = new List <SignificantDay>();
//The new filter with OR on arrays..
var path = nameSpace + "." + BusinessCenterCalendarProp.GenericName;
foreach (var centre in businessCenters)
{
var identifier = path + '.' + centre;
var loadedObject = cache.LoadObject <BusinessCenterCalendar>(identifier);
if (loadedObject?.Holidays != null)
{
var dates = loadedObject.Holidays.Select(dr => (DateTime)dr.Item);
// Get the dates as one list
var significantDates
= dates.Select(dr => new SignificantDay {
Date = dr, ObservedSignificantDayDate = dr, Name = centre
});
dateList.AddRange(significantDates);
}
}
return(dateList);
}
public static int HandleRequest(ILogger logger, ICoreCache cache, Guid requestId, string hostInstance)
{
int result = 0;
if (requestId == Guid.Empty)
{
throw new ArgumentNullException("requestId");
}
string requestItemName = (new AssignedWorkflowRequest()
{
RequestId = requestId.ToString(),
WorkerHostComputer = Environment.MachineName,
WorkerHostInstance = hostInstance
}).NetworkKey;
AssignedWorkflowRequest request = cache.LoadObject <AssignedWorkflowRequest>(requestItemName);
if (request == null)
{
throw new ArgumentException("Cannot find request name: ", requestItemName);
}
logger.LogDebug("---------- request header details");
logger.LogDebug("Id : {0}", requestId);
logger.LogDebug("Computer : {0}", request.WorkerHostComputer);
logger.LogDebug("Instance : {0}", request.WorkerHostInstance);
logger.LogDebug("Data Type: {0}", request.RequestDataType);
logger.LogDebug("Item Name: {0}", request.RequestItemName);
logger.LogDebug("---------- request handler executing");
try
{
if (request.RequestDataType.Equals(typeof(TradeValuationRequest).FullName))
{
HandleSpecificRequest <TradeValuationRequest, WFCalculateTradeValuation>(logger, cache, request.RequestItemName);
}
else if (request.RequestDataType.Equals(typeof(PortfolioValuationRequest).FullName))
{
HandleSpecificRequest <PortfolioValuationRequest, WFCalculatePortfolioValuation>(logger, cache, request.RequestItemName);
}
else if (request.RequestDataType.Equals(typeof(OrdinaryCurveGenRequest).FullName))
{
HandleSpecificRequest <OrdinaryCurveGenRequest, WFGenerateOrdinaryCurve>(logger, cache, request.RequestItemName);
}
else if (request.RequestDataType.Equals(typeof(StressedCurveGenRequest).FullName))
{
HandleSpecificRequest <StressedCurveGenRequest, WFGenerateStressedCurve>(logger, cache, request.RequestItemName);
}
// diagnostic
else if (request.RequestDataType.Equals(typeof(PingHandlerRequest).FullName))
{
HandleSpecificRequest <PingHandlerRequest, WFCalculatePingHandler>(logger, cache, request.RequestItemName);
}
else
{
throw new NotSupportedException(String.Format("Unsupported RequestDataType: '{0}'", request.RequestDataType));
}
// success
result = 1;
logger.LogDebug("---------- request handler completed");
}
catch (Exception outerExcp)
{
logger.LogDebug("---------- request handler failed");
logger.Log(outerExcp);
}
return(result);
}
