public UpdateGatewayPageAnswerPostClarificationRequestHandler(IApplyRepository applyRepository, IGatewayRepository gatewayRepository, IAuditService auditService, IUnitOfWork unitOfWork)
{
_applyRepository = applyRepository;
_gatewayRepository = gatewayRepository;
_auditService = auditService;
_unitOfWork = unitOfWork;
}
public GatewayService(IGatewayRepository gatewayRepo, IMapper mapper, IUnitOfWorkFactory uowFactory) :
base(gatewayRepo, mapper, uowFactory)
{
_gatewayRepo = gatewayRepo;
_mapper = mapper;
_uowFactory = uowFactory;
}
public AuthenticationService(
IAuthRecordRepository authRecordRepository,
IGatewayRepository gatewayRepository
)
{
_authRecordRepository = authRecordRepository;
_gatewayRepository = gatewayRepository;
}
public WithdrawApplicationHandler(IGatewayRepository gatewayRepository, ILogger <WithdrawApplicationHandler> logger, IOversightReviewRepository oversightReviewRepository, IAuditService auditService, IApplicationUpdatedEmailService applicationUpdatedEmailService)
{
_gatewayRepository = gatewayRepository;
_oversightReviewRepository = oversightReviewRepository;
_auditService = auditService;
_logger = logger;
_applicationUpdatedEmailService = applicationUpdatedEmailService;
}
public UpdateGatewayReviewStatusAsClarificationHandler(IApplyRepository applyRepository, IGatewayRepository gatewayRepository,
IAuditService auditService, IUnitOfWork unitOfWork)
{
_applyRepository = applyRepository;
_gatewayRepository = gatewayRepository;
_auditService = auditService;
_unitOfWork = unitOfWork;
}
public ThingBuilder(IGatewayRepository gatewayRepository, IThingRepository thingRepository,
IThingTemplateRepository thingTemplateRepository, IThingChannelBuilder thingChannelBuilder, IMessageHub messageHub)
{
_gatewayRepository = gatewayRepository;
_thingRepository = thingRepository;
_thingTemplateRepository = thingTemplateRepository;
_thingChannelBuilder = thingChannelBuilder;
_messageHub = messageHub;
}
public GatewaysController(IUserRepository userRep, INetworkRepository networkRep,
IGatewayRepository gatewayRep, ICredentialService credentials, IDateTimeService dateTime,
IMapper mapper, IMessageService messages)
{
_userRep = userRep;
_networkRep = networkRep;
_gatewayRep = gatewayRep;
_credentials = credentials;
_dateTime = dateTime;
_mapper = mapper;
_messages = messages;
}
public ConnectionsController(IUserRepository userRep, INetworkRepository networkRep,
IGatewayRepository gatewayRep, ISensorRepository sensorRep,
IGatewayConnectionRepository connectionRep,
ICredentialService credentials, IMapper mapper, IMessageService messages)
{
_userRep = userRep;
_networkRep = networkRep;
_gatewayRep = gatewayRep;
_sensorRep = sensorRep;
_connectionRep = connectionRep;
_credentials = credentials;
_mapper = mapper;
_messages = messages;
}
public UpdateGatewayReviewStatusAndCommentCommandHandler(IApplyRepository applyRepository,
IGatewayRepository gatewayRepository,
IOversightReviewRepository oversightReviewRepository,
IAuditService auditService,
IApplicationUpdatedEmailService applicationUpdatedEmailService,
IUnitOfWork unitOfWork)
{
_applyRepository = applyRepository;
_gatewayRepository = gatewayRepository;
_oversightReviewRepository = oversightReviewRepository;
_auditService = auditService;
_applicationUpdatedEmailService = applicationUpdatedEmailService;
_unitOfWork = unitOfWork;
}
public GatewayAppService(IRepository <GatewayType, int> gatewayTypeRepository,
IGatewayRepository gatewayRepository,
IWorkshopRepository workshopRepository,
IFactoryRepository factoryRepository,
ICityRepository cityRepository,
IGatewayManager gatewayManager)
{
_gatewayTypeRepository = gatewayTypeRepository;
_gatewayRepository = gatewayRepository;
_workshopRepository = workshopRepository;
_factoryRepository = factoryRepository;
_cityRepository = cityRepository;
_gatewayManager = gatewayManager;
}
public CityAppService(ICityManager cityManager, ICityRepository cityRepository,
IGatewayRepository gatewayRepository,
IWorkshopRepository workshopRepository,
IFactoryRepository factoryRepository,
IDeviceRepository deviceRepository,
IRepository <Region, int> regionRepository)
{
_cityManager = cityManager;
_cityRepository = cityRepository;
_gatewayRepository = gatewayRepository;
_workshopRepository = workshopRepository;
_factoryRepository = factoryRepository;
_deviceRepository = deviceRepository;
_regionRepository = regionRepository;
}
public DeviceAppService(IDeviceRepository deviceRepository,
IRepository <DeviceType> deviceTypeRepository,
IGatewayRepository gatewayRepository,
IWorkshopRepository workshopRepository,
IFactoryRepository factoryRepository,
ICityRepository cityRepository,
IDeviceManager deviceManager,
IFieldRepository fieldRepository
)
{
_deviceRepository = deviceRepository;
_deviceTypeRepository = deviceTypeRepository;
_gatewayRepository = gatewayRepository;
_workshopRepository = workshopRepository;
_factoryRepository = factoryRepository;
_cityRepository = cityRepository;
_deviceManager = deviceManager;
_fieldRepository = fieldRepository;
}
public ReadingsController(IUserRepository userRep, INetworkRepository networkRep,
ISensorRepository sensorRep, IGatewayRepository gatewayRep,
IGatewayConnectionRepository connectionRep, ISensorReadingRepository readingRep,
ICredentialService credentials, IThrottlerService throttler,
IGatewayConnectionService connectionService, IVibrationFilter vibrationFilter,
IDateTimeService dateTime, IMapper mapper, IMessageService messages)
{
_userRep = userRep;
_networkRep = networkRep;
_sensorRep = sensorRep;
_gatewayRep = gatewayRep;
_connectionRep = connectionRep;
_readingRep = readingRep;
_credentials = credentials;
_throttler = throttler;
_connectionService = connectionService;
_vibrationFilter = vibrationFilter;
_dateTime = dateTime;
_mapper = mapper;
_messages = messages;
}
public async static Task ConnectToGatewayDb()
{
//connecting to DB
bool connected = false;
if (Convert.ToBoolean(ConfigurationManager.AppSettings["UseDB"]))
{
Console.WriteLine("Connecting to gateway database... ");
string connectionString = ConfigurationManager.ConnectionStrings["DbConnection"].ConnectionString;
gatewayDb = new GatewayRepositoryDapper(connectionString);
gatewayDb.SetWriteInterval(Convert.ToInt32(ConfigurationManager.AppSettings["WritingToDbInterwal"]));
gatewayDb.ShowDebugInConsole(Convert.ToBoolean(ConfigurationManager.AppSettings["ShowDBDebug"]));
gatewayDb.SetStoreTxRxMessages(Convert.ToBoolean(ConfigurationManager.AppSettings["StoreTxRxMessagesInDB"]));
while (!connected)
{
gatewayDb.ConnectToGateway(gateway);
connected = (gatewayDb.IsDbExist());
if (!connected) await Task.Delay(5000);
}
}
}
public TasksController()
{
string cs = ConfigurationManager.ConnectionStrings["GatewayDbConnection"].ConnectionString;
gatewayDb = new GatewayRepositoryDapper(cs);
tasksDb = new SensorsTasksRepositoryDapper(cs);
}
public GatewayController(IGatewayRepository gatewayRepository, ILogger <GatewayController> logger)
{
_context = gatewayRepository;
_logger = logger;
}
public TasksController()
{
gatewayDb = SerialController.gatewayDb;
tasksDb = SerialController.sensorsTasksDb;
}
public GatewayService(IGatewayRepository repository, IMapper mapper) : base(repository, mapper)
{
}
public GatewayBusiness(GatewayRepository _repo)
{
repo = _repo;
}
public UpdateGatewayPageAnswerRequestHandler(IApplyRepository applyRepository, IGatewayRepository gatewayRepository, IAuditService auditService)
{
_applyRepository = applyRepository;
_gatewayRepository = gatewayRepository;
_auditService = auditService;
}
public HistoryController()
{
string cs = ConfigurationManager.ConnectionStrings["GatewayDbConnection"].ConnectionString;
historyDb = new SensorsHistoryRepositoryDapper(cs);
gatewayDb = new GatewayRepositoryDapper(cs);
}
public NewGatewayApplicationsHandler(IGatewayRepository repository)
{
_repository = repository;
}
public GatewayService(IGatewayRepository gatewayRepository, IUnitOfWork unitOfWork, IDeviceService deviceService)
{
_gatewayRepository = gatewayRepository;
_unitOfWork = unitOfWork;
_deviceService = deviceService;
}
public static void ConnectToDB()
{
//connecting to DB
if (!dataBaseEnabled) return;
OnDebugStateMessage("DATABASE: Connecting... ");
if (dataBaseConnectionString == null)
{
OnDebugStateMessage("DATABASE: Connection failed. Set ConnectionString in appsettings.json file.");
return;
}
gatewayDb = new GatewayRepositoryDapper(dataBaseConnectionString);
historyDb = new SensorsHistoryRepositoryDapper(dataBaseConnectionString);
sensorsTasksDb = new SensorsTasksRepositoryDapper(dataBaseConnectionString);
sensorsLinksDb = new SensorsLinksRepositoryDapper(dataBaseConnectionString);
//todo logicalNodesRepository = new logicalNodesRepositoryDapper(dataBaseConnectionString);
gatewayDb.SetWriteInterval(dataBaseWriteInterval);
gatewayDb.ShowDebugInConsole(dataBaseDebugState);
gatewayDb.SetStoreTxRxMessages(dataBaseWriteTxRxMessages);
gatewayDb.ConnectToGateway(gateway);
historyDb.SetWriteInterval(dataBaseWriteInterval);
historyDb.ConnectToGateway(gateway);
OnDebugStateMessage("DATABASE: Connected");
}
public StorageGatewayProxyService(IGatewayRepository repository, GatewayService instance)
{
_repository = repository;
_instance = instance;
}
public GatewayService(IGatewayRepository gatewayRepository, IPeripheralRepository peripheralRepository, IMapper mapper)
{
this.gatewayRepository = gatewayRepository;
this.peripheralRepository = peripheralRepository;
this.mapper = mapper;
}
public GatewaysController(IGatewayRepository repository)
{
_repository = repository;
}
public DashboardService(IMapper mapper, IGatewayRepository gatewayRepository, ILogger logger) : base(mapper, gatewayRepository, logger)
{
}
public UpdateExternalApiCheckDetailsHandler(IApplyRepository applyRepository, IGatewayRepository gatewayRepository)
{
_applyRepository = applyRepository;
_gatewayRepository = gatewayRepository;
}
public UserService(IMapper mapper, IGatewayRepository gatewayRepository, ILogger logger, IImageAttachmentStorageRepository imageAttachmentStorageRepository) : base(mapper, gatewayRepository, logger)
{
_imageAttachmentStorageRepository = imageAttachmentStorageRepository;
}
public GatewayService(IGatewayRepository repo, IUnitOfWork unitOfWork)
{
_repo = repo;
_unitOfWork = unitOfWork;
}
public UpdateGatewayReviewStatusAsClarificationHandler(IApplyRepository applyRepository, IGatewayRepository gatewayRepository)
{
_applyRepository = applyRepository;
_gatewayRepository = gatewayRepository;
}
public LinksController()
{
gatewayDb = SerialController.gatewayDb;
linksDb = SerialController.sensorsLinksDb;
}
public GetGatewayApplicationsCountsHandler(IGatewayRepository repository)
{
_repository = repository;
}
public NodeController()
{
gatewayDb = SerialController.gatewayDb;
historyDb = SerialController.historyDb;
}
public InvoiceService(IMapper mapper, IGatewayRepository gatewayRepository, ILogger logger) : base(mapper, gatewayRepository, logger)
{
}
public InProgressGatewayApplicationsHandler(IGatewayRepository repository)
{
_repository = repository;
}
