private static double GetValue(ValueRequirement req)
{
if (req.TargetSpecification.Type != ComputationTargetType.Primitive)
{
throw new NotImplementedException();
}
using (var remoteClient = Context.CreateFinancialClient())
{
var viewDefinition = new ViewDefinition(TestUtils.GetUniqueName());
var viewCalculationConfiguration = new ViewCalculationConfiguration("Default", new List <ValueRequirement> {
req
}, new Dictionary <string, HashSet <Tuple <string, ValueProperties> > >());
viewDefinition.CalculationConfigurationsByName.Add("Default", viewCalculationConfiguration);
var uid = remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(viewDefinition));
viewDefinition.UniqueID = uid;
try
{
using (var viewClient = Context.ViewProcessor.CreateClient())
{
var viewComputationResultModel = viewClient.GetResults(viewDefinition.UniqueID, ExecutionOptions.SingleCycle).First();
return((double)viewComputationResultModel["Default", req].Value);
}
}
finally
{
remoteClient.ViewDefinitionRepository.RemoveViewDefinition(viewDefinition.Name);
}
}
}
public static ViewDefinition FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
var name = ffc.GetValue <string>("name");
var uniqueIdString = ffc.GetString("uniqueId");
var uniqueId = uniqueIdString == null ? null : UniqueId.Parse(uniqueIdString);
var resultModelDefinition = deserializer.FromField <ResultModelDefinition>(ffc.GetByName("resultModelDefinition"));
UniqueId portfolioIdentifier = ValueRequirement.GetUniqueIdentifier(ffc, deserializer, "identifier");
var user = deserializer.FromField <UserPrincipal>(ffc.GetByName("user"));
var currency = ffc.GetValue <Currency>("currency");
var minDeltaCalcPeriod = ReadNullableTimeSpanField(ffc, "minDeltaCalcPeriod");
var maxDeltaCalcPeriod = ReadNullableTimeSpanField(ffc, "maxDeltaCalcPeriod");
var minFullCalcPeriod = ReadNullableTimeSpanField(ffc, "fullDeltaCalcPeriod");
var maxFullCalcPeriod = ReadNullableTimeSpanField(ffc, "maxFullCalcPeriod");
var calculationConfigurationsByName = ffc.GetAllByName("calculationConfiguration")
.Select(deserializer.FromField <ViewCalculationConfiguration>)
.ToDictionary(vcc => vcc.Name);
return(new ViewDefinition(name, resultModelDefinition, portfolioIdentifier, user, currency, minDeltaCalcPeriod, maxDeltaCalcPeriod, minFullCalcPeriod, maxFullCalcPeriod, calculationConfigurationsByName, uniqueId));
}
public void ValueChangesResults()
{
var valueRequirement = new ValueRequirement("Market_Value", new ComputationTargetSpecification(ComputationTargetType.Primitive, BloombergUid));
var defn = GetViewDefinition();
using (var remoteClient = Context.ViewProcessor.CreateClient())
{
var liveDataOverrideInjector = remoteClient.LiveDataOverrideInjector;
const double newValue = 1234.5678;
ManualResetEvent mre = new ManualResetEvent(false);
IViewComputationResultModel results = null;
var listener = new EventViewResultListener();
listener.CycleCompleted += delegate(object sender, CycleCompletedArgs e)
{
results = e.FullResult;
mre.Set();
};
remoteClient.SetResultListener(listener);
remoteClient.AttachToViewProcess(defn.UniqueID, ExecutionOptions.RealTime);
liveDataOverrideInjector.AddValue(valueRequirement, newValue);
mre.WaitOne();
var result = results.AllResults.Where(
r => valueRequirement.IsSatisfiedBy(r.ComputedValue.Specification)).First();
Assert.Equal(newValue, (double)result.ComputedValue.Value);
}
}
public void RemoveValue(ValueRequirement valueRequirement)
{
ArgumentChecker.NotNull(valueRequirement, "valueRequirement");
RemoveValue(new RemoveValueRequest {
ValueRequirement = valueRequirement
});
}
public void AddValue(ValueRequirement valueRequirement, object value)
{
ArgumentChecker.NotNull(valueRequirement, "valueRequirement");
var addValueRequest = new AddValueRequest {
Value = value, ValueRequirement = valueRequirement
};
AddValue(addValueRequest);
}
private static ViewDefinition GetViewDefinition(ValueRequirement req, string name)
{
var viewDefinition = new ViewDefinition(name);
var viewCalculationConfiguration = new ViewCalculationConfiguration("Default", new List <ValueRequirement> {
req
}, new Dictionary <string, HashSet <Tuple <string, ValueProperties> > >());
viewDefinition.CalculationConfigurationsByName.Add("Default", viewCalculationConfiguration);
return(viewDefinition);
}
public ComputedValue this[string calculationConfiguration, ValueRequirement valueRequirement]
{
get
{
ComputedValue ret;
if (!TryGetComputedValue(calculationConfiguration, valueRequirement, out ret))
{
throw new KeyNotFoundException();
}
return(ret);
}
}
protected int CheckInputData(ValueRequirement requirement, string stringValue, string inputMessage)
{
if (int.TryParse(stringValue, out int inputValue) && requirement(inputValue))
{
return(inputValue);
}
else
{
PrintMessage("Неверный ввод, повторите попытку:");
return(GetInputData(requirement, inputMessage));
}
}
private static T Get <T>(ValueRequirement valueRequirement, IViewComputationResultModel results)
{
ComputedValue value;
if (results.TryGetComputedValue("Default", valueRequirement, out value))
{
return((T)value.Value);
}
else
{
return(default(T));
}
}
public ViewDefinition CreateViewDefinition(RemoteEngineContext context, ValueRequirement valueRequirement)
{
var viewDefinition = new ViewDefinition(TestUtils.GetUniqueName());
viewDefinition.CalculationConfigurationsByName.Add("Default", new ViewCalculationConfiguration("Default", new List <ValueRequirement> {
valueRequirement
}, new Dictionary <string, HashSet <Tuple <string, ValueProperties> > >()));
using (var remoteClient = context.CreateFinancialClient())
{
var uid = remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(viewDefinition));
viewDefinition.UniqueID = uid;
}
_createdViews.Enqueue(Tuple.Create(context, viewDefinition.Name));
return(viewDefinition);
}
//PLAT-1108 [InlineData("Colons:")]
//PLAT-1108 [InlineData("Equals=")]
//PLAT-1108 [InlineData("Evil\\/.?#^5%")]
public void CanAddAndRemovePrimitiveView(string hardUriPart)
{
ValueRequirement req = GetRequirement();
using (var remoteClient = Context.CreateFinancialClient())
{
ViewDefinition vd = GetViewDefinition(req, TestUtils.GetUniqueName() + hardUriPart);
Assert.Null(vd.UniqueID);
remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(vd));
var roundTripped = Context.ViewProcessor.ViewDefinitionRepository.GetViewDefinition(vd.Name);
Assert.NotNull(roundTripped);
AssertEquivalent(vd, roundTripped);
remoteClient.ViewDefinitionRepository.RemoveViewDefinition(vd.Name);
Assert.DoesNotContain(vd.Name, Context.ViewProcessor.ViewDefinitionRepository.GetDefinitionNames());
}
}
protected int GetInputData(ValueRequirement valueRequirement, string messageForInput = null)
{
int resultData = 0;
while (true)
{
if (messageForInput != null)
{
PrintMessage(messageForInput);
}
if (int.TryParse(InputData(), out int inputvalue) && valueRequirement(inputvalue))
{
resultData = inputvalue;
break;
}
else
{
PrintMessage("Неверный ввод, повторите попытку!");
}
}
return(resultData);
}
public void ViewHasRightValue()
{
ValueRequirement req = GetRequirement();
using (var remoteClient = Context.CreateFinancialClient())
{
ViewDefinition vd = GetViewDefinition(req, TestUtils.GetUniqueName());
var uid = remoteClient.ViewDefinitionRepository.AddViewDefinition(new AddViewDefinitionRequest(vd));
Assert.NotNull(uid);
vd.UniqueID = uid;
using (var remoteViewClient = Context.ViewProcessor.CreateClient())
{
var viewComputationResultModel = remoteViewClient.GetResults(vd.UniqueID, ExecutionOptions.SingleCycle).First();
Assert.NotNull(viewComputationResultModel);
var count = viewComputationResultModel.AllResults.Where(spec => req.IsSatisfiedBy(spec.ComputedValue.Specification)).Count();
Assert.Equal(1, count);
}
remoteClient.ViewDefinitionRepository.RemoveViewDefinition(vd.Name);
}
}
public bool TryGetComputedValue(string calculationConfiguration, ValueRequirement valueRequirement, out ComputedValue result)
{
result = null;
ViewCalculationResultModel model;
if (!_configurationMap.TryGetValue(calculationConfiguration, out model))
{
return(false);
}
ISet <ComputedValue> values;
if (!model.TryGetAllValues(valueRequirement.TargetSpecification, out values))
{
return(false);
}
var computedValues = values.Where(v => valueRequirement.IsSatisfiedBy(v.Specification));
result = computedValues.FirstOrDefault();
return(result != null);
}
public static void AssertSensibleValue(ValueRequirement value)
{
Assert.NotNull(value);
Assert.NotEmpty(value.ValueName);
}
protected ViewDefinition CreateViewDefinition(ValueRequirement valueRequirement)
{
return(_testViewFactory.CreateViewDefinition(Context, valueRequirement));
}
private CurrencyMatrixValueRequirement(ValueRequirement valueRequirement, bool reciprocal)
{
_valueRequirement = valueRequirement;
_reciprocal = reciprocal;
}
