public DevicesController(
IDeviceCommunicationService deviceCommunicationService,
DeviceCommunicationExtJsWeb.GpsCommunicationService.IGpsCommunicationContract gpsCommunicationContract,
IDeviceRepository deviceRepository,
IPacketRepository packetRepository,
IEventRepository eventRepository,
ICurrentEventRepository currentEventRepository,
IRequstAckCommandRepository requstAckCommandRepository,
ICacheDataRepository cacheDataRepository,
IDeviceStateDocuments deviceStateDocuments,
IDailyMileageRepository dailyMileageRepository,
IGeoPointRepository geoPointRepository,
ILogDocuments logDocuments)
{
DeviceCommunicationService = deviceCommunicationService;
DeviceRepository = deviceRepository;
PacketRepository = packetRepository;
EventRepository = eventRepository;
CurrentEventRepository = currentEventRepository;
RequstAckCommandRepository = requstAckCommandRepository;
CacheDataRepository = cacheDataRepository;
DeviceStateDocuments = deviceStateDocuments;
GpsCommunicationContract = gpsCommunicationContract;
DailyMileageRepository = dailyMileageRepository;
GeoPointRepository = geoPointRepository;
LogDocuments = logDocuments;
}
/// <summary>
/// Initializes a new instance of the <see cref="WhiteNoise.Storage.DatabaseWorker"/> class.
/// </summary>
/// <param name='repository'>
/// Repository.
/// </param>
public DatabaseWorker(IPacketRepository repository)
{
_repository = repository;
this._deviceFiles = new List<ICaptureDevice>();
this.Version = SharpPcap.Version.VersionString;
this.WorkerReportsProgress = true;
this.WorkerSupportsCancellation = true;
}
public HomeController(IDeviceRepository deviceRepository,
IPacketRepository packetRepository,
IDeviceStateDocuments deviceStateDocuments,
ILogDocuments logDocuments)
{
DeviceRepository = deviceRepository;
PacketRepository = packetRepository;
DeviceStateDocuments = deviceStateDocuments;
LogDocuments = logDocuments;
}
public UpdatePacketValidator(IPacketRepository packetRepository, IVersionRepository versionRepository)
{
RuleFor(x => x.PacketUid).MustAsync(async(x, cancellation) => {
return(await packetRepository.PacketWithUidExists(x));
}).WithMessage(ErrorCodes.PacketDoesNotExist);
RuleFor(x => new { currentVersion = x.CurrentVersion.VersionCode, packetUid = x.PacketUid }).MustAsync(async(x, cancellation) => {
if (x.currentVersion == 0)
{
return(true);
}
return(await versionRepository.PacketVersionExists(x.packetUid, x.currentVersion));
}).WithMessage(ErrorCodes.CurrentVersionDoesNotExist);
RuleFor(x => new { currentVersion = x.PacketVersion.VersionCode, packetUid = x.PacketUid }).MustAsync(async(x, cancellation) => {
return(await versionRepository.PacketVersionExists(x.packetUid, x.currentVersion));
}).WithMessage(ErrorCodes.VersionDoesNotExist);
}
public Handler(IPacketRepository packetRepository)
{
PacketRepository = packetRepository;
}
