public EnrolleeController(IOperatorService operatorService, IEnrolleeService enrolleeService, IStatementService statementService, IStudentStatusService studentStatusService)
{
_operatorService = operatorService;
_enrolleeService = enrolleeService;
_statementService = statementService;
_studentStatusService = studentStatusService;
}
public OperatorPresenter(IKernel kernel, IMainView view, IOperatorService service, Settings settings)
{
_kernel = kernel;
_view = view;
_service = service;
_settings = settings;
}
public SysOperatorController(IBaseManager BaseManager, IRoleService RoleService, IStaffService StaffService, IOperatorService OperatorService) : base(BaseManager)
{
this.BaseManager = BaseManager;
this.RoleService = RoleService;
this.StaffService = StaffService;
this.OperatorService = OperatorService;
}
public WorkLoadService(IJsonService jsonService, IDemandService demandService, IOperatorService operatorService, IJobService jobService, IPenaltyService penaltyService, IParameterService parameterService)
{
JsonService = jsonService;
DemandService = demandService;
OperatorService = operatorService;
JobService = jobService;
ParameterService = parameterService;
}
public OperatorServiceTests()
{
var logger = new Mock <ILogger>();
_mapper = new Mock <IMapper>();
_unitOfWorkMock = new Mock <IUnitOfWork>();
_sut = new OperatorService(_unitOfWorkMock.Object, logger.Object, _mapper.Object);
}
private void MNBRibbon_Load(object sender, RibbonUIEventArgs e)
{
_mnbService = new MNBArfolyamServiceSoapClient();
_operatorService = new OperatorService();
_logDatabaseDataSet = new LogDatabaseDataSet();
_logTableAdapter = new LogTableAdapter();
_logTableAdapter.Fill(_logDatabaseDataSet.Log);
_logBindingSource = new BindingSource();
}
public void Setup()
{
_operatorRepository = MockRepository.GenerateStub<IOperatorRepository>();
_operatorService = new OperatorService(_operatorRepository);
_urlHelper = MockRepository.GenerateStub<IUrlHelper>();
_objectUnderTest = new OperatorsController(_operatorService,_urlHelper);
_objectUnderTest.Request = new HttpRequestMessage();
_objectUnderTest.Request.SetConfiguration(new HttpConfiguration());
}
/// <summary>
/// Initialize a new reference of Application Service Class
/// </summary>
/// <param name="logger"></param>
/// <param name="numberService"></param>
/// <param name="operatorService"></param>
/// <param name="printService"></param>
public ApplicationService(ILogger <ApplicationService> logger,
INumberService numberService,
IOperatorService operatorService,
IPrintService printService)
{
_logger = logger;
_numberService = numberService;
_operatorService = operatorService;
_printService = printService;
}
public void ValidInput_TableNotGenerated()
{
//Arrange
_operatorService = new Multiply(_mockLogger.Object);
//Act
var output = _operatorService.Execute(new List <long> {
});
//Assert
Assert.Null(output);
}
public specialController()
{
_TrendsService = ServiceFactory.TrendsService;
_StatisticsService = ServiceFactory.StatisticsService;
_ModelnumbersService = ServiceFactory.ModelnumbersService;
_OperatingsystemService = ServiceFactory.OperatingsystemService;
_ResolutionService = ServiceFactory.ResolutionService;
_NetworkService = ServiceFactory.NetworkService;
_OperatorService = ServiceFactory.OperatorService;
_ProvinceService = ServiceFactory.ProvinceService;
_AppService = ServiceFactory.AppService;
}
public DataProviderService(ITechnologyService technologyService,
IOperatorService operatorService, IDataGatheringService dataGatheringService)
{
_technologyService = technologyService;
_technologyService.CheckArgumentIsNull(nameof(_technologyService));
_operatorService = operatorService;
_operatorService.CheckArgumentIsNull(nameof(_operatorService));
_dataGatheringService = dataGatheringService;
_dataGatheringService.CheckArgumentIsNull(nameof(_dataGatheringService));
}
public void execute()
{
IOperatorService op = PuppetMaster.getOperator(OpID, ReplicaIndex);
if (op != null)
{
new Thread(() => op.forceUnfreeze()).Start();
}
else
{
Logger.errorWriteLine("Unfreeze.execute: OP not found: " + OpID + " rep " + ReplicaIndex);
}
}
public MainPresenter(IKernel kernel, IMainView mainMenu, IOperatorService operatorService, IControllerService controllerService)
{
_mainView = mainMenu;
_kernel = kernel;
_operatorService = operatorService;
_controllerService = controllerService;
_mainView.GoToSettings += _GoToSettings;
_mainView.AddMan += _AddMan;
_mainView.MoveUpABit += _MoveUp;
_mainView.MoveDownABit += _MoveDown;
_operatorService.MoveUp += _MoveUp;
_operatorService.MoveDown += _MoveDown;
}
public void registerOutputOperator(string opId, string opURL, int replicaIndex)
{
Logger.debugWriteLine(opId + " subscribed to " + myOpId + " replica " + replicaIndex);
IOperatorService service = getOperatorServiceByURL(opURL);
lock (outputOps) {
IList <IOperatorService> replicas;
if (!outputOps.TryGetValue(opId, out replicas))
{
replicas = new List <IOperatorService>();
outputOps.Add(opId, replicas);
}
replicas.Add(service);
Logger.debugWriteLine(myOpId + " now has " + outputOps.Count + " subscribers");
}
}
public void ValidInput_TableGenerated()
{
//Arrange
_operatorService = new Multiply(_mockLogger.Object);
//Act
var output = _operatorService.Execute(new List <long> {
2
});
//Assert
Assert.Contains("4", output);
Assert.Contains("6", output);
Assert.Contains("8", output);
Assert.Contains("20", output);
}
//create a new operator and replicas
public static void addOperator(String opID, int repFact, String[] addresses, String configArgs)
{
Replicas opReplicas = new Dictionary <String, IOperatorService>();
for (int i = 0; i < repFact; i++)
{
//String opURL = addresses[i] + i + opID; //small hack to avoid already registered service names
String opURL = addresses[i]; // the hack is not needed
// OpID opURL replicaIndex inputOps Routing OpSpec OpParams
String args = opID + " " + opURL + " " + i + " " + configArgs;
IProcessCreationService PCS = PCSMan.getPCSbyReplicaURI(opURL);
if (PCS == null)
{
Logger.errorWriteLine("couldn't get PCS of OP " + opURL);
continue;
}
bool pcsOK = false;
while (!pcsOK)
{
try
{
PCS.ping();
PCS.createOperator(args);
pcsOK = true;
}
catch (System.Net.Sockets.SocketException)
{
Console.WriteLine("Waiting for PCS");
Thread.Sleep(100);
}
}
IOperatorService op = (IOperatorService)Activator.GetObject(typeof(IOperatorService), opURL);
opReplicas.Add(new KeyValuePair <String, IOperatorService>(opURL, op));
}
//add created replicas to operator table, associating them with the new OP
OperatorTable.Add(new KeyValuePair <String, Replicas>(opID, opReplicas));
}
public void GetOperaterListTest()
{
var unitOfWorkMock = new Mock <IUnitOfWork>();
unitOfWorkMock.Setup(m => m.OperatorPlanRepository.GetOperatorList())
.Returns(new List <OperaterTable> {
new OperaterTable {
Operater = "Airtel"
}
});
_operaterService = new OperatorService(unitOfWorkMock.Object);
// _logger = (LoggerFactory)new LoggerFactory().CreateLogger("OperatorController");
// Mock<ILogger<OperatorController>> loggerMock = new Mock<ILogger<OperatorController>>();
var operateraController = new OperatorController(_operaterService);
var result = operateraController.GetAllRechargePlans();
Assert.NotNull(result);
}
/// <summary>
/// make ourself an output of our input OPs
/// </summary>
/// <param name=inputOpsURLs>OPs which will send us tuples</param>
private void registerInputs(List <string> inputOpsURLs)
{
foreach (String url in inputOpsURLs)
{
IOperatorService inputOp = getOperatorServiceByURL(url);
/* FIXME we should probably start a new thread here, since not all OPs will be up yet */
Logger.debugWriteLine("Subscribing to " + url);
while (true)
{
try
{
inputOp.registerOutputOperator(myOpId, myOpURL, myReplicaIndex);
break;
}
catch (System.Net.Sockets.SocketException)
{
Console.WriteLine("Waiting for " + url);
Thread.Sleep(100);
}
}
}
}
public TruthTableService(IOperatorService operatorService)
{
_operatorService = operatorService;
}
public OperatorDomainService(IOperatorService operatorService, INotificationContext notificationContext, Envelop.Queryable queryable) => (_operatorService, _notificationContext, _queryable) = (operatorService, notificationContext, queryable);
public ApiOperatorController(IOperatorService operatorService)
{
_operatorService = operatorService;
_operatorService.CheckArgumentIsNull(nameof(_operatorService));
}
public FixConversionService(IOperatorService operatorService)
{
_operatorService = operatorService;
}
public BaseManager(IHttpContextAccessor Accessor, IOperatorService OperatorService)
{
this.Accessor = Accessor;
this.OperatorService = OperatorService;
}
public OperatorsController(IOperatorService operatorService)
{
this.operatorService = operatorService;
}
public OperatorsController(ICommonDataService _ICommonDataService, IOperatorService _IOperatorService)
{
this._ICommonDataService = _ICommonDataService;
this._IOperatorService = _IOperatorService;
}
public OperatorsController(IOperatorService operatorService, IUrlHelper urlHelper)
{
_operatorService = operatorService;
_urlHelper = urlHelper;
}
public OperatorController(IOperatorService operatorService)
{
_operatorService = operatorService;
}
// private readonly ILogger _logger;
public OperatorController(IOperatorService operaterService)
{
///_logger = logger;
_operaterService = operaterService;
}
public OperatorController(IOperatorService operatorService)
{
this.operatorService = operatorService;
}
public AstService(IGrammarService <IGrammarConfig> grammarService, IOperatorService operatorService)
{
this.grammarService = grammarService;
this.operatorService = operatorService;
}
public OperatorController(IOperatorService operatorService, IMapper mapper)
{
_operatorService = operatorService;
_mapper = mapper;
}
