public void UnsuccessfulMatchReturnsNotFound()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var list = new List <PartyRoleMapping>();
repository.Setup(x => x.Queryable <PartyRoleMapping>()).Returns(list.AsQueryable());
var request = new CrossMappingRequest {
SystemName = "Endur", Identifier = "A", ValidAt = SystemTime.UtcNow(), TargetSystemName = "Trayport"
};
// Act
var contract = service.CrossMap(request);
// Assert
Assert.IsNotNull(contract, "Contract null");
Assert.IsFalse(contract.IsValid, "Contract valid");
Assert.AreEqual(ErrorType.NotFound, contract.Error.Type, "ErrorType difers");
}
public void EntityNotFound()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var cd = new EnergyTrading.MDM.Contracts.Sample.BrokerDetails {
Name = "Test"
};
var nexus = new EnergyTrading.Mdm.Contracts.SystemData {
StartDate = new DateTime(2012, 1, 1)
};
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker {
Details = cd, MdmSystemData = nexus
};
validatorFactory.Setup(x => x.IsValid(It.IsAny <EnergyTrading.MDM.Contracts.Sample.Broker>(), It.IsAny <IList <IRule> >())).Returns(true);
// Act
var response = service.Update(1, 1, contract);
// Assert
Assert.IsNotNull(response, "Response is null");
Assert.IsFalse(response.IsValid, "Response is valid");
Assert.AreEqual(ErrorType.NotFound, response.Error.Type, "ErrorType differs");
}
public BaseTest()
{
AutoMapperConfiguration.CreateAllMaps();
var service = new BrokerService();
AutoMapperConfiguration.CreateAllMaps();
}
public void EarlierVersionRaisesVersionConflict()
{
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
validatorFactory.Setup(x => x.IsValid(It.IsAny <EnergyTrading.MDM.Contracts.Sample.Broker>(), It.IsAny <IList <IRule> >())).Returns(true);
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var cd = new EnergyTrading.MDM.Contracts.Sample.BrokerDetails {
Name = "Test"
};
var nexus = new EnergyTrading.Mdm.Contracts.SystemData {
StartDate = new DateTime(2012, 1, 1)
};
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker {
Details = cd, MdmSystemData = nexus
};
var details = new BrokerDetails {
Id = 2, Name = "Test"
};
var entity = new Broker();
entity.AddDetails(details);
repository.Setup(x => x.FindOne <Broker>(1)).Returns(entity);
// Act
service.Update(1, 1, contract);
}
public void RetrieveListOfCarsForBroker()
{
IBrokerService brokerService = new BrokerService(_dbContext);
AppUser user = _dbContext.AppUser.FirstOrDefault(u => u.Id.Equals(_testedBrokerGuid.ToString()));
var result = brokerService.GetCars(user);
}
public SqlXml Create(BrokerService serv, string c)
{
try {
SqlConnection conn = smo.CreateNewConnection(_db);
conn.ChangeDatabase(_db.Name);
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = "sp_export_service_listing";
cmd.CommandType = CommandType.StoredProcedure;
//service name
cmd.Parameters.Add("@service_name", SqlDbType.VarChar, 256);
cmd.Parameters[0].Value = serv.Name;
//cert - if any
cmd.Parameters.Add("@cert_name", SqlDbType.VarChar, 256);
cmd.Parameters[1].Value = c;
cmd.Parameters.Add("@service_listing", SqlDbType.Xml);
cmd.Parameters[2].Direction = ParameterDirection.InputOutput;
cmd.Parameters[2].Value = new SqlXml();
cmd.ExecuteNonQuery();
//string list = cmd.Parameters[2].Value.ToString();
_listing = (SqlXml)cmd.Parameters[2].Value;
}
catch (Exception ex) {
throw;
}
return(_listing);
}
private Task ExecuteProcessAllQueuesAsync(BrokerService broker)
{
// Execute RunAsync to process queues.
var processQueuesMethod = typeof(MockBrokerServiceWithEvents).GetMethod("ProcessAllQueuesAsync", BindingFlags.NonPublic | BindingFlags.Instance);
return((Task)processQueuesMethod.Invoke(broker, new object[] { CancellationToken.None }));
}
public async Task <string> Buy([FromBody] BuyOrder buyOrder)
{
Console.Out.WriteLine("BuyService recieved order:" +
buyOrder.BuyerId + "\n" +
buyOrder.MaxPrice + "\n" +
buyOrder.Quantity + "\n" +
buyOrder.TickerSymbol);
HttpResponseMessage response;
try
{
response = await BrokerService.SubmitBuyOrder(buyOrder);
}
catch (Exception e)
{
return(e.Message);
}
if (response.IsSuccessStatusCode)
{
Console.Out.WriteLine("BuyService: " + Resource.order_submitted_ok);
return(Resource.order_submitted_ok);
}
Console.Out.WriteLine("BuyService: " + Resource.order_submitted_error);
return(Resource.order_submitted_error);
}
public static void MyClassInitialize(TestContext testContext)
{
AutoMapperConfiguration.CreateAllMaps();
var service = new BrokerService();
AutoMapperConfiguration.CreateAllMaps();
_accountServiceImpl = BrokerService.Container.Resolve <IAccountsService>();
_lookupServiceImpl = BrokerService.Container.Resolve <ILookupService>();
}
public void CreateBrokerPolicyTemplate()
{
IBrokerService brokerService = new BrokerService(_dbContext);
AppUser user = _dbContext.AppUser.FirstOrDefault(u => u.Id.Equals(_testedBrokerGuid.ToString()));
bool result = brokerService.CreateBrokerPolicyTemplate(user);
Assert.IsTrue(result);
}
public IHttpActionResult GetMineById()
{
var u = Request.GetQueryString("u");
var service = new BrokerService();
var r = service.GetByNo(u);
return(Ok(r));
}
public void Create()
{
BrokerService brokerService = null;
ExtendedProperty prop = null;
if (!this.ServiceBroker.Services.Contains(this.FullName))
{
// Create initiator service
brokerService = new BrokerService(this.ServiceBroker, this.FullName);
brokerService.QueueName = this.QueueName;
brokerService.Owner = this.ServiceOwnerName;
foreach (object item in this.ContractNames)
{
ServiceContractMapping brokerServiceContract
= new ServiceContractMapping(brokerService, item.ToString());
brokerService.ServiceContractMappings.Add(brokerServiceContract);
}
if (!String.IsNullOrEmpty(this.ServiceOwnerName))
{
CreateUser();
}
//Create Certificate if EnableRemoteServiceBinding = true and AllowAnonymous = false
if (m_EnableRemoteServiceBinding &&
!String.IsNullOrEmpty(this.ServiceOwnerName) && !this.AllowAnonymous)
{
prop = new ExtendedProperty(brokerService,
"CertificateName", this.Certificate.Name);
this.Certificate.Owner = this.ServiceOwnerName;
this.Certificate.Create();
}
//Create ReportServiceBinding
if (m_EnableRemoteServiceBinding && !String.IsNullOrEmpty(this.ServiceOwnerName))
{
this.CreateRemoteServiceBinding();
}
//Grant Receive
if (this.GrantReceive)
{
CreateGrantReceive();
}
brokerService.Create();
//Create property last
if (prop != null)
{
prop.Create();
}
}
}
internal static BrokerService CreateSMOService(Database db, string name)
{
ServiceBroker sb = db.ServiceBroker;
BrokerService bserv = null;
bserv = sb.Services[name];
//svr.ConnectionContext.Disconnect();
return(bserv);
}
public static void MyClassInitialize(TestContext testContext)
{
AutoMapperConfiguration.CreateAllMaps();
var service = new BrokerService();
AutoMapperConfiguration.CreateAllMaps();
_sitesService = new SitesService();
// _accountsService = new AccountsServiceImpl();
_wcfSitesService = new SitesServiceClient();
}
public BrokerController() : base()
{
System.Diagnostics.Debug.WriteLine("init Broker Controller");
_service = new BrokerService();
_client = new HttpClient();
_client.BaseAddress = new Uri("https://localhost:44309/api/");
_client.DefaultRequestHeaders.Accept.Clear();
_client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
}
public IHttpActionResult SetFirm()
{
var r = new MessageRecorder <IList <BrokerageFirm> >();
var u = Request.GetQueryString("u");
var n = Request.GetQueryString("n");
var service = new BrokerService();
var a = service.UpdateFirm(u, n);
return(Ok(a));
}
public void NullRequestErrors()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
// Act
service.CrossMap(null);
}
static void Main(string[] args)
{
XTrace.UseConsole();
XTrace.Debug = true;
svr = new BrokerService {
ProducerServer = { Log = XTrace.Log }
};
Test();
System.Threading.Thread.Sleep(1000);
Client();
Console.ReadLine();
}
public void NullRequestErrors()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
// Act
service.CrossMap(null);
}
public static void Start()
{
_server = new Grpc.Core.Server
{
Services = { BrokerService.BindService(new BusinessImpl()) },
Ports = { new ServerPort("0.0.0.0", Const.SettingService.Local.Port, ServerCredentials.Insecure) }
};
new Thread(_server.Start)
{
IsBackground = true
}.Start(); //开启业务服务
State = true;
}
internal static Service GetSSBIService(Database db, string servName)
{
BrokerService bServ = db.ServiceBroker.Services[servName];
SqlConnection conn = CreateNewConnection(db);
if (conn.Database != bServ.Parent.Parent.Name)
{
conn.ChangeDatabase(bServ.Parent.Parent.Name);
}
return(new Service(bServ.Name, false, conn));
}
public void NullContractInvalid()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
validatorFactory.Setup(x => x.IsValid(It.IsAny <object>(), It.IsAny <IList <IRule> >())).Returns(false);
// Act
service.Create(null);
}
private void RegisterViewsAndServices()
{
// 0. intialize tickqueue and basket
_tickqueue = new BlockingCollection <Tick>(_configmanagerservice.TickQueueCapacity);
_basket = Basket.DeserializeFromXML(Util.GetRootPath() + _configmanagerservice.SettingPath + "basket.xml");
// 1. BrokerService, no need to register
_brokerservice = new BrokerService(_configmanagerservice, _eventAggregator, _logger, _globalidservice, _tickqueue, _basket);
// 2. Tick arichive service, no need to register
_tickarchiveservice = new TickArchiver(Util.GetRootPath() + _configmanagerservice.TickPath + _configmanagerservice.DefaultBroker);
// 3. QuuoteDispatcher Service, no need to register
_quotedispatcherservice = new QuoteDispatcherService(_quoteupdateservice, _feedstrategyservice, _tickarchiveservice, _logger, _tickqueue);
}
public void NullContractInvalid()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
validatorFactory.Setup(x => x.IsValid(It.IsAny<object>(), It.IsAny<IList<IRule>>())).Returns(false);
// Act
service.Create(null);
}
public BrokerServiceConfiguration(string fullName, ServiceBroker serviceBroker)
: base(serviceBroker)
{
if (this.ServiceBroker.Services.Contains(fullName))
{
BrokerService item = this.ServiceBroker.Services[fullName];
base.Urn = new Uri(base.Urn.ToString() + "service/");
m_Name = item.Name.Substring
(base.Urn.ToString().Length, item.Name.Length - base.Urn.ToString().Length);
m_QueueName = item.QueueName;
this.ServiceOwnerName = item.Owner;
//Fill ContractNames from ServiceContractMapping
foreach (ServiceContractMapping map in item.ServiceContractMappings)
{
m_ContractNames.Add(map.Name);
}
//CertificateConfiguration for this Service
//CertificateName is store in ExtendedProperties to match the Service to the Certificate
if (item.ExtendedProperties.Contains("CertificateName"))
{
CertificateConfiguration cert = new
CertificateConfiguration(item.ExtendedProperties["CertificateName"].Value.ToString(),
this.ServiceBroker);
this.Certificate = cert;
}
//RemoteServiceBinding for this Service if it exists
string bindingFullName = base.BaseUrn + "RemoteServiceBinding/" + this.Name + "Binding";
if (this.ServiceBroker.RemoteServiceBindings.Contains(bindingFullName))
{
this.EnableRemoteService = true;
RemoteServiceBinding binding = this.ServiceBroker.
RemoteServiceBindings[bindingFullName];
this.RemoteServiceBinding.CertificateUser = binding.CertificateUser;
this.RemoteServiceBinding.IsAnonymous = binding.IsAnonymous;
this.AllowAnonymous = binding.IsAnonymous;
this.RemoteServiceBinding.Name = binding.Name;
this.RemoteServiceBinding.Owner = binding.Owner;
this.RemoteServiceBinding.RemoteService = binding.RemoteService;
}
}
}
public void InvalidContractNotSaved()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker();
validatorFactory.Setup(x => x.IsValid(It.IsAny <object>(), It.IsAny <IList <IRule> >())).Returns(false);
// Act
service.Create(contract);
}
public void InvalidContractNotSaved()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker();
validatorFactory.Setup(x => x.IsValid(It.IsAny<object>(), It.IsAny<IList<IRule>>())).Returns(false);
// Act
service.Create(contract);
}
/* @"select se.conversation_handle, se.conversation_group_id, s.name [service],
sc.name [contract], se.state_desc, se.far_service, se.is_initiator,
se.lifetime,se.far_broker_instance, from sys.conversation_endpoints se
join sys.services s on se.service_id = s.service_id
join sys.service_contracts sc on se.service_contract_id = sc.service_contract_id
where se.state in ('SO','SI','CO')";*/
public SSBIConversation(BrokerService bServ, IDataRecord rec)
{
_handle = rec.GetGuid(0);
_grpId = rec.GetGuid(1);
_fromService = rec.GetString(2);
_toService = rec.GetString(5);
_state = rec.GetString(4);
_contract = rec.GetString(3);
_initiator = rec.GetBoolean(6);
_lifeTime = rec.GetDateTime(7);
string o = rec[8].ToString();
_farBrokerGuid = Guid.Empty;
if(o != string.Empty)
_farBrokerGuid = new Guid(rec.GetString(8));
_serv = bServ;
//_msgColl = smo.GetMessageCollection(bServ, bServ.Parent.Parent, _handle, null);
}
public EmbeddedBroker(ushort port = 0, bool persistent = false)
{
_bs = new BrokerService();
_bs.setPersistent(persistent);
_bs.setUseJmx(false);
_bs.setEnableStatistics(false);
_bs.setStartAsync(false);
_dataDir = GetTemporaryDirectory();
_bs.setDataDirectory(_dataDir);
var connector = _bs.addConnector("tcp://localhost:" + port);
Uri = connector.getUri().ToString();
_bs.start();
}
public EmbeddedBroker(ushort port = 0, bool persistent = false)
{
_bs = new BrokerService();
_bs.setPersistent(persistent);
_bs.setUseJmx(false);
_bs.setEnableStatistics(false);
_bs.setStartAsync(false);
_dataDir = GetTemporaryDirectory();
_bs.setDataDirectory(_dataDir);
var connector = _bs.addConnector("tcp://localhost:" + port);
Uri = connector.getUri().ToString();
_bs.start();
}
/* @"select se.conversation_handle, se.conversation_group_id, s.name [service],
* sc.name [contract], se.state_desc, se.far_service, se.is_initiator,
* se.lifetime,se.far_broker_instance, from sys.conversation_endpoints se
* join sys.services s on se.service_id = s.service_id
* join sys.service_contracts sc on se.service_contract_id = sc.service_contract_id
* where se.state in ('SO','SI','CO')";*/
public SSBIConversation(BrokerService bServ, IDataRecord rec)
{
_handle = rec.GetGuid(0);
_grpId = rec.GetGuid(1);
_fromService = rec.GetString(2);
_toService = rec.GetString(5);
_state = rec.GetString(4);
_contract = rec.GetString(3);
_initiator = rec.GetBoolean(6);
_lifeTime = rec.GetDateTime(7);
string o = rec[8].ToString();
_farBrokerGuid = Guid.Empty;
if (o != string.Empty)
{
_farBrokerGuid = new Guid(rec.GetString(8));
}
_serv = bServ;
//_msgColl = smo.GetMessageCollection(bServ, bServ.Parent.Parent, _handle, null);
}
public async Task GetTrending()
{
// Arrange
var obj = new List <StockEntity>
{
new StockEntity(),
new StockEntity(),
new StockEntity(),
new StockEntity(),
new StockEntity()
};
_stockRepository.Setup(x => x.GetAll()).ReturnsAsync(obj);
// Act
var service = new BrokerService(_logger.Object, _bankAccountRepository.Object,
_bankAccountStockRepository.Object, _brokerAdapter.Object, _stockRepository.Object);
var result = await service.GetTrending();
// Assert
Assert.NotEmpty(result);
}
internal static IDeviceTimeSyncService Initialise(BrokerService _BrokerService)
{
try
{
_logger.Info(" ");
_logger.Info("-----------------------------------l-");
_logger.Info("startingDeviceTimeSync Service");
_BrokerInstance = _BrokerService;
Uri httpUrl = new Uri("https://localhost:6530/DeviceTimeSyncService");
//Create ServiceHost
WebServiceHost host
= new WebServiceHost(typeof(DeviceTimeSyncService), httpUrl);
//Add a service endpoint
host.AddServiceEndpoint(typeof(IDeviceTimeSyncService)
, new WebHttpBinding(WebHttpSecurityMode.Transport), "");//WSHttpBinding
ServiceThrottlingBehavior throttleBehavior = new ServiceThrottlingBehavior
{
MaxConcurrentCalls = 500,
MaxConcurrentInstances = 500,
MaxConcurrentSessions = 500,
};
host.Description.Behaviors.Add(throttleBehavior);
host.Open();
_logger.Info("DeviceTimeSync Service started successfully");
return(null);//service;
}
catch (Exception ex)
{
_logger.Info("DeviceTimeSync Service Initialise() Exception" + ex.Message);
InsertBrokerOperationLog.AddProcessLog("DeviceTimeSync Service Initialise() Exception" + ex.Message);
_BrokerInstance.isInitialiseFail = true;
}
return(null);
}
public void ValidContractIsSaved()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var broker = new Broker();
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker();
validatorFactory.Setup(x => x.IsValid(It.IsAny<EnergyTrading.MDM.Contracts.Sample.Broker>(), It.IsAny<IList<IRule>>())).Returns(true);
mappingEngine.Setup(x => x.Map<EnergyTrading.MDM.Contracts.Sample.Broker, Broker>(contract)).Returns(broker);
// Act
var expected = service.Create(contract);
// Assert
Assert.AreSame(expected, broker, "Broker differs");
repository.Verify(x => x.Add(broker));
repository.Verify(x => x.Flush());
}
public void ValidContractIsSaved()
{
// Arrange
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var broker = new Broker();
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker();
validatorFactory.Setup(x => x.IsValid(It.IsAny <EnergyTrading.MDM.Contracts.Sample.Broker>(), It.IsAny <IList <IRule> >())).Returns(true);
mappingEngine.Setup(x => x.Map <EnergyTrading.MDM.Contracts.Sample.Broker, Broker>(contract)).Returns(broker);
// Act
var expected = service.Create(contract);
// Assert
Assert.AreSame(expected, broker, "Broker differs");
repository.Verify(x => x.Add(broker));
repository.Verify(x => x.Flush());
}
public void EarlierVersionRaisesVersionConflict()
{
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
validatorFactory.Setup(x => x.IsValid(It.IsAny<EnergyTrading.MDM.Contracts.Sample.Broker>(), It.IsAny<IList<IRule>>())).Returns(true);
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var cd = new EnergyTrading.MDM.Contracts.Sample.BrokerDetails { Name = "Test" };
var nexus = new EnergyTrading.Mdm.Contracts.SystemData { StartDate = new DateTime(2012, 1, 1) };
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker { Details = cd, MdmSystemData = nexus };
var details = new BrokerDetails { Id = 2, Name = "Test" };
var entity = new Broker();
entity.AddDetails(details);
repository.Setup(x => x.FindOne<Broker>(1)).Returns(entity);
// Act
service.Update(1, 1, contract);
}
public void EntityNotFound()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var cd = new EnergyTrading.MDM.Contracts.Sample.BrokerDetails { Name = "Test" };
var nexus = new EnergyTrading.Mdm.Contracts.SystemData { StartDate = new DateTime(2012, 1, 1) };
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker { Details = cd, MdmSystemData = nexus };
validatorFactory.Setup(x => x.IsValid(It.IsAny<EnergyTrading.MDM.Contracts.Sample.Broker>(), It.IsAny<IList<IRule>>())).Returns(true);
// Act
var response = service.Update(1, 1, contract);
// Assert
Assert.IsNotNull(response, "Response is null");
Assert.IsFalse(response.IsValid, "Response is valid");
Assert.AreEqual(ErrorType.NotFound, response.Error.Type, "ErrorType differs");
}
public void UnsuccessfulMatchReturnsNotFound()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
var list = new List<PartyRoleMapping>();
repository.Setup(x => x.Queryable<PartyRoleMapping>()).Returns(list.AsQueryable());
var request = new CrossMappingRequest { SystemName = "Endur", Identifier = "A", ValidAt = SystemTime.UtcNow(), TargetSystemName = "Trayport" };
// Act
var contract = service.CrossMap(request);
// Assert
Assert.IsNotNull(contract, "Contract null");
Assert.IsFalse(contract.IsValid, "Contract valid");
Assert.AreEqual(ErrorType.NotFound, contract.Error.Type, "ErrorType difers");
}
public void ValidDetailsSaved()
{
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
// Contract
var cd = new EnergyTrading.MDM.Contracts.Sample.BrokerDetails { Name = "Test" };
var nexus = new EnergyTrading.Mdm.Contracts.SystemData { StartDate = new DateTime(2012, 1, 1) };
var identifier = new EnergyTrading.Mdm.Contracts.MdmId { SystemName = "Test", Identifier = "A" };
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker { Details = cd, MdmSystemData = nexus };
contract.Identifiers.Add(identifier);
// Domain
var system = new SourceSystem { Name = "Test" };
var mapping = new PartyRoleMapping { System = system, MappingValue = "A" };
var d1 = new BrokerDetails { Id = 1, Name = "Test", Timestamp = 74UL.GetVersionByteArray() };
var entity = new Broker() { Party = new Party() { Id = 999 } };
entity.AddDetails(d1);
var d2 = new BrokerDetails { Name = "Test" };
var range = new DateRange(new DateTime(2012, 1, 1), DateTime.MaxValue);
validatorFactory.Setup(x => x.IsValid(It.IsAny<CreateMappingRequest>(), It.IsAny<IList<IRule>>())).Returns(true);
validatorFactory.Setup(x => x.IsValid(It.IsAny<EnergyTrading.MDM.Contracts.Sample.Broker>(), It.IsAny<IList<IRule>>())).Returns(true);
repository.Setup(x => x.FindOne<Broker>(1)).Returns(entity);
mappingEngine.Setup(x => x.Map<EnergyTrading.MDM.Contracts.Sample.BrokerDetails, BrokerDetails>(cd)).Returns(d2);
mappingEngine.Setup(x => x.Map<EnergyTrading.Mdm.Contracts.SystemData, DateRange>(nexus)).Returns(range);
mappingEngine.Setup(x => x.Map<EnergyTrading.Mdm.Contracts.MdmId, PartyRoleMapping>(identifier)).Returns(mapping);
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
// Act
service.Update(1, 74, contract);
// Assert
Assert.AreEqual(2, entity.Details.Count, "Details count differs");
Assert.AreEqual(1, entity.Mappings.Count, "Mapping count differs");
repository.Verify(x => x.Save(entity));
repository.Verify(x => x.Flush());
}
public void ValidDetailsSaved()
{
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
// Contract
var cd = new EnergyTrading.MDM.Contracts.Sample.BrokerDetails {
Name = "Test"
};
var nexus = new EnergyTrading.Mdm.Contracts.SystemData {
StartDate = new DateTime(2012, 1, 1)
};
var identifier = new EnergyTrading.Mdm.Contracts.MdmId {
SystemName = "Test", Identifier = "A"
};
var contract = new EnergyTrading.MDM.Contracts.Sample.Broker {
Details = cd, MdmSystemData = nexus
};
contract.Identifiers.Add(identifier);
// Domain
var system = new SourceSystem {
Name = "Test"
};
var mapping = new PartyRoleMapping {
System = system, MappingValue = "A"
};
var d1 = new BrokerDetails {
Id = 1, Name = "Test", Timestamp = 74UL.GetVersionByteArray()
};
var entity = new Broker()
{
Party = new Party()
{
Id = 999
}
};
entity.AddDetails(d1);
var d2 = new BrokerDetails {
Name = "Test"
};
var range = new DateRange(new DateTime(2012, 1, 1), DateTime.MaxValue);
validatorFactory.Setup(x => x.IsValid(It.IsAny <CreateMappingRequest>(), It.IsAny <IList <IRule> >())).Returns(true);
validatorFactory.Setup(x => x.IsValid(It.IsAny <EnergyTrading.MDM.Contracts.Sample.Broker>(), It.IsAny <IList <IRule> >())).Returns(true);
repository.Setup(x => x.FindOne <Broker>(1)).Returns(entity);
mappingEngine.Setup(x => x.Map <EnergyTrading.MDM.Contracts.Sample.BrokerDetails, BrokerDetails>(cd)).Returns(d2);
mappingEngine.Setup(x => x.Map <EnergyTrading.Mdm.Contracts.SystemData, DateRange>(nexus)).Returns(range);
mappingEngine.Setup(x => x.Map <EnergyTrading.Mdm.Contracts.MdmId, PartyRoleMapping>(identifier)).Returns(mapping);
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
// Act
service.Update(1, 74, contract);
// Assert
Assert.AreEqual(2, entity.Details.Count, "Details count differs");
Assert.AreEqual(1, entity.Mappings.Count, "Mapping count differs");
repository.Verify(x => x.Save(entity));
repository.Verify(x => x.Flush());
}
int UpDateSsb()
{
updatedobj = null;
//if (!isDirty)
//return 0;
if (!ValidateData()) {
Cursor crs = Cursor.Current;
Cursor.Current = Cursors.WaitCursor;
try {
Database db = null;
ServiceBroker sb = null;
if (ssbType != SsbEnum.Database && ssbType != SsbEnum.Login && ssbType != SsbEnum.EndPoint) {
sb = dBase.ServiceBroker;
}
switch (ssbType) {
case SsbEnum.Database:
MasterKey mk = null;
SSBIDatabase sbd = null;
if (isEdit) {
sbd = (SSBIDatabase)objToUpdate;
db = sbd.DataBase;
}
else {
db = new Database();
db.Name = txtName.Text;
db.Parent = dbServ.SMOServer;
}
if (isEdit) {
if(db.MasterKey != null && db_chkMasterKey.Checked == false) {
mk = db.MasterKey;
mk.Drop();
}
else if (db.MasterKey == null && db_chkMasterKey.Checked) {
mk = new MasterKey();
mk.Parent = db;
mk.Create(db_txtMkPwd.Text);
}
db.Alter();
if (sbd.IsTrustworthy != db_chkTrustWorthy.Checked)
sbd.IsTrustworthy = db_chkTrustWorthy.Checked;
}
else {
db.Create();
sbd = new SSBIDatabase(db);
if (db_chkMasterKey.Checked) {
mk = new MasterKey();
mk.Parent = db;
mk.Create(db_txtMkPwd.Text);
}
if (db_chkTrustWorthy.Checked) {
sbd.IsTrustworthy = true;
}
}
if (dBase == null)
dBase = db;
//Server serv = db.Parent;
updatedobj = db;
break;
case SsbEnum.MessageType:
MessageType mt = null;
if (isEdit)
mt = (MessageType)objToUpdate;
else {
mt = new MessageType();
mt.Parent = sb;
mt.Name = txtName.Text;
}
if (cboUser.Text != string.Empty)
mt.Owner = cboUser.Text;
mt.MessageTypeValidation = (MessageTypeValidation)Enum.Parse(typeof(MessageTypeValidation), cboVal.Text);
if (cboValSchema.Enabled)
mt.ValidationXmlSchemaCollection = cboValSchema.Text;
if (isEdit)
mt.Alter();
else
mt.Create();
updatedobj = mt;
break;
case SsbEnum.Contract:
ServiceContract sc = new ServiceContract();
sc.Parent = sb;
sc.Name = txtName.Text;
if (cboUser.Text != string.Empty)
sc.Owner = cboUser.Text;
//get the message types
foreach (DataGridViewRow row in dvMsgTypes.Rows) {
sc.MessageTypeMappings.Add(new MessageTypeMapping(sc, row.Cells[0].Value.ToString(), (MessageSource)Enum.Parse(typeof(MessageSource), row.Cells[1].Value.ToString())));
}
if (isEdit)
sc.Alter();
else
sc.Create();
updatedobj = sc;
break;
case SsbEnum.Queu:
ServiceQueue q = null;
if (isEdit)
q = (ServiceQueue)objToUpdate;
else {
q = new ServiceQueue();
q.Parent = sb;
q.Name = txtName.Text;
}
q.IsEnqueueEnabled = chkStatus.Checked;
if (chkRetention.Checked)
q.IsRetentionEnabled = true;
//if (chkActivation.Checked) {
//if(isEdit)
// q.IsActivationEnabled = chkActivation.Checked;
//
if (chkActivation.Checked) {
q.IsActivationEnabled = chkActivation.Checked;
if (dBase.Name != cboQDb.Text)
q.ProcedureDatabase = cboQDb.Text;
StoredProcedure sp = (StoredProcedure)cboProc.SelectedItem;
q.ProcedureSchema = sp.Schema;
q.ProcedureName = cboProc.Text;
q.MaxReaders = short.Parse(txtReaders.Text);
if (rdOwner.Checked)
q.ActivationExecutionContext = ActivationExecutionContext.Owner;
else if (rdSelf.Checked)
q.ActivationExecutionContext = ActivationExecutionContext.Self;
else if (rdUser.Checked) {
q.ActivationExecutionContext = ActivationExecutionContext.ExecuteAsUser;
q.ExecutionContextPrincipal = txtExecuteAs.Text;
}
}
if (isEdit)
q.Alter();
else
q.Create();
updatedobj = q;
break;
case SsbEnum.Service:
BrokerService bserv = null;
if (isEdit)
bserv = (BrokerService)objToUpdate;
else {
bserv = new BrokerService();
bserv.Parent = sb;
bserv.Name = txtName.Text;
}
if (cboUser.Text != string.Empty)
bserv.Owner = cboUser.Text;
ServiceQueue servq = (ServiceQueue)cboQueue.SelectedItem;
bserv.QueueName = servq.Name;
bserv.QueueSchema = servq.Schema;
if (lbChosenCtr.Items.Count > 0) {
foreach (object o in lbChosenCtr.Items) {
ServiceContract servctr = o as ServiceContract;
ServiceContractMapping scm = new ServiceContractMapping(bserv, servctr.Name);
bserv.ServiceContractMappings.Add(scm);
}
}
if (isEdit)
bserv.Alter();
else
bserv.Create();
updatedobj = bserv;
break;
case SsbEnum.Route:
ServiceRoute srt = null;
if (isEdit)
srt = (ServiceRoute)objToUpdate;
else {
srt = new ServiceRoute();
srt.Name = txtName.Text;
srt.Parent = sb;
}
if (cboUser.Text != string.Empty)
srt.Owner = cboUser.Text;
if (textBroker.Text != string.Empty)
srt.BrokerInstance = textBroker.Text;
if (textRemote.Text != string.Empty)
srt.RemoteService = textRemote.Text;
if (textLifeTime.Text != string.Empty)
srt.ExpirationDate = DateTime.Parse(textLifeTime.Text);
if (rdLocal.Checked)
srt.Address = "LOCAL";
if (rdTransport.Checked)
srt.Address = "TRANSPORT";
if (rdTCP.Checked)
srt.Address = "TCP://" + txtAddress.Text;
if (txtMirror.Text != string.Empty)
srt.MirrorAddress = "TCP://" + txtMirror.Text;
//StringCollection sColl = srt.Script();
//foreach (string s in sColl)
// MessageBox.Show(s);
if (isEdit)
srt.Alter();
else
srt.Create();
updatedobj = srt;
break;
case SsbEnum.RemoteBinding:
RemoteServiceBinding remBind = null;
if (isEdit)
remBind = (RemoteServiceBinding)objToUpdate;
else {
remBind = new RemoteServiceBinding();
remBind.Name = txtName.Text;
remBind.Parent = sb;
}
if (cboUser.Text != string.Empty)
remBind.Owner = cboUser.Text;
remBind.RemoteService = textRemServ.Text;
remBind.CertificateUser = cboRemUser.Text;
remBind.IsAnonymous = chkAnon.Checked;
StringCollection sColl = remBind.Script();
foreach (string s in sColl)
MessageBox.Show(s);
if (isEdit)
remBind.Alter();
else
remBind.Create();
updatedobj = remBind;
break;
case SsbEnum.Conversation:
TimeSpan ts = TimeSpan.Zero;
Guid grpHandle = Guid.Empty;
string convContract = "DEFAULT";
BrokerService bServ = (BrokerService)cnv_cboFrmServ.SelectedItem;
string toService = cnv_txtToSrv.Text;
if (cnv_txtLifetime.Text != string.Empty && cnv_txtLifetime.Text != "0")
ts = TimeSpan.FromSeconds(double.Parse(cnv_txtLifetime.Text));
if (cnv_cboContract.Text != string.Empty)
convContract = cnv_cboContract.Text;
if (cnv_txtRelGrpHndl.Text != string.Empty)
grpHandle = new Guid(cnv_txtRelGrpHndl.Text);
//get a service object
Service smoserv = smo.GetSSBIService(bServ.Parent.Parent, bServ.Name);
if (smoserv.Connection.State == ConnectionState.Closed)
smoserv.Connection.Open();
smoserv.Connection.ChangeDatabase(bServ.Parent.Parent.Name);
updatedobj = smoserv.BeginDialog(toService, convContract, ts, cnv_chkEncryption.Checked, grpHandle);
break;
case SsbEnum.Message:
SSBIConversation msgConv = (SSBIConversation)msg_cboConv.SelectedItem;
string servName = msg_txtFrom.Text;
//we need a service object
Service msgSsbiServ = smo.GetSSBIService(dBase, msgConv.FromService);
if (msgSsbiServ.Connection.State== ConnectionState.Closed)
msgSsbiServ.Connection.Open();
msgSsbiServ.Connection.ChangeDatabase(dBase.Name);
Conversation msgCnv = new Conversation(msgSsbiServ, msgConv.Handle);
string msgType = msg_cboMsgType.SelectedText;
string msgString = msg_rchMsg.Text;
msgType = msg_cboMsgType.Text;
MemoryStream msgBody = new MemoryStream(Encoding.ASCII.GetBytes(msgString));
Microsoft.Samples.SqlServer.Message msg = new Microsoft.Samples.SqlServer.Message(msgType, msgBody);
msgCnv.Send(msg);
break;
case SsbEnum.Login :
string pwd = "";
Login lg = new Login();
lg.Parent = dbServ.SMOServer;
lg.Name = lgn_txtLoginName.Text;
if (lgn_rdSql.Checked) {
pwd = lgn_txtPwd.Text;
lg.PasswordPolicyEnforced = lgn_chkEnforcePolicy.Checked;
lg.LoginType = LoginType.SqlLogin;
lg.Create(pwd);
}
else {
lg.Create();
}
updatedobj = lg;
break;
case SsbEnum.Certificate:
string certOwner = "dbo";
int certSource = cert_cboSource.SelectedIndex;
Certificate cert = new Certificate();
if(!isEdit) {
cert.Name = txtName.Text;
if(cboUser.Text != "")
certOwner = cboUser.Text;
cert.Parent = dBase;
cert.Owner = certOwner;
}
cert.ActiveForServiceBrokerDialog = cert_chkBeginDlg.Checked;
if (certSource == 0) {
if (!isEdit) {
if (cert_chkMasterKey.Checked)
cert.Create(cert_txtCertPath.Text, CertificateSourceType.File, cert_txtPrivPath.Text, cert_txtDecrypt.Text);
else
cert.Create(cert_txtCertPath.Text, CertificateSourceType.File, cert_txtPrivPath.Text, cert_txtDecrypt.Text, cert_txtEncrypt.Text);
}
}
else if (certSource == 1) {
if (!isEdit) {
cert.StartDate = cert_dtValidFrom.Value;
cert.ExpirationDate = cert_dtExpiry.Value;
cert.Subject = cert_txtCertPath.Text;
if (cert_chkMasterKey.Checked) {
cert.Create();
}
else {
cert.Create(cert_txtEncrypt.Text);
}
}
}
else if (certSource == 2) {
if (!isEdit) {
cert.Create(cert_txtCertPath.Text, CertificateSourceType.File);
}
}
if (isEdit)
cert.Alter();
updatedobj = cert;
break;
case SsbEnum.User :
User usr;
if (!isEdit) {
usr = new User();
usr.Name = txtName.Text;
usr.Parent = dBase;
if(usr_chkLogin.Checked)
usr.Login = usr_cboLogin.Text;
}
else
usr = (User)objToUpdate;
if (usr_cboCerts.SelectedIndex != -1)
usr.Certificate = usr_cboCerts.Text;
if (!isEdit)
if (usr_chkLogin.Checked)
usr.Create();
else
smo.CreateUserWithNoLogin(usr);
else
usr.Alter();
updatedobj = usr;
break;
case SsbEnum.EndPoint :
Endpoint ep = null;
if (!isEdit) {
ep = new Endpoint();
ep.Name = txtName.Text;
ep.Parent = dbServ.SMOServer;
ep.ProtocolType = ProtocolType.Tcp;
ep.EndpointType = EndpointType.ServiceBroker;
}
else
ep = ((SSBIEndpoint)objToUpdate).EndPoint;
ep.Protocol.Tcp.ListenerPort = int.Parse(ep_txtPort.Text);
if (ep_txtIp.Text == "ALL")
ep.Protocol.Tcp.ListenerIPAddress = System.Net.IPAddress.Any;
else {
ep.Protocol.Tcp.ListenerIPAddress = System.Net.IPAddress.Parse(ep_txtIp.Text);
}
ep.Payload.ServiceBroker.EndpointAuthenticationOrder = (EndpointAuthenticationOrder)ep_cboAuth.SelectedItem;
if (ep_cboCert.SelectedIndex != -1)
ep.Payload.ServiceBroker.Certificate = ep_cboCert.Text;
ep.Payload.ServiceBroker.EndpointEncryption = (EndpointEncryption)ep_cboEncrypt.SelectedItem;
if (ep_cboAlgorithm.SelectedIndex != -1)
ep.Payload.ServiceBroker.EndpointEncryptionAlgorithm = (EndpointEncryptionAlgorithm)ep_cboAlgorithm.SelectedItem;
ep.Payload.ServiceBroker.IsMessageForwardingEnabled = ep_chkFwd.Checked;
if (ep_txtSize.Text != string.Empty)
ep.Payload.ServiceBroker.MessageForwardingSize = int.Parse(ep_txtSize.Text);
if(!isEdit)
ep.Create();
switch ((EndpointState)ep_cboState.SelectedIndex) {
case EndpointState.Disabled :
ep.Disable();
break;
case EndpointState.Started :
ep.Start();
break;
case EndpointState.Stopped :
if (isEdit)
ep.Stop();
break;
}
if (isEdit)
ep.Alter();
break;
case SsbEnum.CreateListing :
CreateListing(true);
break;
}
if (isEdit)
_state = SsbState.Edited;
else
_state = SsbState.New;
Cursor.Current = crs;
this.DialogResult = DialogResult.OK;
ExitAndClose();
}
catch (FailedOperationException e) {
smo.ShowException(e);
}
catch (Exception ex) {
smo.ShowException(ex);
}
finally {
if(dbServ !=null)
dbServ.SMOServer.ConnectionContext.Disconnect();
}
}
return 0;
}
internal static SSBIConversationCollection GetConversationCollection(Database db, BrokerService bServ, Guid handle)
{
SqlConnection conn = null;
int servid;
conn = CreateNewConnection(db);
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = sqlConversation;
if (bServ != null) {
servid = bServ.ID;
cmd.CommandText += " and se.service_id = @id";
cmd.Parameters.Add("@id", SqlDbType.Int, 4);
cmd.Parameters["@id"].Value = servid;
}
if (handle != Guid.Empty) {
cmd.CommandText += " and se.conversation_handle = @h";
cmd.Parameters.Add("@h", SqlDbType.UniqueIdentifier);
cmd.Parameters["@h"].Value = handle;
}
if (conn.Database != db.Name)
conn.ChangeDatabase(db.Name);
SqlDataReader dr = cmd.ExecuteReader();
SSBIConversationCollection scColl = new SSBIConversationCollection();
while (dr.Read()) {
string srvName = dr["service"].ToString();
if(bServ == null)
bServ = CreateSMOService(db, srvName);
SSBIConversation sc = new SSBIConversation(bServ, dr);
scColl.Add(sc);
}
conn.Close();
return scColl;
}
public void RequestProcessed(BrokerService.Contract.Entity.BrokerResponse response)
{
var request = RequestStorage.Instance.FindRequest(response.RequestId);
if (request == null)
{
Logger.Info("MT4 executor - исходный запрос не найден: " + response);
return;
}
Logger.Info("Ответ MT4 executor: " + response);
if (response.Status != OrderStatus.Executed)
return;
// закрытие ордера
if (request.request.IsClosingRequest)
{
if (!response.Price.HasValue)
{
Logger.Error("Ответ MT4 executor - закрытие позиции - нет цены");
return;
}
ServerInterface.CloseOrder(request.requestedOrder.ID,
response.Price.Value, PositionExitReason.Closed);
return;
}
// открытие ордера
if (!response.Price.HasValue)
response.RejectReason = OrderRejectReason.UnknownOrder;
if (response.RejectReason.HasValue && response.RejectReason.Value != OrderRejectReason.None)
{
ServerInterface.NotifyClientOnOrderRejected(request.requestedOrder,
response.RejectReasonString);
Logger.DebugFormat("{0}: order {1} is rejected for reason {2}",
DealerCode, request.requestedOrder.ToStringShort(), response.RejectReason);
return;
}
var order = request.requestedOrder;
order.PriceEnter = (float) response.Price.Value;
order.AccountID = request.request.Account;
order.TimeEnter = DateTime.Now;
order.State = PositionState.Opened;
order.MasterOrder = response.Mt4OrderId;
int openedOrderId;
ServerInterface.SaveOrderAndNotifyClient(order, out openedOrderId);
}
internal static SSBIMessageCollection GetMessageCollection(BrokerService bServ, Database db, Guid handle, ServiceQueue q)
{
string sqlConn = string.Format("server={0};database={1};Integrated Security='SSPI';", db.Parent.Name, db.Name);
string schema;
string qName;
string sqlExec = @"select q.conversation_group_id,
q.conversation_handle,
q.message_sequence_number,
q.service_name,
se.far_service,
q.service_contract_name,
q.message_type_name,
q.validation, message_body
from {0}.{1} q
join sys.conversation_endpoints se
on q.conversation_handle = se.conversation_handle";
//where se.state in ('SO','SI','CO')";
SqlConnection conn = CreateNewConnection(db);
SqlCommand cmd = conn.CreateCommand();
if (bServ == null && q != null) {
schema = q.Schema;
qName = q.Name;
}
else {
schema = bServ.QueueSchema;
qName = bServ.QueueName;
sqlExec += " and q.service_id = @id";
int id = bServ.ID;
cmd.Parameters.Add("@id", SqlDbType.Int, 4);
cmd.Parameters["@id"].Value = id;
}
if (handle != Guid.Empty) {
sqlExec += " and q.conversation_handle = @h";
cmd.Parameters.Add("@h", SqlDbType.UniqueIdentifier);
cmd.Parameters["@h"].Value = handle;
}
sqlExec = string.Format(sqlExec, schema, qName);
cmd.CommandText = sqlExec;
if (conn.Database != db.Name)
conn.ChangeDatabase(db.Name);
SqlDataReader reader = cmd.ExecuteReader();
SSBIMessageCollection scColl = new SSBIMessageCollection();
while (reader.Read()) {
Guid cnvHandle;
SSBIMessage msg = new SSBIMessage();
msg.ConversationGroupId = reader.GetGuid(0);
cnvHandle = reader.GetGuid(1);
msg.ConversationHandle = cnvHandle;
//msg.Conversation = new Conversation(srv, cnvHandle);
msg.SequenceNumber = reader.GetInt64(2);
msg.RemoteServiceName = reader.GetString(4);
msg.ServiceName = reader.GetString(3);
msg.ContractName = reader.GetString(5);
msg.Type = reader.GetString(6);
msg.Validation = reader.GetString(7);
if (!reader.IsDBNull(8)) {
SqlBytes sb = reader.GetSqlBytes(8);
msg.Body = sb.Stream;
}
else
msg.Body = null;
scColl.Add(msg);
}
conn.Close();
return scColl;
}
public void RequestProcessed(BrokerService.Contract.Entity.BrokerResponse response)
{
var request = RequestStorage.Instance.FindRequest(response.RequestId);
if (request == null)
{
Logger.Info("MT4 executor - исходный запрос не найден: " + response);
return;
}
Logger.Info("Ответ MT4 executor: " + response);
if (response.Status != OrderStatus.Executed)
return;
// закрытие ордера
if (request.request.IsClosingRequest)
{
if (!response.Price.HasValue)
{
Logger.Error("Ответ MT4 executor - закрытие позиции - нет цены");
return;
}
ServerInterface.CloseOrder(request.requestedOrder.ID,
response.Price.Value, PositionExitReason.Closed);
return;
}
// открытие ордера
if (!response.Price.HasValue)
response.RejectReason = OrderRejectReason.UnknownOrder;
if (response.RejectReason.HasValue && response.RejectReason.Value != OrderRejectReason.None)
{
ServerInterface.NotifyClientOnOrderRejected(request.requestedOrder,
response.RejectReasonString);
Logger.DebugFormat("{0}: order {1} is rejected for reason {2}",
DealerCode, request.requestedOrder.ToStringShort(), response.RejectReason);
return;
}
// сравнить запрошенную и итоговые цены
if (request.request.RequestedPrice > 0)
{
// ReSharper disable once PossibleInvalidOperationException
var delta = Math.Abs(response.Price.Value - request.request.RequestedPrice);
var deltaRel = delta * 100 / Math.Min(response.Price.Value, request.request.RequestedPrice);
if (deltaRel > 5)
{
var errorStr = string.Format("{0}: order {1} is rejected: requested price ({2}) is far beyond the resulted price ({3})",
DealerCode, request.requestedOrder.ToStringShort(),
request.request.RequestedPrice.ToStringUniformPriceFormat(true),
response.Price.Value.ToStringUniformPriceFormat(true));
Logger.Error(errorStr);
response.RejectReason = OrderRejectReason.UnknownOrder;
response.RejectReasonString = errorStr;
ServerInterface.NotifyClientOnOrderRejected(request.requestedOrder,
response.RejectReasonString);
return;
}
}
var order = request.requestedOrder;
order.PriceEnter = (float) response.Price.Value;
order.AccountID = request.request.Account;
order.TimeEnter = DateTime.Now;
order.State = PositionState.Opened;
order.MasterOrder = response.Mt4OrderId;
int openedOrderId;
ServerInterface.SaveOrderAndNotifyClient(order, out openedOrderId);
}
public SqlXml Create(BrokerService serv)
{
return Create(serv, null);
}
public SqlXml Create(BrokerService serv, string c)
{
try {
SqlConnection conn = smo.CreateNewConnection(_db);
conn.ChangeDatabase(_db.Name);
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = "sp_export_service_listing";
cmd.CommandType = CommandType.StoredProcedure;
//service name
cmd.Parameters.Add("@service_name", SqlDbType.VarChar, 256);
cmd.Parameters[0].Value = serv.Name;
//cert - if any
cmd.Parameters.Add("@cert_name", SqlDbType.VarChar, 256);
cmd.Parameters[1].Value = c;
cmd.Parameters.Add("@service_listing", SqlDbType.Xml);
cmd.Parameters[2].Direction = ParameterDirection.InputOutput;
cmd.Parameters[2].Value = new SqlXml();
cmd.ExecuteNonQuery();
//string list = cmd.Parameters[2].Value.ToString();
_listing = (SqlXml)cmd.Parameters[2].Value;
}
catch (Exception ex) {
throw;
}
return _listing;
}
public void SuccessMatch()
{
// Arrange
var validatorFactory = new Mock<IValidatorEngine>();
var mappingEngine = new Mock<IMappingEngine>();
var repository = new Mock<IRepository>();
var searchCache = new Mock<ISearchCache>();
var service = new BrokerService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
// Domain details
var system = new MDM.SourceSystem { Name = "Endur" };
var mapping = new PartyRoleMapping
{
System = system,
MappingValue = "A"
};
var targetSystem = new MDM.SourceSystem { Name = "Trayport" };
var targetMapping = new PartyRoleMapping
{
System = targetSystem,
MappingValue = "B",
IsDefault = true
};
var details = new MDM.BrokerDetails
{
Name = "Test",
};
var broker = new MDM.Broker
{
Id = 1
};
broker.AddDetails(details);
broker.ProcessMapping(mapping);
broker.ProcessMapping(targetMapping);
// Contract details
var targetIdentifier = new MdmId
{
SystemName = "Trayport",
Identifier = "B"
};
mappingEngine.Setup(x => x.Map<PartyRoleMapping, MdmId>(targetMapping)).Returns(targetIdentifier);
var list = new List<PartyRoleMapping> { mapping };
repository.Setup(x => x.Queryable<PartyRoleMapping>()).Returns(list.AsQueryable());
var request = new CrossMappingRequest
{
SystemName = "Endur",
Identifier = "A",
TargetSystemName = "trayport",
ValidAt = SystemTime.UtcNow(),
Version = 1
};
// Act
var response = service.CrossMap(request);
var candidate = response.Contract;
// Assert
Assert.IsNotNull(response, "Contract null");
Assert.IsTrue(response.IsValid, "Contract invalid");
Assert.IsNotNull(candidate, "Mapping null");
Assert.AreEqual(1, candidate.Mappings.Count, "Identifier count incorrect");
Assert.AreSame(targetIdentifier, candidate.Mappings[0], "Different identifier assigned");
}
internal static SSBIConversationCollection GetConversationCollection(Database db, BrokerService bServ)
{
return GetConversationCollection(db, bServ, Guid.Empty);
}
public void Create()
{
BrokerService brokerService = null;
ExtendedProperty prop = null;
if (!this.ServiceBroker.Services.Contains(this.FullName))
{
// Create initiator service
brokerService = new BrokerService(this.ServiceBroker, this.FullName);
brokerService.QueueName = this.QueueName;
brokerService.Owner = this.ServiceOwnerName;
foreach (object item in this.ContractNames)
{
ServiceContractMapping brokerServiceContract
= new ServiceContractMapping(brokerService, item.ToString());
brokerService.ServiceContractMappings.Add(brokerServiceContract);
}
if (!String.IsNullOrEmpty(this.ServiceOwnerName))
{
CreateUser();
}
//Create Certificate if EnableRemoteServiceBinding = true and AllowAnonymous = false
if (m_EnableRemoteServiceBinding
&& !String.IsNullOrEmpty(this.ServiceOwnerName) && !this.AllowAnonymous)
{
prop = new ExtendedProperty(brokerService,
"CertificateName", this.Certificate.Name);
this.Certificate.Owner = this.ServiceOwnerName;
this.Certificate.Create();
}
//Create ReportServiceBinding
if (m_EnableRemoteServiceBinding && !String.IsNullOrEmpty(this.ServiceOwnerName))
{
this.CreateRemoteServiceBinding();
}
//Grant Receive
if (this.GrantReceive)
{
CreateGrantReceive();
}
brokerService.Create();
//Create property last
if (prop != null)
prop.Create();
}
}
