public SqlServerRepository(IConnectionFactory connectionFactory,
IEnvironmentCheckRepository environmentCheckRepository, IReportRepository reportRepository,
IAnalyticsRepository analyticsRepository, IFileLatencyRepository fileLatencyRepository,
IResourceServerRepository resourceServerRepository,
IDeploymentRepository deploymentRepository,
IPerformanceSummaryRepository performanceSummaryRepository, IConfigurationRepository configurationRepository,
IPrimarySqlServerRepository primarySqlServerRepository, IServerRepository performanceServerRepository,
IAgentRepository agentRepository, ISampleHistoryRepository sampleHistoryRepository,
IBackfillRepository backfillRepository, IEventRepository eventRepository, ILogRepository logRepository,
IProcessControlRepository processControlRepository, IConfigurationAuditRepository configurationAuditRepository)
{
this.connectionFactory = connectionFactory;
_dataRepositories.AddRange(new IDbRepository[]
{
ReportRepository = reportRepository,
EnvironmentCheckRepository = environmentCheckRepository,
AnalyticsRepository = analyticsRepository,
FileLatencyRepository = fileLatencyRepository,
PDBNotificationRepository = new PDBNotificationRepository(this.connectionFactory),
ResourceServerRepository = resourceServerRepository,
DeploymentRepository = deploymentRepository,
PerformanceSummaryRepository = performanceSummaryRepository,
ConfigurationRepository = configurationRepository,
PrimarySqlServerRepository = primarySqlServerRepository,
PerformanceServerRepository = performanceServerRepository,
AgentRepository = agentRepository,
SampleHistoryRepository = sampleHistoryRepository,
BackfillRepository = backfillRepository,
EventRepository = eventRepository,
LogRepository = logRepository,
ProcessControlRepository = processControlRepository,
ConfigurationAuditRepository = configurationAuditRepository
});
}
private async Task PersistBufferAsync(List <AnalyticsItem> buffer)
{
if (0 == buffer.Count)
{
return;
}
using (IServiceScope serviceScope = this.ServiceProvider.CreateScope())
{
IAnalyticsRepository repository = serviceScope.ServiceProvider.GetRequiredService <IAnalyticsRepository>();
try
{
await repository.StoreAsync(buffer, CancellationToken.None);
this.Logger.LogTrace($"AnalyticsItems persisted in repository.");
}
catch (Exception storageError)
{
try
{
await repository?.HandleErrorAsync(buffer, storageError);
}
catch (Exception errorHandlerError)
{
this.Logger.LogError(errorHandlerError, $"Repository '{repository.GetType().FullName}' failed to handle error.");
}
}
finally
{
buffer.Clear();
}
}
}
/// <summary>
/// Creates a new instance of <see cref="ReportAnalyzer" />.
/// </summary>
/// <param name="hashCodeGenerator">Used to identify is this is a new unique exception</param>
/// <param name="domainQueue">
/// to publish the
/// <see cref="Coderr.Server.ReportAnalyzer.Abstractions.Incidents.ReportAddedToIncident" /> event
/// </param>
/// <param name="repository">repos</param>
public ReportAnalyzer(IHashCodeGenerator hashCodeGenerator, IAnalyticsRepository repository, IDomainQueue domainQueue, IConfiguration <ReportConfig> reportConfig)
{
_hashCodeGenerator = hashCodeGenerator;
_repository = repository;
_domainQueue = domainQueue;
_reportConfig = reportConfig;
}
public AnalyticsController(IAnalyticsRepository analyticsRepository,
IDayAnalyticsRepository dayAnalyticsRepository, IPanelRepository panelRepository)
{
_analyticsRepository = analyticsRepository;
_dayAnalyticsRepository = dayAnalyticsRepository;
_panelRepository = panelRepository;
}
/// <summary>
/// Creates a new instance of <see cref="ReportAnalyzer" />.
/// </summary>
/// <param name="hashCodeGenerator">Used to identify is this is a new unique exception</param>
/// <param name="messageBus">to publish the <see cref="ReportAddedToIncident" /> event</param>
/// <param name="repository">repos</param>
public ReportAnalyzer(HashCodeGenerator hashCodeGenerator, IMessageBus messageBus,
IAnalyticsRepository repository)
{
_hashCodeGenerator = hashCodeGenerator;
_messageBus = messageBus;
_repository = repository;
}
public AnalyticsControllerTest(IPanelRepository panelRepositoryMock, IAnalyticsRepository analyticsRepository, IDayAnalyticsRepository dayAnalyticsRepository)
{
_panelRepositoryMock = panelRepositoryMock;
_analyticsRepository = analyticsRepository;
_dayAnalyticsRepository = dayAnalyticsRepository;
_controller = new AnalyticsController(_analyticsRepository, _panelRepositoryMock, _dayAnalyticsRepository);
}
public CategoryContextExtension(
ICatalogRepository catalogRepository,
IAnalyticsRepository analyticsRepository,
IConfigurationResolver configurationResolver) : base(configurationResolver)
{
this.catalogRepository = catalogRepository;
this.analyticsRepository = analyticsRepository;
}
private void ResetRepositories()
{
_transactionRepository = null;
_accountRepository = null;
_analyticsRepository = null;
_expenditureRepository = null;
_reportRepository = null;
_mappingRepository = null;
}
public AnalyticsControllerTests() : base()
{
var contextOpions = new DbContextOptionsBuilder <CrossSolarDbContext>().UseSqlServer(ConnectionString).Options;
var context = new CrossSolarDbContext(contextOpions);
_anlticsReposiitory = new AnalyticsRepository(context);
_panelRepository = new PanelRepository(context);
_anlyticsController = new AnalyticsController(_anlticsReposiitory, _panelRepository);
_panelController = new PanelController(_panelRepository);
}
public AnalyticsControllerTest()
{
_analyticsRepository = new MockedAnalyticsRepository();
_panelRepositoryMock = new MockPanelRepository();
_dayAnalyticsRepository = new MockedDayAnalyticsRepository();
_analyticsController = new AnalyticsController(_analyticsRepository, _panelRepositoryMock, _dayAnalyticsRepository);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
using (IServiceScope serviceScope = this.ServiceProvider.CreateScope())
{
IAnalyticsRepository repository = serviceScope.ServiceProvider.GetRequiredService <IAnalyticsRepository>();
await repository.InitializeAsync();
}
for (int loop = 0; loop < this.Options.ProcessorThreadCount; loop++)
{
this.Logger.LogInformation($"Starting queue processor instance {loop}.");
this.ProcessorTasks[loop] = Task.Run(async() => { await this.ProcessItemsAsync(); });
}
}
/// <summary>
/// Constructor of the class.
/// </summary>
public AnalyticsControllerTests()
{
// Using 'UseInMemoryDatabase' instead of throwing the repository, avoiding EF limitations and asynchronous returns.
options = new DbContextOptionsBuilder <CrossSolarDbContext>()
.UseInMemoryDatabase(databaseName: "CrossSolarDbInMemory").Options;
context = new CrossSolarDbContext(options);
_panelRepository = new PanelRepository(context);
_analyticsRepository = new AnalyticsRepository(context);
_dayAnalyticsRepository = new DayAnalyticsRepository(context);
_analyticsController = new AnalyticsController(_analyticsRepository, _dayAnalyticsRepository, _panelRepository);
}
/// <summary>
/// Creates a new instance of <see cref="ReportAnalyzer" />.
/// </summary>
/// <param name="hashCodeGenerator">Used to identify is this is a new unique exception</param>
/// <param name="messageBus">
/// to publish the
/// <see cref="Coderr.Server.ReportAnalyzer.Abstractions.Incidents.ReportAddedToIncident" /> event
/// </param>
/// <param name="repository">repos</param>
public ReportAnalyzer(IHashCodeGenerator hashCodeGenerator, IAnalyticsRepository repository, IDomainQueue domainQueue)
{
_hashCodeGenerator = hashCodeGenerator;
_repository = repository;
_domainQueue = domainQueue;
}
public xDBContactService(IAnalyticsRepository<Contact> repository, IApplicationSettings appSettings)
{
_repository = repository;
_appSettings = appSettings;
}
/// <summary>
/// Creates a new instance of <see cref="ReportAnalyzer" />.
/// </summary>
/// <param name="hashCodeGenerator">Used to identify is this is a new unique exception</param>
/// <param name="eventBus">to publish the <see cref="ReportAddedToIncident" /> event</param>
/// <param name="repository">repos</param>
public ReportAnalyzer(HashCodeGenerator hashCodeGenerator, IEventBus eventBus, IAnalyticsRepository repository)
{
_hashCodeGenerator = hashCodeGenerator;
_eventBus = eventBus;
_repository = repository;
}
public static AnalyticsBuilder UseServerAnalytics(this IApplicationBuilder app, IAnalyticsRepository repository, ILogger logger)
{
var builder = new AnalyticsBuilder(repository, logger);
app.Use(builder.Run);
return(builder);
}
public xDBContactService(IAnalyticsRepository <Contact> repository, IApplicationSettings appSettings)
{
_repository = repository;
_appSettings = appSettings;
}
public GetAnalyticsHandler(IUnitOfWork unitOfWork)
{
_analyticsRepo = unitOfWork.AnalyticsRepo;
}
public xDBInteractionService(IAnalyticsRepository <Interaction> repository, IApplicationSettings appSettings)
{
_repository = repository;
_appSettings = appSettings;
}
internal AnalyticsBuilder(IAnalyticsRepository analyticsRepository, ILogger logger)
{
_geoDataExtractor = new IpApiService();
_repository = analyticsRepository;
_logger = logger;
}
public EmotionAnalyticsService(IAnalyticsRepository analyticsRepository)
{
this.analyticsRepository = analyticsRepository;
}
private void SetUpMockRepositories()
{
var panels = new[]
{
new Panel
{
Brand = "TikTak",
Latitude = 22.345678,
Longitude = 58.7655432,
Serial = "SSSS22225555TTTT"
}
}.AsQueryable();
var mockSet = new Mock <DbSet <Panel> >();
mockSet.As <IAsyncEnumerable <Panel> >()
.Setup(m => m.GetEnumerator())
.Returns(new TestAsyncEnumerator <Panel>(panels.GetEnumerator()));
mockSet.As <IQueryable <Panel> >()
.Setup(m => m.Provider)
.Returns(new TestAsyncQueryProvider <Panel>(panels.Provider));
mockSet.As <IQueryable <Panel> >().Setup(m => m.Expression).Returns(panels.Expression);
mockSet.As <IQueryable <Panel> >().Setup(m => m.ElementType).Returns(panels.ElementType);
mockSet.As <IQueryable <Panel> >().Setup(m => m.GetEnumerator()).Returns(() => panels.GetEnumerator());
var contextOptions = new DbContextOptions <CrossSolarDbContext>();
var mockContext = new Mock <CrossSolarDbContext>(contextOptions);
mockContext.Setup(c => c.Set <Panel>()).Returns(mockSet.Object);
_panelRepository = new PanelRepository(mockContext.Object);
_oneHrElectricities = new[]
{
new OneHourElectricity
{
Id = 1,
PanelId = "SSSS22225555TTTT",
DateTime = DateTime.Now,
KiloWatt = 240
},
new OneHourElectricity
{
Id = 2,
PanelId = "SSSS22225555TTTT",
DateTime = DateTime.Now.AddDays(1),
KiloWatt = 2400
}
};
var oneHrElectricitiesQueryable = _oneHrElectricities.AsQueryable();
var analyticsMockSet = new Mock <DbSet <OneHourElectricity> >();
analyticsMockSet.As <IAsyncEnumerable <OneHourElectricity> >()
.Setup(m => m.GetEnumerator())
.Returns(new TestAsyncEnumerator <OneHourElectricity>(oneHrElectricitiesQueryable.GetEnumerator()));
analyticsMockSet.As <IQueryable <Panel> >()
.Setup(m => m.Provider)
.Returns(new TestAsyncQueryProvider <OneHourElectricity>(panels.Provider));
analyticsMockSet.As <IQueryable <OneHourElectricity> >().Setup(m => m.Expression).Returns(oneHrElectricitiesQueryable.Expression);
analyticsMockSet.As <IQueryable <OneHourElectricity> >().Setup(m => m.ElementType).Returns(oneHrElectricitiesQueryable.ElementType);
analyticsMockSet.As <IQueryable <OneHourElectricity> >().Setup(m => m.GetEnumerator()).Returns(() => oneHrElectricitiesQueryable.GetEnumerator());
mockContext.Setup(c => c.Set <OneHourElectricity>()).Returns(analyticsMockSet.Object);
_oneHrElectricityRepository = new AnalyticsRepository(mockContext.Object);
}
public AnalyticsService(IAnalyticsRepository analyticsRepository)
{
this.analyticsRepository = analyticsRepository;
}
public xDBInteractionService(IAnalyticsRepository<Interaction> repository, IApplicationSettings appSettings)
{
_repository = repository;
_appSettings = appSettings;
}
public DataReader(ILogger <DataReader> logger, IAnalyticsRepository repository)
{
this._logger = logger;
_repository = repository;
}
internal AnalyticsBuilder(IAnalyticsRepository analyticsRepository)
{
_geoDataExtractor = new IpApiService();
_repository = analyticsRepository;
}
