892 lines
32 KiB
C#
892 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using skyscraper5.Docsis.MacManagement;
|
|
using skyscraper5.DsmCc.Descriptors;
|
|
using skyscraper5.Dvb.DataBroadcasting.IntModel;
|
|
using skyscraper5.Dvb.DataBroadcasting.SkyscraperVfs;
|
|
using skyscraper5.Dvb.Descriptors;
|
|
using skyscraper5.Dvb.Psi.Model;
|
|
using skyscraper5.Dvb.SystemSoftwareUpdate.Model;
|
|
using skyscraper5.Dvb.TvAnytime;
|
|
using skyscraper5.Mhp.Si;
|
|
using skyscraper5.Mhp.Si.Model;
|
|
using skyscraper5.Mpeg2.Descriptors;
|
|
using skyscraper5.Mpeg2.Psi.Model;
|
|
using skyscraper5.Rds.Messages;
|
|
using skyscraper5.Scte35;
|
|
using skyscraper5.Skyscraper.Equipment;
|
|
using skyscraper5.Skyscraper.Gps;
|
|
using skyscraper5.Skyscraper.Headless;
|
|
using skyscraper5.Skyscraper.IO.CrazycatStreamReader;
|
|
using skyscraper5.Skyscraper.Scraper.Storage.Utilities;
|
|
using skyscraper5.src.InteractionChannel.Model;
|
|
using skyscraper5.src.InteractionChannel.Model.Descriptors;
|
|
using skyscraper5.src.Skyscraper.FrequencyListGenerator;
|
|
using skyscraper5.src.Skyscraper.Scraper.Dns;
|
|
using skyscraper5.Teletext;
|
|
using skyscraper8.Ses;
|
|
using Platform = skyscraper5.Dvb.SystemSoftwareUpdate.Model.Platform;
|
|
|
|
namespace skyscraper5.Skyscraper.Scraper.Storage.Split
|
|
{
|
|
public class SplitScraperStorage : IScraperStroage
|
|
{
|
|
private readonly DataStorage dataStorage;
|
|
private readonly ObjectStorage objectStorage;
|
|
|
|
public SplitScraperStorage(DataStorage dataStorage, ObjectStorage objectStorage)
|
|
{
|
|
this.dataStorage = dataStorage;
|
|
this.objectStorage = objectStorage;
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForNitNetwork(NitNetwork nitNetwork)
|
|
{
|
|
return dataStorage.TestForNitNetwork(nitNetwork);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreNitNetwork(NitNetwork nitNetwork)
|
|
{
|
|
dataStorage.StoreNitNetwork(nitNetwork);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateNitNetwork(NitNetwork nitNetwork)
|
|
{
|
|
return dataStorage.UpdateNitNetwork(nitNetwork);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForNitTransportStream(ushort networkId, NitTransportStream transportStream)
|
|
{
|
|
return dataStorage.TestForNitTransportStream(networkId, transportStream);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreNitTransportStream(ushort networkId, NitTransportStream transportStream)
|
|
{
|
|
dataStorage.StoreNitTransportStream(networkId, transportStream);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateNitTransportStream(ushort networkId, NitTransportStream transportStream)
|
|
{
|
|
return dataStorage.UpdateNitTransportStream(networkId, transportStream);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool StorePatEntry(int currentNetworkId, int currentTransportStreamId, int pmtPid, ushort programId)
|
|
{
|
|
return dataStorage.StorePatEntry(currentNetworkId, currentTransportStreamId, pmtPid, programId);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForPmtEvent(int currentNetworkId, int currentTransportStreamId, ProgramMapping result)
|
|
{
|
|
return dataStorage.TestForPmtEvent(currentNetworkId, currentTransportStreamId, result);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool StorePmtEvent(int currentNetworkId, int currentTransportStreamId, ProgramMapping mapping)
|
|
{
|
|
return dataStorage.StorePmtEvent(currentNetworkId, currentTransportStreamId, mapping);
|
|
}
|
|
|
|
public bool StoreTeletextPage(int networkId, int transportStreamId, ushort programNumber, TeletextMagazine magazine, DateTime timestamp)
|
|
{
|
|
if (magazine.HumanReadablePageNumber > 999)
|
|
return false;
|
|
|
|
return dataStorage.StoreTeletextPage(networkId, transportStreamId, programNumber, magazine, timestamp);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForSdtService(ushort transportStreamId, ushort originalNetworkId, SdtService sdtService)
|
|
{
|
|
return dataStorage.TestForSdtService(transportStreamId, originalNetworkId, sdtService);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateSdtService(ushort transportStreamId, ushort originalNetworkId, SdtService sdtService)
|
|
{
|
|
return dataStorage.UpdateSdtService(transportStreamId, originalNetworkId, sdtService);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreSdtService(ushort transportStreamId, ushort originalNetworkId, SdtService sdtService)
|
|
{
|
|
dataStorage.StoreSdtService(transportStreamId, originalNetworkId, sdtService);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForBatBouquet(BatBouquet batBouquet)
|
|
{
|
|
return dataStorage.TestForBatBouquet(batBouquet);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateBatBouquet(BatBouquet batBouquet)
|
|
{
|
|
return dataStorage.UpdateBatBouquet(batBouquet);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreBatBouquet(BatBouquet batBouquet)
|
|
{
|
|
dataStorage.StoreBatBouquet(batBouquet);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForBatTransportStream(ushort batBouquetBouquetId, BatTransportStream child)
|
|
{
|
|
return dataStorage.TestForBatTransportStream(batBouquetBouquetId, child);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateBatTransportStream(ushort batBouquetBouquetId, BatTransportStream child)
|
|
{
|
|
return dataStorage.UpdateBatTransportStream(batBouquetBouquetId, child);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreBatTransportStream(ushort batBouquetBouquetId, BatTransportStream child)
|
|
{
|
|
dataStorage.StoreBatTransportStream(batBouquetBouquetId, child);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateTimeOffsetTable(int currentNetworkId, int currentTransportStreamId, DateTime utcTime, LocalTimeOffsetDescriptor ltod)
|
|
{
|
|
return dataStorage.UpdateTimeOffsetTable(currentNetworkId, currentTransportStreamId, utcTime, ltod);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateTimeAndDate(int currentNetworkId, int currentTransportStreamId, DateTime utcTime)
|
|
{
|
|
return dataStorage.UpdateTimeAndDate(currentNetworkId, currentTransportStreamId, utcTime);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool StoreEitEvent(EitEvent eitEvent)
|
|
{
|
|
return dataStorage.StoreEitEvent(eitEvent);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForAitApplication(ApplicationIdentifier aitApplicationApplicationIdentifier)
|
|
{
|
|
return dataStorage.TestForAitApplication(aitApplicationApplicationIdentifier);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreAitApplication(AitApplication aitApplication)
|
|
{
|
|
dataStorage.StoreAitApplication(aitApplication);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool ObjectCarouselFileArrival(VfsFile vfsFile, int transportStreamId, int networkId)
|
|
{
|
|
return objectStorage.ObjectCarouselFileArrival(vfsFile, transportStreamId, networkId);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForCaSystem(int currentNetworkId, int currentTransportStreamId, int caDescriptorCaPid)
|
|
{
|
|
return dataStorage.TestForCaSystem(currentNetworkId, currentTransportStreamId, caDescriptorCaPid);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreCaSystem(int currentNetworkId, int currentTransportStreamId, CaDescriptor caDescriptor)
|
|
{
|
|
dataStorage.StoreCaSystem(currentNetworkId, currentTransportStreamId, caDescriptor);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreUpdateNotification(int hashCode, UpdateNotificationGroup common, Compatibility compatibility, Platform platform)
|
|
{
|
|
dataStorage.StoreUpdateNotification(hashCode, common, compatibility, platform);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void DataCarouselModuleArrival(int currentNetworkId, int currentTransportStreamId, int elementaryPid, ushort moduleModuleId, byte moduleModuleVersion, Stream result)
|
|
{
|
|
objectStorage.DataCarouselModuleArrival(currentNetworkId, currentTransportStreamId, elementaryPid, moduleModuleId, moduleModuleVersion, result);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForKnownRdsData(int currentNetworkId, int currentTransportStreamId, int programNumber)
|
|
{
|
|
return dataStorage.TestForKnownRdsData(currentNetworkId, currentTransportStreamId, programNumber);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void EnableRdsCollection(int currentNetworkId, int currentTransportStreamId, int programNumber)
|
|
{
|
|
dataStorage.EnableRdsCollection(currentNetworkId, currentTransportStreamId, programNumber);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateRdsProgrammeServiceName(int currentNetworkId, int currentTransportStreamId, int programNumber, string programmeService2)
|
|
{
|
|
return dataStorage.UpdateRdsProgrammeServiceName(currentNetworkId, currentTransportStreamId, programNumber, programmeService2);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateRdsRadioText(int currentNetworkId, int currentTransportStreamId, int programNumber, string text)
|
|
{
|
|
return dataStorage.UpdateRdsRadioText(currentNetworkId, currentTransportStreamId, programNumber, text);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UpdateRdsPty(int currentNetworkId, int currentTransportStreamId, int programNumber, PTY.ProgrammeTypeCodes pty)
|
|
{
|
|
return dataStorage.UpdateRdsPty(currentNetworkId, currentTransportStreamId, programNumber, pty);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool MarkAsRdsTrafficInformationProgramme(int currentNetworkId, int currentTransportStreamId, int programNumber)
|
|
{
|
|
return dataStorage.MarkAsRdsTrafficInformationProgramme(currentNetworkId, currentTransportStreamId, programNumber);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForScte35SpliceInsert(int currentNetworkId, int currentTransportStreamId, ushort programNumber, SpliceInsert spliceInsert)
|
|
{
|
|
return dataStorage.TestForScte35SpliceInsert(currentNetworkId, currentTransportStreamId, programNumber, spliceInsert);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreScte35SpliceInsert(int currentNetworkId, int currentTransportStreamId, ushort programNumber, SpliceInsert spliceInsert)
|
|
{
|
|
dataStorage.StoreScte35SpliceInsert(currentNetworkId, currentTransportStreamId, programNumber, spliceInsert);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool IsCompliant(int currentNetworkId, int currentTransportStreamId, string compliance)
|
|
{
|
|
return dataStorage.IsCompliant(currentNetworkId, currentTransportStreamId, compliance);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void MarkAsCompliant(int currentNetworkId, int currentTransportStreamId, string compliance)
|
|
{
|
|
dataStorage.MarkAsCompliant(currentNetworkId, currentTransportStreamId, compliance);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool SetStationIdentification(int currentNetworkId, int currentTransportStreamId, string stationIdentification)
|
|
{
|
|
return dataStorage.SetStationIdentification(currentNetworkId, currentTransportStreamId, stationIdentification);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool IsDsmCcModuleWanted(int currentNetworkId, int currentTransportStreamId, int elementaryPid, ushort moduleId, byte moduleVersion)
|
|
{
|
|
return objectStorage.IsDsmCcModuleWanted(currentNetworkId, currentTransportStreamId, elementaryPid, moduleId, moduleVersion);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreDsmCcDoItNowEvent(DateTime value, int currentNetworkId, int currentTransportStreamId, int programNumber, StreamEventDescriptor descriptorListStreamEventDescriptor, int pid)
|
|
{
|
|
dataStorage.StoreDsmCcDoItNowEvent(value, currentNetworkId, currentTransportStreamId, programNumber, descriptorListStreamEventDescriptor, pid);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool StoreRunningStatus(uint transportStreamId, uint originalNetworkId, uint serviceId, uint eventId, RunningStatus runningStatus, DateTime currentTime)
|
|
{
|
|
return dataStorage.StoreRunningStatus(transportStreamId, originalNetworkId, serviceId, eventId, runningStatus, currentTime);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void SetScte35TimeSignal(int currentNetworkId, int currentTransportStreamId, DateTime currentTime, ushort programNumber, TimeSignal timeSignal)
|
|
{
|
|
dataStorage.SetScte35TimeSignal(currentNetworkId, currentTransportStreamId, currentTime, programNumber, timeSignal);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForFramegrab(int currentNetworkId, int transportStreamId, ushort mappingProgramNumber, int mappingStreamElementaryPid)
|
|
{
|
|
return objectStorage.TestForFramegrab(currentNetworkId, transportStreamId, mappingProgramNumber, mappingStreamElementaryPid);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForIpMacNotification(IpMacNotification notification)
|
|
{
|
|
return dataStorage.TestForIpMacNotification(notification);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreIpMacNotification(IpMacNotification notification)
|
|
{
|
|
dataStorage.StoreIpMacNotification(notification);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool ImportFileKnown(FileInfo fi)
|
|
{
|
|
return dataStorage.ImportFileKnown(fi);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void ImportMarkFileAsKnown(FileInfo fi, TimeSpan timeTaken, int tstype)
|
|
{
|
|
dataStorage.ImportMarkFileAsKnown(fi, timeTaken, tstype);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public DateTime T2MiGetTimestamp(int currentNetworkId, int currentTransportStreamId, int pid)
|
|
{
|
|
return dataStorage.T2MiGetTimestamp(currentNetworkId, currentTransportStreamId, pid);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void T2MiSetTimestamp(int currentNetworkId, int currentTransportStreamId, int pid, DateTime resolveTime)
|
|
{
|
|
dataStorage.T2MiSetTimestamp(currentNetworkId, currentTransportStreamId, pid, resolveTime);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForRelatedContent(EitEvent lEvent, RctLinkInfo rctLinkInfo)
|
|
{
|
|
return dataStorage.TestForRelatedContent(lEvent, rctLinkInfo);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void SetRelatedContent(EitEvent lEvent, RctLinkInfo rctLinkInfo)
|
|
{
|
|
dataStorage.SetRelatedContent(lEvent, rctLinkInfo);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public List<SatellitePosition> UiSatellitesListAll()
|
|
{
|
|
return dataStorage.UiSatellitesListAll();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UiSatellitesAdd(SatellitePosition newPosition)
|
|
{
|
|
dataStorage.UiSatellitesAdd(newPosition);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UiSatellitesDelete(SatellitePosition satellitePosition)
|
|
{
|
|
dataStorage.UiSatellitesDelete(satellitePosition);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool UiTunerTestFor(TunerMetadata tuner)
|
|
{
|
|
return dataStorage.UiTunerTestFor(tuner);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UiTunerUpdate(TunerMetadata tuner)
|
|
{
|
|
dataStorage.UiTunerUpdate(tuner);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UiTunerInsert(TunerMetadata tuner)
|
|
{
|
|
dataStorage.UiTunerInsert(tuner);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UiTunerGetConfiguration(TunerMetadata foundTuner)
|
|
{
|
|
dataStorage.UiTunerGetConfiguration(foundTuner);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreFramegrab(int currentNetworkId, int transportStreamId, ushort mappingProgramNumber, ushort pid, byte[] imageData)
|
|
{
|
|
objectStorage.StoreFramegrab(currentNetworkId, transportStreamId, mappingProgramNumber, pid, imageData);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForDocsisUpstreamChannel(PhysicalAddress mmmSource, uint mmmFrequency, int locationId)
|
|
{
|
|
return dataStorage.TestForDocsisUpstreamChannel(mmmSource, mmmFrequency, locationId);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreDocsisUpstreamChannel(UpstreamChannelDescriptor mmm, int locationId)
|
|
{
|
|
dataStorage.StoreDocsisUpstreamChannel(mmm, locationId);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForDocsisDownstreamChannel(PhysicalAddress physicalAddress, MacDomainDescriptor.DownstreamActiveChannel downstreamActiveChannel, int locationId)
|
|
{
|
|
return dataStorage.TestForDocsisDownstreamChannel(physicalAddress, downstreamActiveChannel,locationId);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreDocsisDownstreamChannel(PhysicalAddress physicalAddress, MacDomainDescriptor.DownstreamActiveChannel downstreamActiveChannel, int locationId)
|
|
{
|
|
dataStorage.StoreDocsisDownstreamChannel(physicalAddress, downstreamActiveChannel,locationId);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool SetCmtsIp(PhysicalAddress arpHeaderSenderHardwareAddress, IPAddress arpHeaderSenderProtocolAddress)
|
|
{
|
|
return dataStorage.SetCmtsIp(arpHeaderSenderHardwareAddress, arpHeaderSenderProtocolAddress);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool IsDsmCcModuleBlacklisted(int currentNetworkId, int currentTransportStreamId, int elementaryPid, ushort moduleId,
|
|
byte moduleVersion)
|
|
{
|
|
return dataStorage.IsDsmCcModuleBlacklisted(currentNetworkId, currentTransportStreamId, elementaryPid, moduleId, moduleVersion);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public int? GetCurrentLocationId()
|
|
{
|
|
return dataStorage.GetCurrentLocationId();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreDocsisParticipant(PhysicalAddress pa, int currentLocation)
|
|
{
|
|
dataStorage.StoreDocsisParticipant(pa, currentLocation);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public HeadlessJob GetQueuedJob()
|
|
{
|
|
return dataStorage.GetQueuedJob();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void SetQueuedJobComplete(HeadlessJob headlessJob)
|
|
{
|
|
dataStorage.SetQueuedJobComplete(headlessJob);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void WaitForCompletion()
|
|
{
|
|
dataStorage.WaitForCompletion();
|
|
objectStorage.WaitForCompletion();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UiSetVersion(int version)
|
|
{
|
|
dataStorage.UiSetVersion(version);
|
|
objectStorage.UiSetVersion(version);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool T2MiTestForTransmitter(int? currentNetworkId, int? currentTransportStreamId, int relatedPid, ushort txIdentifier)
|
|
{
|
|
return dataStorage.T2MiTestForTransmitter(currentNetworkId, currentTransportStreamId, relatedPid, txIdentifier);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void T2MiRememberTransmitter(int? currentNetworkId, int? currentTransportStreamId, int relatedPid, ushort txIdentifier)
|
|
{
|
|
dataStorage.T2MiRememberTransmitter(currentNetworkId, currentTransportStreamId, relatedPid, txIdentifier);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void T2MiSetTransmitterTimeOffset(int? currentNetworkId, int? currentTransportStreamId, int relatedPid, ushort txIdentifier, ushort timeOffset)
|
|
{
|
|
dataStorage.T2MiSetTransmitterTimeOffset(currentNetworkId, currentTransportStreamId, relatedPid, txIdentifier, timeOffset);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public List<LnbType> UiLnbTypesListAll()
|
|
{
|
|
return dataStorage.UiLnbTypesListAll();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UiLnbTypesAdd(LnbType defaultLnbType)
|
|
{
|
|
dataStorage.UiLnbTypesAdd(defaultLnbType);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public List<DishType> UiDishTypesListAll()
|
|
{
|
|
return dataStorage.UiDishTypesListAll();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UiDishTypesAdd(DishType defaultDishType)
|
|
{
|
|
dataStorage.UiDishTypesAdd(defaultDishType);
|
|
}
|
|
|
|
public object[] GetPluginConnector()
|
|
{
|
|
object[] dataConnector = dataStorage.GetPluginConnector();
|
|
object[] objectConnector = objectStorage.GetPluginConnector();
|
|
|
|
if (dataConnector != null && objectConnector == null)
|
|
return dataConnector;
|
|
|
|
if (dataConnector == null && objectConnector != null)
|
|
return objectConnector;
|
|
|
|
object[] result = new object[dataConnector.Length + objectConnector.Length];
|
|
Array.Copy(dataConnector, 0, result, 0, dataConnector.Length);
|
|
Array.Copy(objectConnector, 0, result, dataConnector.Length, objectConnector.Length);
|
|
return result;
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void Ping()
|
|
{
|
|
dataStorage.Ping();
|
|
objectStorage.Ping();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public IEnumerable<Tuple<int, int, ProgramMapping>> SelectAllPmt()
|
|
{
|
|
return dataStorage.SelectAllPmt();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public SdtService SelectSdtById(int networkId, int tsId, ushort programMappingProgramNumber)
|
|
{
|
|
return dataStorage.SelectSdtById(networkId, tsId, programMappingProgramNumber);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public IEnumerable<Tuple<int, int, SdtService>> SelectAllSdt()
|
|
{
|
|
return dataStorage.SelectAllSdt();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void BeamsDisableAll()
|
|
{
|
|
dataStorage.BeamsDisableAll();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void BeamsEnable(int id, float satpos, string name, DateTime processTimestamp)
|
|
{
|
|
dataStorage.BeamsEnable(id, satpos, name, processTimestamp);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void BeamFootprintStore(int databasePointerId, DateTime databasePointerBeamsProcessTimestamp, string name,
|
|
string getPolygonString, string id)
|
|
{
|
|
dataStorage.BeamFootprintStore(databasePointerId, databasePointerBeamsProcessTimestamp, name, getPolygonString, id);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForBeamFootprint(int databasePointerId, DateTime databasePointerBeamsProcessTimestamp, string name, string id)
|
|
{
|
|
return dataStorage.TestForBeamFootprint(databasePointerId, databasePointerBeamsProcessTimestamp, name, id);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void BeamsDisableSpecific(int databasePointerId, float databasePointerSatpos, string databasePointerName,
|
|
DateTime databasePointerBeamsProcessTimestamp)
|
|
{
|
|
dataStorage.BeamsDisableSpecific(databasePointerId, databasePointerSatpos, databasePointerName, databasePointerBeamsProcessTimestamp);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public IEnumerable<SatelliteBeam> BeamsSelectEnabled()
|
|
{
|
|
return dataStorage.BeamsSelectEnabled();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public List<SatelliteBeamFootprint> BeamsSelectFootprints(int satelliteBeamId, DateTime satelliteBeamProcessTimestamp)
|
|
{
|
|
return dataStorage.BeamsSelectFootprints(satelliteBeamId, satelliteBeamProcessTimestamp);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertBlindscanJob(DbBlindscanJob jobInDb)
|
|
{
|
|
dataStorage.InsertBlindscanJob(jobInDb);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UpdateJobState(DbBlindscanJob jobInDb)
|
|
{
|
|
dataStorage.UpdateJobState(jobInDb);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertSearchResult(DbBlindscanJob jobInDb, bool satellite, SearchResult searchResult, int polarityIndex,
|
|
SearchResult2 searchResult2)
|
|
{
|
|
dataStorage.InsertSearchResult(jobInDb, satellite, searchResult, polarityIndex, searchResult2);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UpdateTransponderState(DbBlindscanJob jobInDb, bool satellite, SearchResult searchResult,
|
|
BlindscanResultState blindscanResultState, SearchResult2 searchResult2)
|
|
{
|
|
dataStorage.UpdateTransponderState(jobInDb, satellite, searchResult, blindscanResultState, searchResult2);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertTransponderService(DbBlindscanJob jobInDb, bool resultSatellite, SearchResult resultSr1,
|
|
SearchResult2 resultSr2, HumanReadableService humanReadableService)
|
|
{
|
|
dataStorage.InsertTransponderService(jobInDb, resultSatellite, resultSr1, resultSr2, humanReadableService);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForIncompleteJob()
|
|
{
|
|
return dataStorage.TestForIncompleteJob();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public DbBlindscanJob GetPastBlindscanJob(long offset)
|
|
{
|
|
return dataStorage.GetPastBlindscanJob(offset);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void DeleteBlindscanJob(Guid guid)
|
|
{
|
|
dataStorage.DeleteBlindscanJob(guid);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void DeleteBlindscanResults(Guid jobGuid, int polarityIndex)
|
|
{
|
|
dataStorage.DeleteBlindscanResults(jobGuid, polarityIndex);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void MoveBlScanResultsToAnotherJob(Guid moveFrom, Guid moveTo, int polarityIndex)
|
|
{
|
|
dataStorage.MoveBlScanResultsToAnotherJob(moveFrom, moveTo, polarityIndex);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void FailDsmCcDownload(DatabaseKeyDsmCcModule key, double value)
|
|
{
|
|
dataStorage.FailDsmCcDownload(key, value);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public IReadOnlyList<string> ListImportFileByTag1(int tag1)
|
|
{
|
|
return dataStorage.ListImportFileByTag1(tag1);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForTerminalBurstTimePlan(ushort interactiveNetworkId, uint groupId, uint logonId)
|
|
{
|
|
return dataStorage.TestForTerminalBurstTimePlan(interactiveNetworkId, groupId, logonId);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreTerminalBurstTimePlan(ushort interactiveNetworkId, uint gtoupId, uint superframeCount, uint frameNumber, Tbtp.TbtpFrame.BtpEntity btp)
|
|
{
|
|
dataStorage.StoreTerminalBurstTimePlan(interactiveNetworkId, gtoupId, superframeCount, frameNumber, btp);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForCmtEntry(ushort interactiveNetworkId, Cmt.CmtEntry entry)
|
|
{
|
|
return dataStorage.TestForCmtEntry(interactiveNetworkId, entry);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertCmtEntry(ushort interactiveNetworkId, Cmt.CmtEntry entry)
|
|
{
|
|
dataStorage.InsertCmtEntry(interactiveNetworkId, entry);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public int GetRmtTransmissionStandard(ushort networkId)
|
|
{
|
|
return dataStorage.GetRmtTransmissionStandard(networkId);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public byte[] GetTmst(ushort interactiveNetworkId)
|
|
{
|
|
return dataStorage.GetTmst(interactiveNetworkId);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertTmst(ushort interactiveNetworkId, byte[] modes)
|
|
{
|
|
dataStorage.InsertTmst(interactiveNetworkId, modes);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void UpdateTmst(ushort interactiveNetworkId, byte[] modes)
|
|
{
|
|
dataStorage.UpdateTmst(interactiveNetworkId, modes);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForRmtLinkage(_0x4a_LinkageDescriptor linkage)
|
|
{
|
|
return dataStorage.TestForRmtLinkage(linkage);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertRmtLinkage(_0x4a_LinkageDescriptor linkage)
|
|
{
|
|
dataStorage.InsertRmtLinkage(linkage);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForRmtTransportStream(ushort networkId, Rmt.TransportStream transportStream)
|
|
{
|
|
return dataStorage.TestForRmtTransportStream(networkId, transportStream);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertRmtTransportStream(ushort networkId, Rmt.TransportStream transportStream)
|
|
{
|
|
dataStorage.InsertRmtTransportStream(networkId, transportStream);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForSuperframeComposition(ushort interactiveNetworkId, Sct.Superframe superframe)
|
|
{
|
|
return dataStorage.TestForSuperframeComposition(interactiveNetworkId, superframe);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreSuperframeComposition(ushort interactiveNetworkId, Sct.Superframe superframe)
|
|
{
|
|
dataStorage.StoreSuperframeComposition(interactiveNetworkId, superframe);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForFrameComposition(ushort interactiveNetworkId, Fct.Frame frame)
|
|
{
|
|
return dataStorage.TestForFrameComposition(interactiveNetworkId, frame);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertFctFrame(ushort interactiveNetworkId, Fct.Frame frame)
|
|
{
|
|
dataStorage.InsertFctFrame(interactiveNetworkId, frame);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForSatellitePosition(ushort interactiveNetworkId, Spt.Satellite satellite)
|
|
{
|
|
return dataStorage.TestForSatellitePosition(interactiveNetworkId, satellite);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void StoreSatellitePosition(ushort interactiveNetworkId, Spt.Satellite satellite)
|
|
{
|
|
dataStorage.StoreSatellitePosition(interactiveNetworkId, satellite);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForTim(PhysicalAddress mac)
|
|
{
|
|
return dataStorage.TestForTim(mac);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void CreateTim(PhysicalAddress mac)
|
|
{
|
|
dataStorage.CreateTim(mac);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool CorrectTim(PhysicalAddress mac, _0xa1_CorrectionMessageDescriptor cmd)
|
|
{
|
|
return dataStorage.CorrectTim(mac, cmd);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool ContentionTim(PhysicalAddress mac, _0xab_ContentionControlDescriptor ccdNew)
|
|
{
|
|
return dataStorage.ContentionTim(mac, ccdNew);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool CorrectionControlTim(PhysicalAddress mac, _0xac_CorrectionControlDescriptor descriptor)
|
|
{
|
|
return dataStorage.CorrectionControlTim(mac, descriptor);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool NetworkLayerInfoTim(PhysicalAddress mac, _0xa0_NetworkLayerInfoDescriptor nlid, DateTime timestamped)
|
|
{
|
|
return dataStorage.NetworkLayerInfoTim(mac, nlid, timestamped);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public IEnumerable<DbBlindscanJob> GetDbBlindscanJobs()
|
|
{
|
|
return dataStorage.GetDbBlindscanJobs();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public long DnsCountA()
|
|
{
|
|
return dataStorage.DnsCountA();
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public string DnsIpToName(IPAddress source)
|
|
{
|
|
return dataStorage.DnsIpToName(source);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForIp(IPAddress iP)
|
|
{
|
|
return dataStorage.TestForIp(iP);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void RememberDnsRecord(DnsRecord record)
|
|
{
|
|
dataStorage.RememberDnsRecord(record);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForSgtList(SgtList list)
|
|
{
|
|
return dataStorage.TestForSgtList(list);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertSgtList(SgtList list)
|
|
{
|
|
dataStorage.InsertSgtList(list);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public bool TestForSgtService(SgtService child)
|
|
{
|
|
return dataStorage.TestForSgtService(child);
|
|
}
|
|
|
|
[DebuggerStepThrough]
|
|
public void InsertSgtService(SgtService child)
|
|
{
|
|
dataStorage.InsertSgtService(child);
|
|
}
|
|
}
|
|
}
|