public MeasurementController(DashboardRepository dashboardRepository, IHubContext <SensorHub> hub, IDistributedCache cache, MeasurementRepository measurementRepository)
{
this.hub = hub;
this.cache = cache;
this.measurementRepository = measurementRepository;
this.dashboardRepository = dashboardRepository;
}
public UnitOfWork(bastelei_ws context)
{
_context = context;
Probes = new ProbeRepository(_context);
Measurements = new MeasurementRepository(_context);
Users = new UserRepository(_context);
}
public static Installation ConverttoEntity(InstallationModel ininstallation)
{
Installation installation = null;
try
{
CustomerRepository crepo = new CustomerRepository();
MeasurementRepository mrepo = new MeasurementRepository();
installation = new Installation();
installation.customerid = ininstallation.customerid;
installation.installationid = ininstallation.installationid;
installation.latitude = ininstallation.latitude;
installation.longitude = ininstallation.longitude;
installation.description = ininstallation.description;
installation.serialno = ininstallation.serialno;
//installation.Customer = ConvertCustomer.ConverttoEntity(crepo.GetById(installation.customerid));
foreach (var item in ininstallation.Measurement)
{
installation.Measurement.Add(ConvertMeasurement.ConverttoEntity(mrepo.GetById(item)));
}
log.Info("InstallationModel wurde konvertiert.");
}
catch (Exception exp)
{
log.Error("InstallationModel konnte nicht konvertiert werden.");
throw new DalException("InstallationModel konnte nicht konvertiert werden.", exp);
}
return installation;
}
public MeasurementReportsController(MonthRepository monthRepository, ReceiptRepository receiptRepository, MeasurementRepository measurementRepository, IHttpClientFactory clientFactory)
{
_clientFactory = clientFactory;
_monthRepository = monthRepository;
_receiptRepository = receiptRepository;
_measurementRepository = measurementRepository;
}
public virtual void Update()
{
IRepository <Measurement> repo = new MeasurementRepository();
this.updated_at = DateTime.Now;
repo.Update(this);
}
static void Main(string[] args)
{
// Ikke akkurat dependency injection
using (var context = new TellerContext())
{
var eventRepo = new EventRepository(context);
var measurementRepo = new MeasurementRepository(context);
var eventFetcher = new FilesystemEventDataFetcher();
var measurementReader = new MeasurementReader();
var fileArchiver = new FileArchiver();
var ingestor = new MeasurementIngestor(eventRepo, measurementRepo, eventFetcher, measurementReader, fileArchiver);
ingestor.ReadAndIngestData();
}
using (var context = new TellerContext())
{
var eventRepo = new EventRepository(context);
var allEvents = eventRepo.GetAll()
.ToList();
var test = new RenderTest();
foreach (var bsEvent in allEvents)
{
test.Render(bsEvent);
}
}
}
public ServiceMethods()
{
client = new HttpClient();
measurementsRepository = new MeasurementRepository();
timer = new System.Timers.Timer();
timer.Elapsed += async(_, __) => await GetMeasurementAndAddToDbAsync();
timer.Interval = 10000;
timer.Enabled = true;
}
public ReceiptController(ReceiptRepository receiptRepository,
ContractRepository contractRepository,
MeasurementRepository measurementRepository,
ChargeRepository chargeRepository)
{
_receiptRepository = receiptRepository;
_contractRepository = contractRepository;
_measurementRepository = measurementRepository;
_chargeRepository = chargeRepository;
}
public AspMqttClient(IMqttClientOptions options, IDistributedCache cache)
{
this.measurementRepository = new MeasurementRepository();
this.cache = cache;
this.options = options;
client = new MqttFactory().CreateManagedMqttClient();
managedOptionsBuilder = new ManagedMqttClientOptionsBuilder()
.WithClientOptions(this.options);
client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(OnReceivedApplicationMessage);
}
public MeasurementsController(MeasurementRepository measurementRepository, MonthRepository monthRepository, SystemUserRepository systemUserRepository) : base(measurementRepository)
{
_monthRepository = monthRepository;
_systemUserRepository = systemUserRepository;
_measurementRepository = measurementRepository;
}
static void Main(string[] args)
{
var sw = new Stopwatch();
sw.Start();
SetupTraceListeners();
List <BillettServiceEvent> updatedEvents;
// Ikke akkurat dependency injection
using (var context = new TellerContext())
{
var eventRepo = new EventRepository(context);
var measurementRepo = new MeasurementRepository(context);
var eventFetcher = new FilesystemEventDataFetcher();
var measurementReader = new MeasurementReader();
var fileArchiver = new FileArchiver();
var ingestor = new MeasurementIngestor(eventRepo, measurementRepo, eventFetcher, measurementReader, fileArchiver);
updatedEvents = ingestor.ReadAndIngestData().ToList();
}
Trace.TraceInformation("{0} events updated: {1}", updatedEvents.Count, String.Join(", ", updatedEvents.Select(e => e.EventNumber)));
using (var context = new TellerContext())
{
var eventRepo = new EventRepository(context);
var allEvents = eventRepo.GetAll()
//.Where(e => updatedEvents.Any(ue => ue.EventNumber == e.EventNumber))
.ToList();
var missingFileEvents =
allEvents.Where(
ev =>
!File.Exists(Path.Combine(StautConfiguration.Current.StaticImageDirectory,
ev.EventNumber + ".png")))
.ToList();
var eventsToRender =
missingFileEvents.Concat(
allEvents.Where(
ae =>
!missingFileEvents.Contains(ae) &&
updatedEvents.Any(ue => ue.EventNumber == ae.EventNumber))).ToList();
var test = new RenderTest();
foreach (var bsEvent in eventsToRender)
{
test.Render(bsEvent);
}
}
sw.Stop();
Trace.TraceInformation("Ingest process complete, took {0}ms", sw.ElapsedMilliseconds);
Trace.Flush();
Trace.Close();
}
public DashboardController(ReceiptRepository receiptRepository, MeasurementRepository measurementRepository, MonthRepository monthRepository)
{
_measurementRepository = measurementRepository;
_receiptRepository = receiptRepository;
_monthRepository = monthRepository;
}
public TRepository GetRepository <TRepository>(IUnitOfWork unitOfWork)
where TRepository : class
{
if (typeof(TRepository) == typeof(IBedRepository))
{
dynamic repo = new BedRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IRoomRepository))
{
dynamic repo = new RoomRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IOutletRepository))
{
dynamic repo = new OutletRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(ICustomerRepository))
{
dynamic repo = new CustomerRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(ITherapistRepository))
{
dynamic repo = new TherapistRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IServiceRepository))
{
dynamic repo = new ServiceRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IService_BedRepository))
{
dynamic repo = new Service_BedRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IAppoitmentDetailRepository))
{
dynamic repo = new AppoitmentDetailRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IReviewOutletRepository))
{
dynamic repo = new ReviewOutletRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(ITimeSlotRepository))
{
dynamic repo = new TimeSlotRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IReviewOutletRepository))
{
dynamic repo = new ReviewOutletRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IBufferTimeRepository))
{
dynamic repo = new BufferTimeRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IAppoitmentRepository))
{
dynamic repo = new AppoitmentRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IOutlet_StaffRepository))
{
dynamic repo = new Outlet_StaffRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IMeasurementRepository))
{
dynamic repo = new MeasurementRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IServiceTypeRepository))
{
dynamic repo = new ServiceTypeRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
if (typeof(TRepository) == typeof(IReviewServiceRepository))
{
dynamic repo = new ReviewServiceRepository();
repo.UnitOfWork = unitOfWork;
return((TRepository)repo);
}
TRepository repository = null;
return(repository);
}
public MeasurementController(MeasurementRepository measurementRepository)
{
_repository = measurementRepository;
}
public MeasurementManager(AppDatabaseContext context)
{
this.rep = new MeasurementRepository(context);
}
public virtual Measurement GetByDateUTC(Station station, int YYYY, int MM, int DD, int GG)
{
MeasurementRepository repo = new MeasurementRepository();
return(repo.GetByDate(station, YYYY, MM, DD, GG));
}
public MeasurementReciever()
{
_measurementRepo = new MeasurementRepository();
}
public MeasurementServiceTest()
{
var measurementRepository = new MeasurementRepository(_context);
_measurementService = new MeasurementService(measurementRepository);
}
public MeasurementService(MeasurementRepository measurementRepository)
{
_measurementRepository = measurementRepository;
}