protected bool InitializeGentle()
{
try
{
// Use the same Gentle.config as the TVEngine
string gentleConfigFile = Path.Combine(ServiceRegistration.Get <IPathManager>().GetPath("<TVCORE>"), "Gentle.config");
// but be quiet when it doesn't exists, as not everyone has the TV Engine installed
if (!File.Exists(gentleConfigFile))
{
ServiceRegistration.Get <ILogger>().Info("SlimTvProxy: Cannot find Gentle.config file, assuming TVEngine isn't installed...");
return(false);
}
Gentle.Common.Configurator.AddFileHandler(gentleConfigFile);
//Load settings
ISettingsManager settingsManager = ServiceRegistration.Get <ISettingsManager>();
SlimTvProxySettings settings = settingsManager.Load <SlimTvProxySettings>();
settingsManager.Save(settings);
RemoteControl.HostName = settings.HostName;
ProviderFactory.SetDefaultProviderConnectionString(settings.DatabaseConnectionString);
ProviderFactory.SetDefaultProvider(settings.DatabaseProvider);
_allCards = new List <Card>(Card.ListAll());
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("SlimTvProxy: Failed to connect to TVEngine", ex);
return(false);
}
return(true);
}
public static bool IsChannelMappedToCard(Channel dbChannel, Card card)
{
bool isChannelMappedToCard = false;
IDictionary<int, bool> cardIds;
bool isChannelFound = _channelMapping.TryGetValue(dbChannel.IdChannel, out cardIds);
bool channelMappingFound = false;
if (isChannelFound)
{
channelMappingFound = cardIds.TryGetValue(card.IdCard, out isChannelMappedToCard);
}
if (!channelMappingFound)
{
//check if channel is mapped to this card and that the mapping is not for "Epg Only"
isChannelMappedToCard = _businessLayer.IsChannelMappedToCard(dbChannel, card, false);
if (cardIds == null)
{
cardIds = new Dictionary<int, bool>();
}
cardIds.Add(card.IdCard, isChannelMappedToCard);
}
_channelMapping[dbChannel.IdChannel] = cardIds;
return isChannelMappedToCard;
}
//TODO: move these helpers to other static classes
private void SetupChannelMapping(ITvCardHandler cardHandler1, ChannelMap channelMap, TvBusinessLayer businessLayer, Channel channel)
{
Isolate.WhenCalled(() => channelMap.EpgOnly).WillReturn(false);
Isolate.WhenCalled(() => channelMap.ReferencedCard().DevicePath).WillReturn(cardHandler1.DataBaseCard.DevicePath);
TvDatabase.Card card = cardHandler1.DataBaseCard;
Isolate.WhenCalled(() => businessLayer.IsChannelMappedToCard(channel, card, false)).WillReturn(true);
}
private IUser GetUserByUserName(string userName)
{
if (_tvControl == null)
{
return(null);
}
return(Card.ListAll()
.Where(c => c != null && c.Enabled)
.SelectMany(c => { var users = _tvControl.GetUsersForCard(c.IdCard); return users ?? new IUser[] { }; })
.FirstOrDefault(u => u.Name == userName));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="controller">instance of a TVController</param>
/// <param name="card">The card</param>
public EpgCard(TVController controller, Card card)
{
_card = card;
_user = new User("epg", false, -1);
_tvController = controller;
_grabStartTime = DateTime.MinValue;
_state = EpgState.Idle;
_epgTimer.Interval = 30000;
_epgTimer.Elapsed += _epgTimer_Elapsed;
_eventHandler = controller_OnTvServerEvent;
_dbUpdater = new EpgDBUpdater(_tvController, "IdleEpgGrabber", true);
}
/// <summary>
/// Initializes a new instance of the <see cref="ITVCard"/> class.
/// </summary>
public TvCardHandler(Card dbsCard, ITVCard card)
{
_dbsCard = dbsCard;
Card = card;
IsLocal = _card != null;
_userManagement = new UserManagement(this);
_disEqcManagement = new DisEqcManagement(this);
_teletext = new TeletextManagement(this);
_scanner = new ChannelScanning(this);
_epgGrabbing = new EpgGrabbing(this);
_audioStreams = new AudioStreams(this);
_recorder = new Recorder(this);
_timerShifter = new TimeShifter(this);
_tuner = new CardTuner(this);
}
private void ExternalChannels_Load(object sender, EventArgs e)
{
IList<Card> cards = Card.ListAll();
if (cards.Count == 0)
{
Card dummyCard = new Card(0, "device path", "Dummy TV Card", 0, false, DateTime.Now, "recording folder", 0,
false, 0, "timeshifting folder", 0, 0, 0);
cards.Add(dummyCard);
}
_tvCardStbSetups = new StbSetup[cards.Count];
comboBoxCopyFrom.Items.Clear();
TabPage tempPage;
int index = 0;
foreach (Card card in cards)
{
comboBoxCopyFrom.Items.Add(card.IdCard);
_tvCardStbSetups[index] = new StbSetup(card.IdCard);
_tvCardStbSetups[index].Name = String.Format("StbSetup{0}", index);
_tvCardStbSetups[index].Dock = DockStyle.Fill;
_tvCardStbSetups[index].TabIndex = 0;
tempPage = new TabPage(String.Format("TV Card {0}", index + 1));
tempPage.Controls.Add(_tvCardStbSetups[index]);
tabControlTVCards.TabPages.Add(tempPage);
index++;
}
comboBoxCopyFrom.SelectedIndex = 0;
// Setup quick setup combo box
string[] quickSetupFiles = Directory.GetFiles(Common.FolderSTB, "*.xml", SearchOption.TopDirectoryOnly);
foreach (string file in quickSetupFiles)
comboBoxQuickSetup.Items.Add(Path.GetFileNameWithoutExtension(file));
comboBoxQuickSetup.Items.Add("Clear all");
}
protected override bool GetRecordingConfiguration(out List <string> recordingFolders, out string singlePattern, out string seriesPattern)
{
try
{
TvBusinessLayer layer = new TvBusinessLayer();
IList <Card> allCards = Card.ListAll();
// Get all different recording folders
recordingFolders = allCards.Select(c => c.RecordingFolder).Where(f => !string.IsNullOrEmpty(f)).Distinct(StringComparer.OrdinalIgnoreCase).ToList();
singlePattern = layer.GetSetting("moviesformat", string.Empty).Value;
seriesPattern = layer.GetSetting("seriesformat", string.Empty).Value;
return(recordingFolders.Count > 0);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("SlimTvService: Exception while getting recording folders", ex);
}
recordingFolders = null;
singlePattern = null;
seriesPattern = null;
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="ITVCard"/> class.
/// </summary>
public TvCardHandler(Card dbsCard, ITVCard card)
{
_dbsCard = dbsCard;
_card = card;
if (_card != null)
{
_card.Context = new TvCardContext();
_isLocal = true;
}
else
{
_isLocal = false;
}
_userManagement = new UserManagement(this);
_disEqcManagement = new DisEqcManagement(this);
_teletext = new TeletextManagement(this);
_scanner = new ChannelScanning(this);
_epgGrabbing = new EpgGrabbing(this);
_audioStreams = new AudioStreams(this);
_tuner = new CardTuner(this);
_recorder = new Recorder(this);
_timerShifter = new TimeShifter(this);
}
private bool TuneEPGgrabber(Channel channel, IChannel tuning, Card card, TvResult result)
{
try
{
_user.CardId = card.IdCard;
ITvCardHandler cardHandler;
if (_tvController.CardCollection.TryGetValue(card.IdCard, out cardHandler))
{
ICardTuneReservationTicket ticket = null;
try
{
ICardReservation cardReservationImpl = new CardReservationTimeshifting(_tvController);
ticket = cardReservationImpl.RequestCardTuneReservation(cardHandler, tuning, _user);
if (ticket != null)
{
result = _tvController.Tune(ref _user, tuning, channel.IdChannel, ticket);
if (result == TvResult.Succeeded)
{
if (!_isRunning || false == _tvController.GrabEpg(this, card.IdCard))
{
if (!_isRunning)
Log.Epg("Tuning finished but EpgGrabber no longer enabled");
_tvController.StopGrabbingEpg(_user);
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not start dvbt grabbing", card.IdCard);
return false;
}
_user.CardId = card.IdCard;
return true;
}
}
}
catch (Exception)
{
CardReservationHelper.CancelCardReservation(cardHandler, ticket);
throw;
}
}
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not tune to channel:{1}", card.IdCard, result.ToString());
return false;
}
catch (Exception ex)
{
Log.Write(ex);
throw;
}
}
/// <summary>
/// This method will try to start the epg grabber for the channel and tuning details specified
/// Epg grabbing can only be started if there is a card idle which can receive the channel specified
/// </summary>
/// <param name="channel">channel to grab/param>
/// <param name="tuning">tuning information</param>
/// <param name="card">card to use for grabbing</param>
/// <returns>true if grabbing has started else false</returns>
private bool GrabEpgForChannel(Channel channel, IChannel tuning, Card card)
{
if (channel == null)
{
Log.Error("Epg: invalid channel");
return false;
}
if (tuning == null)
{
Log.Error("Epg: invalid tuning");
return false;
}
if (card == null)
{
Log.Error("Epg: invalid card");
return false;
}
if (_tvController == null)
{
Log.Error("Epg: invalid tvcontroller");
return false;
}
if (_user == null)
{
Log.Error("Epg: invalid user");
return false;
}
//remove following check to enable multi-card epg grabbing (still beta)
if (_tvController.AllCardsIdle == false)
{
Log.Epg("Epg: card:{0} cards are not idle", card.IdCard);
return false;
}
TvResult result = TvResult.UnknownError;
//handle ATSC
ATSCChannel atscChannel = tuning as ATSCChannel;
if (atscChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.Atsc)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} atsc card is not idle", card.IdCard);
return false; //card is busy
}
return TuneEPGgrabber(channel, tuning, card, result);
}
Log.Epg("Epg: card:{0} could not tune to atsc channel:{1}", card.IdCard, tuning.ToString());
return false;
}
//handle DVBC
DVBCChannel dvbcChannel = tuning as DVBCChannel;
if (dvbcChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbC)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbc card is not idle", card.IdCard);
return false; //card is busy
}
return TuneEPGgrabber(channel, tuning, card, result);
}
Log.Epg("Epg: card:{0} could not tune to dvbc channel:{1}", card.IdCard, tuning.ToString());
return false;
}
//handle DVBS
DVBSChannel dvbsChannel = tuning as DVBSChannel;
if (dvbsChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbS)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbs card is not idle", card.IdCard);
return false; //card is busy
}
return TuneEPGgrabber(channel, tuning, card, result);
}
Log.Epg("Epg: card:{0} could not tune to dvbs channel:{1}", card.IdCard, tuning.ToString());
return false;
}
//handle DVBT
DVBTChannel dvbtChannel = tuning as DVBTChannel;
if (dvbtChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbT)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbt card is not idle", card.IdCard);
return false; //card is busy
}
return TuneEPGgrabber(channel, tuning, card, result);
}
Log.Epg("Epg: card:{0} could not tune to dvbt channel:{1}", card.IdCard, tuning.ToString());
return false;
}
//handle DVBIP
DVBIPChannel dvbipChannel = tuning as DVBIPChannel;
if (dvbipChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbIP)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbip card is not idle", card.IdCard);
return false; //card is busy
}
return TuneEPGgrabber(channel, tuning, card, result);
}
else
{
Log.Epg("Epg: card:{0} could not tune to dvbip channel:{1}", card.IdCard, tuning.ToString());
}
return false;
}
Log.Epg("Epg: card:{0} could not tune to channel:{1}", card.IdCard, tuning.ToString());
return false;
}
/// <summary>
/// Retrieves the status of a TV card.
/// </summary>
/// <param name="card">The required TV card.</param>
/// <returns>uWiMP.TVServer.Cards.Status</returns>
/// <remarks></remarks>
public static Status GetCardStatus(Card card)
{
SetupConnection();
User user = new User();
VirtualCard vcard;
user.CardId = card.IdCard;
IUser[] usersForCard = RemoteControl.Instance.GetUsersForCard(card.IdCard);
Status status = Cards.Status.idle;
if (usersForCard.Length == 0)
{
vcard = new VirtualCard(user, RemoteControl.HostName);
try
{
if (vcard.IsScanning)
status = Cards.Status.scanning;
if (vcard.IsRecording)
status = Cards.Status.recording;
if (vcard.IsGrabbingEpg)
status = Cards.Status.grabbing;
if (vcard.IsTimeShifting)
status = Cards.Status.timeshifting;
}
catch (Exception ex)
{
}
}
else
{
int i = 0;
for (i = 0; i <= usersForCard.Length - 1; i++)
{
vcard = new VirtualCard(usersForCard[i], RemoteControl.HostName);
try
{
if (vcard.IsScanning)
status = Cards.Status.scanning;
if (vcard.IsRecording)
status = Cards.Status.recording;
if (vcard.IsGrabbingEpg)
status = Cards.Status.grabbing;
if (vcard.IsTimeShifting)
status = Cards.Status.timeshifting;
}
catch (Exception ex)
{
}
}
}
return status;
}
/// <summary>
/// Kicks a user from a TV card if timeshifting.
/// </summary>
/// <param name="card"></param>
/// <returns></returns>
/// <remarks></remarks>
public static bool StopTimeshifting(Card card)
{
SetupConnection();
VirtualCard vcard;
IUser[] usersForCard = RemoteControl.Instance.GetUsersForCard(card.IdCard);
foreach (IUser user in usersForCard)
{
vcard = new VirtualCard(user, RemoteControl.HostName);
try
{
if (vcard.IsTimeShifting)
{
vcard.StopTimeShifting();
return true;
}
}
catch (Exception ex)
{
return false;
}
}
return false;
}
public static bool IsChannelMappedToCard(Channel dbChannel, Card card)
{
bool isChannelMappedToCard = _businessLayer.IsChannelMappedToCard(dbChannel, card, false);
return isChannelMappedToCard;
}
public override Task <AsyncResult <List <IVirtualCard> > > GetActiveVirtualCardsAsync()
{
IEnumerable <VirtualCard> virtualCards = Card.ListAll()
.Where(card => RemoteControl.Instance.CardPresent(card.IdCard))
.Select(card => RemoteControl.Instance.GetUsersForCard(card.IdCard))
.Where(users => users != null)
.SelectMany(user => user)
.Select(user => new VirtualCard(user, RemoteControl.HostName))
.Where(tvCard => tvCard.IsTimeShifting || tvCard.IsRecording);
List <IVirtualCard> cards = new List <IVirtualCard>();
foreach (var card in virtualCards)
{
cards.Add(new SlimTvVirtualCard
{
BitRateMode = (int)card.BitRateMode,
ChannelName = card.ChannelName,
Device = card.Device,
Enabled = card.Enabled,
GetTimeshiftStoppedReason = (int)card.GetTimeshiftStoppedReason,
GrabTeletext = card.GrabTeletext,
HasTeletext = card.HasTeletext,
Id = card.Id,
ChannelId = card.IdChannel,
IsGrabbingEpg = card.IsGrabbingEpg,
IsRecording = card.IsRecording,
IsScanning = card.IsScanning,
IsScrambled = card.IsScrambled,
IsTimeShifting = card.IsTimeShifting,
IsTunerLocked = card.IsTunerLocked,
MaxChannel = card.MaxChannel,
MinChannel = card.MinChannel,
Name = card.Name,
QualityType = (int)card.QualityType,
RecordingFileName = card.RecordingFileName,
RecordingFolder = card.RecordingFolder,
RecordingFormat = card.RecordingFormat,
RecordingScheduleId = card.RecordingScheduleId,
RecordingStarted = card.RecordingStarted != DateTime.MinValue ? card.RecordingStarted : new DateTime(2000, 1, 1),
RemoteServer = card.RemoteServer,
RTSPUrl = card.RTSPUrl,
SignalLevel = card.SignalLevel,
SignalQuality = card.SignalQuality,
TimeShiftFileName = card.TimeShiftFileName,
TimeShiftFolder = card.TimeshiftFolder,
TimeShiftStarted = card.TimeShiftStarted != DateTime.MinValue ? card.TimeShiftStarted : new DateTime(2000, 1, 1),
Type = (SlimTvCardType)Enum.Parse(typeof(SlimTvCardType), card.Type.ToString()),
User = card.User != null ? new SlimTvUser
{
Priority = card.User.Priority,
ChannelStates = card.User.ChannelStates.ToDictionary(item => item.Key, item => (SlimTvChannelState)Enum.Parse(typeof(SlimTvChannelState), item.ToString())),
CardId = card.User.CardId,
Name = card.User.Name,
FailedCardId = card.User.FailedCardId,
HeartBeat = card.User.HeartBeat,
History = card.User.History,
IdChannel = card.User.IdChannel,
IsAdmin = card.User.IsAdmin,
SubChannel = card.User.SubChannel,
TvStoppedReason = (SlimTvStoppedReason)Enum.Parse(typeof(SlimTvStoppedReason), card.User.TvStoppedReason.ToString()),
} : null
});
}
return(Task.FromResult(new AsyncResult <List <IVirtualCard> >(cards.Count > 0, cards)));
}
protected bool IsChannelMappedToCard(Channel dbChannel, Card card)
{
//check if channel is mapped to this card and that the mapping is not for "Epg Only"
bool isChannelMappedToCard = _businessLayer.IsChannelMappedToCard(dbChannel, card, false);
return isChannelMappedToCard;
}
/// <summary>
/// checks if the decryptLimit for a card, regarding to a list of assigned shedules
/// has been reached or not
/// </summary>
/// <param name="card">card we wanna use</param>
/// <param name="assignedSchedules">List of schedules assigned to this card</param>
/// <returns></returns>
private bool cardLimitReached(Card card, IList<Schedule> assignedSchedules)
{
return false;
}
/// <summary>
/// Load external channel configurations.
/// </summary>
internal static void LoadExternalConfigs()
{
IList<Card> cards = Card.ListAll();
if (cards.Count == 0)
{
Log.Info("Cannot load external channel configurations, there are no TV cards registered");
Card dummyCard = new Card(0, "device path", "Dummy TV Card", 0, false, DateTime.Now, "recording folder", 0,
false, 0, "timeshifting folder", 0, 0, 0);
cards.Add(dummyCard);
}
_externalChannelConfigs = new ExternalChannelConfig[cards.Count];
int index = 0;
foreach (Card card in cards)
{
string fileName = Path.Combine(ExtCfgFolder, String.Format("ExternalChannelConfig{0}.xml", card.IdCard));
try
{
_externalChannelConfigs[index] = ExternalChannelConfig.Load(fileName);
}
catch (Exception ex)
{
_externalChannelConfigs[index] = new ExternalChannelConfig(fileName);
Log.Error(ex.ToString());
}
_externalChannelConfigs[index].CardId = card.IdCard;
index++;
}
}
/// <summary>
/// This method will try to start the epg grabber for the channel and tuning details specified
/// Epg grabbing can only be started if there is a card idle which can receive the channel specified
/// </summary>
/// <param name="channel">channel to grab/param>
/// <param name="tuning">tuning information</param>
/// <param name="card">card to use for grabbing</param>
/// <returns>true if grabbing has started else false</returns>
private bool GrabEpgForChannel(Channel channel, IChannel tuning, Card card)
{
if (channel == null)
{
Log.Error("Epg: invalid channel");
return false;
}
if (tuning == null)
{
Log.Error("Epg: invalid tuning");
return false;
}
if (card == null)
{
Log.Error("Epg: invalid card");
return false;
}
if (_tvController == null)
{
Log.Error("Epg: invalid tvcontroller");
return false;
}
if (_user == null)
{
Log.Error("Epg: invalid user");
return false;
}
//remove following check to enable multi-card epg grabbing (still beta)
if (_tvController.AllCardsIdle == false)
{
Log.Epg("Epg: card:{0} cards are not idle", card.IdCard);
return false;
}
TvResult result;
//handle ATSC
ATSCChannel atscChannel = tuning as ATSCChannel;
if (atscChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.Atsc)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} atsc card is not idle", card.IdCard);
return false; //card is busy
}
try
{
IUser cardUser;
if (_tvController.IsCardInUse(card.IdCard, out cardUser) == false)
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
if (result == TvResult.Succeeded)
{
if (!_isRunning || false == _tvController.GrabEpg(this, card.IdCard))
{
if (!_isRunning)
Log.Epg("Tuning finished but EpgGrabber no longer enabled");
_tvController.StopGrabbingEpg(_user);
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not start atsc epg grabbing", card.IdCard);
return false;
}
_user.CardId = card.IdCard;
return true;
}
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not tune to channel:{1}", card.IdCard, result.ToString());
return false;
}
}
catch (Exception ex)
{
Log.Write(ex);
throw;
}
return false;
}
Log.Epg("Epg: card:{0} could not tune to atsc channel:{1}", card.IdCard, tuning.ToString());
return false;
}
//handle DVBC
DVBCChannel dvbcChannel = tuning as DVBCChannel;
if (dvbcChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbC)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbc card is not idle", card.IdCard);
return false; //card is busy
}
try
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
if (result == TvResult.Succeeded)
{
if (!_isRunning || false == _tvController.GrabEpg(this, card.IdCard))
{
if (!_isRunning)
Log.Epg("Tuning finished but EpgGrabber no longer enabled");
_tvController.StopGrabbingEpg(_user);
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not start dvbc epg grabbing", card.IdCard);
return false;
}
_user.CardId = card.IdCard;
return true;
}
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not tune to channel:{1}", card.IdCard, result.ToString());
return false;
}
catch (Exception ex)
{
Log.Write(ex);
throw;
}
//unreachable return false;
}
Log.Epg("Epg: card:{0} could not tune to dvbc channel:{1}", card.IdCard, tuning.ToString());
return false;
}
//handle DVBS
DVBSChannel dvbsChannel = tuning as DVBSChannel;
if (dvbsChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbS)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbs card is not idle", card.IdCard);
return false; //card is busy
}
try
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
if (result == TvResult.Succeeded)
{
if (!_isRunning || false == _tvController.GrabEpg(this, card.IdCard))
{
if (!_isRunning)
Log.Epg("Tuning finished but EpgGrabber no longer enabled");
_tvController.StopGrabbingEpg(_user);
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not start dvbs epg grabbing", card.IdCard);
return false;
}
_user.CardId = card.IdCard;
return true;
}
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not tune to channel:{1}", card.IdCard, result.ToString());
return false;
}
catch (Exception ex)
{
Log.Write(ex);
throw;
}
//unreachable return false;
}
Log.Epg("Epg: card:{0} could not tune to dvbs channel:{1}", card.IdCard, tuning.ToString());
return false;
}
//handle DVBT
DVBTChannel dvbtChannel = tuning as DVBTChannel;
if (dvbtChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbT)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbt card is not idle", card.IdCard);
return false; //card is busy
}
try
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
if (result == TvResult.Succeeded)
{
if (!_isRunning || false == _tvController.GrabEpg(this, card.IdCard))
{
if (!_isRunning)
Log.Epg("Tuning finished but EpgGrabber no longer enabled");
_tvController.StopGrabbingEpg(_user);
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not start dvbt grabbing", card.IdCard);
return false;
}
_user.CardId = card.IdCard;
return true;
}
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not tune to channel:{1}", card.IdCard, result.ToString());
return false;
}
catch (Exception ex)
{
Log.Write(ex);
throw;
}
//unreachable return false;
}
Log.Epg("Epg: card:{0} could not tune to dvbt channel:{1}", card.IdCard, tuning.ToString());
return false;
}
//handle DVBIP
DVBIPChannel dvbipChannel = tuning as DVBIPChannel;
if (dvbipChannel != null)
{
if (_tvController.Type(card.IdCard) == CardType.DvbIP)
{
if (IsCardIdle(card.IdCard) == false)
{
Log.Epg("Epg: card:{0} dvbip card is not idle", card.IdCard);
return false; //card is busy
}
try
{
_user.CardId = card.IdCard;
result = RemoteControl.Instance.Tune(ref _user, tuning, channel.IdChannel);
if (result == TvResult.Succeeded)
{
if (!_isRunning || false == _tvController.GrabEpg(this, card.IdCard))
{
if (!_isRunning)
Log.Epg("Tuning finished but EpgGrabber no longer enabled");
_tvController.StopGrabbingEpg(_user);
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not start dvbip grabbing", card.IdCard);
return false;
}
_user.CardId = card.IdCard;
return true;
}
else
{
_user.CardId = -1;
Log.Epg("Epg: card:{0} could not tune to channel:{1}", card.IdCard, result.ToString());
return false;
}
}
catch (Exception ex)
{
Log.Write(ex);
throw ex;
}
//unreachable return false;
}
else
{
Log.Epg("Epg: card:{0} could not tune to dvbip channel:{1}", card.IdCard, tuning.ToString());
}
return false;
}
Log.Epg("Epg: card:{0} could not tune to channel:{1}", card.IdCard, tuning.ToString());
return false;
}
public CardInfo(Card card)
{
_card = card;
}
public bool Importxmlfile(string filename)
{
XmlDocument doc = new XmlDocument();
POSTIMPORT = "";
if (DEBUG == true)
textoutput("BackupSettings: Trying to import channels from " + filename);
try
{
doc.Load(filename);
}
catch (Exception exc)
{
textoutput("<RED>Could not load xml file " + filename);
if (DEBUG == true)
textoutput("<RED>Exception message is:" + exc.Message);
return (false);
}
//list all cards and initiate translationtable
#if(MP100)
IList allTVcards = Card.ListAll();
#elif (MP101)
IList<Card> allTVcards = Card.ListAll();
#else //MP11BETA or SVN
IList<Card> allTVcards = Card.ListAll();
#endif
bool[] TVcardassigned = new bool[allTVcards.Count + 1];
Card[] TVcards = new Card[allTVcards.Count + 1];
//count all cards in xml file
XmlNodeList cardList = doc.SelectNodes("/tvserver/servers/server/cards/card");
Int32 xmlcardnumbers = cardList.Count;
Int32[] cardidpos = new Int32[xmlcardnumbers + 1];
int i = 1;
foreach (XmlNode nodecard in cardList)
{
int cardid = Convert.ToInt32(nodecard.Attributes["IdCard"].Value);
cardidpos[i] = cardid;
i++;
}
int allXMLcards = i - 1;
bool[] xmlcardassigned = new bool[allXMLcards + 1];
int[] cardmaptranslator = new int[allXMLcards + 1];
//initialize tv card TVcardassigned
i = 1;
foreach (Card dbservercard in allTVcards)
{
TVcards[i] = dbservercard;
TVcardassigned[i] = false;
i++;
}
//initialize cardmaptranslator and xmlcardsassigned
for (i = 0; i <= allXMLcards; i++)
{
cardmaptranslator[i] = 0;
xmlcardassigned[i] = false;
}
// check if plugins are available
bool ok = plugincheck();
if (ok == false)
return false;
try
{
CountryCollection collection = new CountryCollection();
TvBusinessLayer layer = new TvBusinessLayer();
bool identicalCards = false;
int motorCount = 0;
int serverCount = 0;
int cardCount = 0;
int channelCount = 0;
int programCount = 0;
int scheduleCount = 0;
int recordingCount = 0;
int channelGroupCount = 0;
int radiochannelGroupCount = 0;
int tvmovieCount = 0;
// version check
XmlNodeList versionList = doc.SelectNodes("/tvserver/versions/pluginversion");
bool versionfound = false;
foreach (XmlNode nodeversion in versionList)
{
string restoreversion;
versionfound = true;
try
{
restoreversion = nodeversion.Attributes["backupSettingVersion"].Value;
}
catch
{
restoreversion = "0.0.0.1";
}
string actualversion = detectplugin("BackupSettings");
if (restoreversion != actualversion)
{
textoutput("<YELLOW>Warning: actual BackupSetting plugin version is " + actualversion);
textoutput("<YELLOW>Backup data were created by version " + restoreversion);
try
{
myMessageBox("Backup data were created with an older version of BackupSettings\nIn case of problems install the older plugin version from\n" + filename.Substring(0, filename.Length - 22) + @"TV_Program\Plugins", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
}
catch (Exception exc)
{
if (DEBUG == true)
{
textoutput("<RED>MessageBox Exception is " + exc.Message);
}
return false;
}
}
}
if (versionfound == false)
{
textoutput("<YELLOW>No version number found - backup data were created by version 0.0.0.1 or 0.0.0.2");
}
// Delete Channels
if (delete_channels == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_DeleteAllChannels);
textoutput("Deleting all channels - Please be patient");
channelCount = 0;
try
{
foreach (Channel tmpChannel in Channel.ListAll())
{
try
{
tmpChannel.Delete();
channelCount++;
}
catch
{
textoutput("<RED>Channel " + tmpChannel.DisplayName + " number " + channelCount.ToString() + " could not be deleted");
}
}
}
catch
{
textoutput("<YELLOW>Channels could not be listed");
}
textoutput(channelCount + " Channels deleted");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_DeleteAllChannels);
}
// Delete Schedules and Programs
if (delete_schedules == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_deleteAllSchedules);
textoutput("Deleting all programs from database");
programCount = 0;
#if(MP100)
IList programs = Program.ListAll();
#elif(MP101)
IList<Program> programs = Program.ListAll();
#else //MP11BETA or SVN
IList<Program> programs = Program.ListAll();
#endif
foreach (Program tmpProgram in programs)
{
tmpProgram.Delete();
programCount++;
}
textoutput(programCount + " Programs deleted");
// end program delete
//schedules
textoutput("Deleting all schedules from database");
scheduleCount = 0;
#if(MP100)
IList schedules = Schedule.ListAll();
#elif(MP101)
IList<Schedule> allschedules = Schedule.ListAll();
#else //MP11BETA or SVN
IList<Schedule> allschedules = Schedule.ListAll();
#endif
foreach (Schedule tmpSchedule in allschedules)
{
tmpSchedule.Delete();
scheduleCount++;
}
textoutput(scheduleCount + " Schedules deleted");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_deleteAllSchedules);
}
// Delete Recordings
if (delete_recordings == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_DeleteAllRecordings);
textoutput("Deleting all recordings from database");
recordingCount = 0;
#if(MP100)
IList allrecordings = Recording.ListAll();
#elif(MP101)
IList<Recording> allrecordings = Recording.ListAll();
#else //MP11BETA or SVN
IList<Recording> allrecordings = Recording.ListAll();
#endif
foreach (Recording tmpRecording in allrecordings)
{
tmpRecording.Delete();
recordingCount++;
}
textoutput(recordingCount + " Recordings deleted from database");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_DeleteAllRecordings);
}
// Delete Channel groups
if (delete_tvgroups == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_DeleteAllTvGroups);
textoutput("Deleting all TV groups");
channelGroupCount = 0;
#if(MP100)
IList tvgroups = ChannelGroup.ListAll();
#elif(MP101)
IList<ChannelGroup> alltvgroups = ChannelGroup.ListAll();
#else //MP11BETA or SVN
IList<ChannelGroup> alltvgroups = ChannelGroup.ListAll();
#endif
foreach (ChannelGroup tmpGroup in alltvgroups)
{
tmpGroup.Delete();
channelGroupCount++;
}
textoutput(channelGroupCount + " TV groups deleted");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_DeleteAllTvGroups);
}
// Delete Radio Channel Groups
if (delete_radiogroups == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_DeleteAllRadioGroups);
textoutput("Deleting all radio groups");
radiochannelGroupCount = 0;
#if(MP100)
IList allradiogroups = RadioChannelGroup.ListAll();
#elif(MP101)
IList<RadioChannelGroup> allradiogroups = RadioChannelGroup.ListAll();
#else //MP11BETA or SVN
IList<RadioChannelGroup> allradiogroups = RadioChannelGroup.ListAll();
#endif
foreach (RadioChannelGroup tmpRadioGroup in allradiogroups)
{
tmpRadioGroup.Delete();
radiochannelGroupCount++;
}
textoutput(radiochannelGroupCount + " radio groups deleted");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_DeleteAllRadioGroups);
}
//import servers and cards
if (server == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_Servers);
textoutput("Importing server settings");
Server dbserver = null;
Card dbserverCard = null;
XmlNodeList serverList = doc.SelectNodes("/tvserver/servers/server");
serverCount = 0;
foreach (XmlNode nodeserver in serverList)
{
serverCount++;
int serverid = Convert.ToInt32(nodeserver.Attributes["IdServer"].Value);
try
{
dbserver = Server.Retrieve(serverid);
// check for identical Hostname
if (dbserver.HostName != nodeserver.Attributes["HostName"].Value)
{
textoutput("<RED>Server hostname " + dbserver.HostName + " does not match import data " + nodeserver.Attributes["HostName"].Value);
switch (myMessageBox("Do you want to cancel the import? This is recommended! \n\n ", "Server hostname " + dbserver.HostName + " does not match import data " + nodeserver.Attributes["HostName"].Value, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1))
{
case DialogResult.Yes: // Abort
{
textoutput("User is aborting import");
return (false);
}
case DialogResult.No: // Continue
{
textoutput("User continues import although server name does not match host");
break;
}
}
}
//Server settings are in SetupTV\Sections\Servers.cs : private void buttonMaster_Click
dbserver.IsMaster = Convert.ToBoolean(nodeserver.Attributes["IsMaster"].Value);
#if(MP13)
try
{
dbserver.RtspPort = Convert.ToInt32(nodeserver.Attributes["RtspPort"].Value);
}
catch //do nothing
{
}
#endif
dbserver.Persist();
// global scanning parameters which are saved as server attributes
PostImport(doc, nodeserver, "lnbDefault");
PostImport(doc, nodeserver, "LnbLowFrequency");
PostImport(doc, nodeserver, "LnbHighFrequency");
PostImport(doc, nodeserver, "LnbSwitchFrequency");
}
catch (Exception exc)
{
textoutput("<RED>Servers: Failed to add server " + serverid);
if (DEBUG == true)
{
textoutput("<RED>Exception message is " + exc.Message);
}
return false;
}
}
textoutput(serverCount + " Server settings imported");
// Cards
textoutput("Importing card settings");
//case a: match id and name and devicepath
i = 1;
foreach (XmlNode nodecard in cardList)
{
if (i > allTVcards.Count) //stop if there are more xml cards than tv cards, id cannot match anymore
break;
//int cardid = Convert.ToInt32(nodecard.Attributes["IdCard"].Value);
int cardid = i;
string name = nodecard.Attributes["Name"].Value;
string devicepath = nodecard.Attributes["DevicePath"].Value;
if ((cardidpos[i] == TVcards[i].IdCard) && (name == TVcards[i].Name) && (devicepath == TVcards[i].DevicePath) && (TVcardassigned[i] == false) && (xmlcardassigned[i] == false))
{
if (DEBUG == true)
textoutput("Card id " + TVcards[i].IdCard.ToString() + " maped to .xml id " + cardidpos[i].ToString() + " name " + name + " (matched id, name, devicepath)");
cardmaptranslator[i] = i;
TVcardassigned[i] = true;
xmlcardassigned[i] = true;
}
i++;
}
//case b: match id and name
i = 1;
foreach (XmlNode nodecard in cardList)
{
if (i > allTVcards.Count) //stop if there are more xml cards than tv cards, id cannot match anymore
break;
//int cardid = Convert.ToInt32(nodecard.Attributes["IdCard"].Value);
int cardid = i;
string name = nodecard.Attributes["Name"].Value;
string devicepath = nodecard.Attributes["DevicePath"].Value;
if ((cardidpos[i] == TVcards[i].IdCard) && (name == TVcards[i].Name) && (TVcardassigned[i] == false) && (xmlcardassigned[i] == false))
{
if (DEBUG == true)
textoutput("Card id " + TVcards[i].IdCard.ToString() + " maped to .xml id " + cardidpos[i].ToString() + " name " + name + " (matched id, name)");
cardmaptranslator[i] = i;
TVcardassigned[i] = true;
xmlcardassigned[i] = true;
}
i++;
}
//case c: match name and devicepath
foreach (XmlNode nodecard in cardList)
{
int cardid = Convert.ToInt32(nodecard.Attributes["IdCard"].Value);
int cardidposition = 0;
for (int j = 1; j <= xmlcardnumbers; j++)
{
if (cardid == cardidpos[j])
{
cardidposition = j;
break;
}
}
if (cardidposition == 0)
{
textoutput("<RED>Card ID position for card number " + cardid.ToString() + "could not be identified - aborting import");
return false;
}
string name = nodecard.Attributes["Name"].Value;
string devicepath = nodecard.Attributes["DevicePath"].Value;
for (i = 1; i <= allTVcards.Count; i++)
{
if ((name == TVcards[i].Name) && (devicepath == TVcards[i].DevicePath) && (TVcardassigned[i] == false) && (xmlcardassigned[cardidposition] == false))
{
if (DEBUG == true)
textoutput("Card id " + TVcards[i].IdCard.ToString() + " maped to .xml id " + cardid.ToString() + " name " + name + " \n(matched name, devicepath)");
cardmaptranslator[cardidposition] = i;
TVcardassigned[i] = true;
xmlcardassigned[cardidposition] = true;
}
}
}
//case d: match name
foreach (XmlNode nodecard in cardList)
{
int cardid = Convert.ToInt32(nodecard.Attributes["IdCard"].Value);
int cardidposition = 0;
for (int j = 1; j <= xmlcardnumbers; j++)
{
if (cardid == cardidpos[j])
{
cardidposition = j;
break;
}
}
if (cardidposition == 0)
{
textoutput("<RED>Card ID position for card number " + cardid.ToString() + "could not be identified - aborting import");
return false;
}
string name = nodecard.Attributes["Name"].Value;
string devicepath = nodecard.Attributes["DevicePath"].Value;
for (i = 1; i <= allTVcards.Count; i++)
{
if ((name == TVcards[i].Name) && (TVcardassigned[i] == false) && (xmlcardassigned[cardidposition] == false))
{
if (DEBUG == true)
textoutput("Card id " + TVcards[i].IdCard.ToString() + " maped to .xml id " + cardid.ToString() + " name " + name + " \n(matched name)");
cardmaptranslator[cardidposition] = i;
TVcardassigned[i] = true;
xmlcardassigned[cardidposition] = true;
}
}
}
for (i = 1; i <= allTVcards.Count; i++)
{
if (TVcardassigned[i] == false)
{
textoutput("<YELLOW>TV card ID " + TVcards[i].IdCard.ToString() + " with name " + TVcards[i].Name + " has not been assigned to a card from the backup data - no channel will be assigned to this card");
}
}
for (i = 1; i <= allXMLcards; i++)
{
if (xmlcardassigned[i] == false)
{
textoutput("<YELLOW>TV card ID " + cardidpos[i].ToString() + " from backup data could not assigned to a TV server card - card data will be skipped");
}
}
// now import card attributes
//cardList = doc.SelectNodes("/tvserver/servers/server/cards/card");
cardCount = 0;
foreach (XmlNode nodecard in cardList)
{
int cardid = Convert.ToInt32(nodecard.Attributes["IdCard"].Value);
int cardidposition = 0;
for (int j = 1; j <= xmlcardnumbers; j++)
{
if (cardid == cardidpos[j])
{
cardidposition = j;
break;
}
}
if (cardidposition == 0)
{
textoutput("<RED>Card ID position for card number " + cardid.ToString() + "could not be identified - aborting import");
return false;
}
if (xmlcardassigned[cardidposition] == true) //cardmapping does exist
{
try
{
dbserverCard = TVcards[cardmaptranslator[cardidposition]];
cardCount++;
// check for identical card names
if (dbserverCard.Name != nodecard.Attributes["Name"].Value)
{
textoutput("<RED>Card name of cardid " + cardid + " does not match import data - aborting import");
return false;
}
dbserverCard.RecordingFolder = nodecard.Attributes["RecordingFolder"].Value;
checkfilepath(dbserverCard.RecordingFolder, "recording folder card " + cardidposition.ToString());
dbserverCard.TimeShiftFolder = nodecard.Attributes["TimeShiftFolder"].Value;
checkfilepath(dbserverCard.TimeShiftFolder, "time shift folder card " + cardidposition.ToString());
// check for directory existence and write access
dbserverCard.RecordingFormat = Convert.ToInt32(nodecard.Attributes["RecordingFormat"].Value);
dbserverCard.Enabled = Convert.ToBoolean(nodecard.Attributes["Enabled"].Value);
dbserverCard.GrabEPG = Convert.ToBoolean(nodecard.Attributes["GrabEPG"].Value);
dbserverCard.Priority = Convert.ToInt32(nodecard.Attributes["Priority"].Value);
#if(MP100)
//do nothing
#elif(MP101)
//do nothing
#else //MP11BETA or SVN
try
{
dbserverCard.CAM = Convert.ToBoolean(nodecard.Attributes["CAM"].Value);
dbserverCard.PreloadCard = Convert.ToBoolean(nodecard.Attributes["PreloadCard"].Value);
dbserverCard.netProvider = Convert.ToInt32(nodecard.Attributes["netProvider"].Value); //bugfix: added 15.08.2010
}
catch
{
//do nothing
}
#endif
#if(MP13)
try
{
dbserverCard.CAM = Convert.ToBoolean(nodecard.Attributes["StopGraph"].Value);
}
catch //do nothing
{
}
#endif
dbserverCard.CamType = Convert.ToInt32(nodecard.Attributes["CamType"].Value);
dbserverCard.DecryptLimit = Convert.ToInt32(nodecard.Attributes["DecryptLimit"].Value);
dbserverCard.Persist();
//Import card settings for scanning
//NOTFOUND values are filtered out during Tvserverimport
//Analog
PostImport(doc, nodecard, "analog" + dbserverCard.IdCard.ToString() + "Country", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "analog" + dbserverCard.IdCard.ToString() + "Source", "BACKUPSETTINGS_NOTFOUND");
//ATSC
PostImport(doc, nodecard, "atsc" + dbserverCard.IdCard.ToString() + "supportsqam", "BACKUPSETTINGS_NOTFOUND");
//DVBC
PostImport(doc, nodecard, "dvbc" + dbserverCard.IdCard.ToString() + "Country", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbc" + dbserverCard.IdCard.ToString() + "creategroups", "BACKUPSETTINGS_NOTFOUND");
//DVBS
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "SatteliteContext1", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "SatteliteContext2", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "SatteliteContext3", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "SatteliteContext4", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "DisEqc1", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "DisEqc2", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "DisEqc3", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "DisEqc4", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "band1", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "band2", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "band3", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "band4", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "LNB1", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "LNB2", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "LNB3", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "LNB4", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "creategroups", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "creategroupssat", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "createsignalgroup", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "enabledvbs2", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "limitsEnabled", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "motorEnabled", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "motorStepSize", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbs" + dbserverCard.IdCard.ToString() + "selectedMotorSat", "BACKUPSETTINGS_NOTFOUND");
//DVBT
PostImport(doc, nodecard, "dvbt" + dbserverCard.IdCard.ToString() + "Country", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbt" + dbserverCard.IdCard.ToString() + "creategroups", "BACKUPSETTINGS_NOTFOUND");
//DVBIP
PostImport(doc, nodecard, "dvbip" + dbserverCard.IdCard.ToString() + "Service", "BACKUPSETTINGS_NOTFOUND");
PostImport(doc, nodecard, "dvbip" + dbserverCard.IdCard.ToString() + "creategroups", "BACKUPSETTINGS_NOTFOUND");
}
catch (Exception exc)
{
textoutput("<RED>Cards: Failed to add card attributes for card ID " + cardid);
if (DEBUG == true)
{
textoutput("<RED>Exception message is " + exc.Message);
}
return false;
}
}
}
textoutput(cardCount + " Card settings imported");
identicalCards = true; // card and server names do match import file
//Import DiSEqC motor settings
textoutput("Importing DiSEqC motor settings");
motorCount = 0;
XmlNodeList motorList = doc.SelectNodes("/tvserver/DiSEqCmotors/motor");
foreach (XmlNode nodemotor in motorList)
{
if ((CompareVersions(ActualTvServerVersion, "1.0.3.0") == (int)COMPAREVERSION.NEWER) && (CompareVersions(BackupTvServerVersion, "1.0.3.0") == (int)COMPAREVERSION.OLDER))
{
myMessageBox("Satellite file names have been changed in your actual version\nDisEqc settings will not get imported", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
textoutput("<RED>Satellite file names have been changed in your actual version\nDisEqc settings will not get imported");
break;
}
else if ((CompareVersions(BackupTvServerVersion, "1.0.3.0") == (int)COMPAREVERSION.NEWER) && (CompareVersions(ActualTvServerVersion, "1.0.3.0") == (int)COMPAREVERSION.OLDER))
{
myMessageBox("Satellite file names have been changed in your actual version\nDisEqc settings will not get imported", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1);
textoutput("<RED>Satellite file names have been changed in your actual version\nDisEqc settings will not get imported");
break;
}
else // DisEqc settingsb will get imported
{
try
{
motorCount++;
int cardidmotor = Convert.ToInt32(nodemotor.Attributes["IdCard"].Value);
int cardidposition = 0;
for (int j = 1; j <= xmlcardnumbers; j++)
{
if (cardidmotor == cardidpos[j])
{
cardidposition = j;
break;
}
}
if (cardidposition == 0)
{
textoutput("<RED>Card ID position for card number " + cardidmotor.ToString() + "could not be identified - aborting import");
return false;
}
int idcardunmapped = cardidposition;
if (xmlcardassigned[idcardunmapped] == true)
{
//check if satellite does exist
string satelliteName = nodemotor.Attributes["SatelliteName"].Value;
string transponderFileName = nodemotor.Attributes["TransponderFileName"].Value;
Satellite satellite = null;
#if(MP100)
IList allsatellites = Satellite.ListAll();
#elif(MP101)
IList<Satellite> allsatellites = Satellite.ListAll();
#else //MP11BETA or SVN
IList<Satellite> allsatellites = Satellite.ListAll();
#endif
foreach (Satellite sat in allsatellites)
{
if ((sat.SatelliteName == satelliteName) && (sat.TransponderFileName == transponderFileName))
{
satellite = sat;
if (DEBUG == true)
textoutput("Existing satellite id " + satellite.IdSatellite + " found for name " + satellite.SatelliteName);
break;
}
}
if (satellite == null)
{
//create new satellite
satellite = new Satellite(satelliteName, transponderFileName);
if (satellite == null)
{
textoutput("<RED>Could not create new satellite for " + satelliteName + " with transponder filename \n" + transponderFileName);
return false;
}
satellite.Persist();
if (DEBUG == true)
textoutput("New satellite id " + satellite.IdSatellite + " created for name " + satellite.SatelliteName);
}
if (File.Exists(transponderFileName) == false)
{
//try to translate path
if (transponderFileName.Contains("Tuningparameters") == true)
{
int pos = transponderFileName.IndexOf("Tuningparameters");
string partialfilename = transponderFileName.Substring(pos, transponderFileName.Length - pos);
#if(MP100)
string newtransponderFileName = TV_PROGRAM_FOLDER + @"\" + partialfilename;
#elif(MP101)
string newtransponderFileName = TV_PROGRAM_FOLDER + @"\" + partialfilename;
#else //MP11BETA or SVN
string newtransponderFileName = TV_USER_FOLDER + @"\" + partialfilename;
#endif
if (File.Exists(newtransponderFileName) == true)
{
if (DEBUG == true)
textoutput("Renaming transponder filename \n" + transponderFileName + "\nto " + newtransponderFileName);
satellite.TransponderFileName = newtransponderFileName;
satellite.Persist();
}
else
{
textoutput("<RED>Renamed transponder filename " + newtransponderFileName + " does not exist for satellite" + satelliteName);
return false;
}
}
else
{
textoutput("<RED>Transponder filename " + transponderFileName + " does not exist for satellite" + satelliteName);
return false;
}
}
//check if motorsetting does exist
int cardid = TVcards[cardmaptranslator[idcardunmapped]].IdCard;
int position = Convert.ToInt32(nodemotor.Attributes["Position"].Value);
DiSEqCMotor motor = null;
#if(MP100)
IList allmotors = DiSEqCMotor.ListAll();
#elif(MP101)
IList<DiSEqCMotor> allmotors = DiSEqCMotor.ListAll();
#else //MP11BETA or SVN
IList<DiSEqCMotor> allmotors = DiSEqCMotor.ListAll();
#endif
foreach (DiSEqCMotor mot in allmotors)
{
if ((mot.IdCard == cardid) && (mot.IdSatellite == satellite.IdSatellite))
{
motor = mot;
if (DEBUG == true)
textoutput("Existing motor id " + motor.IdDiSEqCMotor + " found for satellite " + satellite.SatelliteName + " and card id " + cardid);
break;
}
}
if (motor == null)
{
//create new motor
motor = new DiSEqCMotor(cardid, satellite.IdSatellite, position);
if (DEBUG == true)
textoutput("New DiSEqC motor created for satellite " + satellite.SatelliteName + " and card id " + cardid);
}
//update values
motor.IdCard = cardid;
motor.IdSatellite = satellite.IdSatellite;
motor.Position = position;
motor.Persist();
if (DEBUG == true)
textoutput("DiSEqC motor id " + motor.IdDiSEqCMotor + " wirth cardid " + motor.IdCard + " and position " + motor.Position + " has been processed successfully");
}
}
catch (Exception exc)
{
motorCount--;
textoutput("<RED>Failed to add/update DiSEqC Motor ");
if (DEBUG == true)
{
textoutput("<RED>Exception message is " + exc.Message);
}
return false;
}
}
}
textoutput(motorCount + " DiSEqC motor settings imported");
// Hybrid Settings
textoutput("Importing hybrid card settings");
// Delete old groups
#if(MP100)
IList hybridcardgroups = CardGroup.ListAll();
#elif(MP101)
IList<CardGroup> hybridcardgroups = CardGroup.ListAll();
#else //MP11BETA or SVN
IList<CardGroup> hybridcardgroups = CardGroup.ListAll();
#endif
int cardgroupCount = 0;
foreach (CardGroup hybridcardgroup in hybridcardgroups)
{
cardgroupCount++;
try
{
hybridcardgroup.Delete();
}
catch (Exception exc)
{
textoutput("<RED>Failed to delete hybrid card group " + hybridcardgroup.IdCardGroup + " named " + hybridcardgroup.Name);
if (DEBUG == true)
{
textoutput("<RED>Exception message is " + exc.Message);
}
return false;
}
}
textoutput(cardgroupCount + " Old hybrid groups deleted");
XmlNodeList cardgroupList = doc.SelectNodes("/tvserver/HybridCardGroups/HybridCardGroup");
cardgroupCount = 0;
foreach (XmlNode nodecardgroup in cardgroupList)
{
cardgroupCount++;
int newIdCardGroup = Convert.ToInt32(nodecardgroup.Attributes["IdCardGroup"].Value);
string newname = nodecardgroup.Attributes["CardGroupName"].Value;
try
{
CardGroup newcardgroup = new CardGroup(newIdCardGroup, newname);
newcardgroup.Persist();
}
catch (Exception exc)
{
textoutput("<RED>CardGroups: Failed to add card group attributes for card group " + newIdCardGroup + " named " + newname);
if (DEBUG == true)
{
textoutput("<RED>Exception message is " + exc.Message);
}
return false;
}
}
textoutput(cardgroupCount + " hybrid groups imported");
XmlNodeList cardgroupmapList = doc.SelectNodes("/tvserver/HybridCardGroupMaps/HybridCardGroupMap");
int cardgroupmapCount = 0;
foreach (XmlNode nodecardgroupmap in cardgroupmapList)
{
cardgroupmapCount++;
int newIdCardGroupMap = Convert.ToInt32(nodecardgroupmap.Attributes["IdMapping"].Value);
int newIdCardGroup = Convert.ToInt32(nodecardgroupmap.Attributes["IdCardGroup"].Value);
//int newIdCardunmapped = Convert.ToInt32(nodecardgroupmap.Attributes["IdCard"].Value);
int cardid = Convert.ToInt32(nodecardgroupmap.Attributes["IdCard"].Value);
int cardidposition = 0;
for (int j = 1; j <= xmlcardnumbers; j++)
{
if (cardid == cardidpos[j])
{
cardidposition = j;
break;
}
}
if (cardidposition == 0)
{
textoutput("<RED>Card ID position for card number " + cardid.ToString() + "could not be identified - aborting import");
return false;
}
int newIdCardunmapped = cardidposition;
string HybridGroupName = nodecardgroupmap.Attributes["HybridGroupName"].Value;
if (xmlcardassigned[newIdCardunmapped] == true) //cardmapping does exist
{
int newIdCard = TVcards[cardmaptranslator[newIdCardunmapped]].IdCard;
try
{
POSTIMPORT += "CARDGROUPMAP\t" + newIdCard + "\t" + newIdCardGroup + "\t" + HybridGroupName + "\n";
if (DEBUG == true)
{
textoutput("newIdCard =" + newIdCard + " newIdCardGroup=" + newIdCardGroup);
}
}
catch (Exception exc)
{
textoutput("<RED>CardGroupMappings: Failed to add card group mapping " + newIdCardGroupMap + "Error: " + exc.Message);
}
}
}
textoutput(cardgroupCount + " Hybrid Groups with " + cardgroupmapCount + " Card Mappings imported");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_Servers);
}
if (identicalCards == false) // do not import channelmappings if cards and servers are not identical from importfile
{
channelcardmappings = false;
textoutput("<YELLOW>Servers and cards box unchecked - will not import channel mappings");
}
// Import Channels
if (channels == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_Channels);
textoutput("Importing channel settings - Please be patient");
XmlNodeList channelList = doc.SelectNodes("/tvserver/channels/channel");
channelCount = 0;
foreach (XmlNode nodeChannel in channelList)
{
string name = nodeChannel.Attributes["DisplayName"].Value; //use only displayname
int IdChannel = Int32.Parse(GetNodeAttribute(nodeChannel, "IdChannel", "0"));
try
{
channelCount++;
Channel dbChannel = null;
XmlNodeList tuningList = nodeChannel.SelectNodes("TuningDetails/tune");
XmlNodeList mappingList = nodeChannel.SelectNodes("mappings/map");
bool grabEpg = (GetNodeAttribute(nodeChannel, "GrabEpg", "True") == "True");
bool isRadio = (GetNodeAttribute(nodeChannel, "IsRadio", "False") == "True");
bool isTv = (GetNodeAttribute(nodeChannel, "IsTv", "True") == "True");
DateTime lastGrabTime = DateTime.ParseExact("2000-01-01 00:00:00", "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
DateTime totalTimeWatched = DateTime.ParseExact("2000-01-01 00:00:00", "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
try
{
lastGrabTime = DateTime.ParseExact(GetNodeAttribute(nodeChannel, "LastGrabTime", "1900-01-01 00:00:00"), "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
totalTimeWatched = DateTime.ParseExact(GetNodeAttribute(nodeChannel, "TotalTimeWatched", "1900-01-01 00:00:00"), "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
}
catch
{
textoutput("<RED>Date and time could not be parsed for LastGrabTime and TotalTimeWatched - skipping values");
}
int sortOrder = Int32.Parse(GetNodeAttribute(nodeChannel, "SortOrder", "0"));
int timesWatched = Int32.Parse(GetNodeAttribute(nodeChannel, "TimesWatched", "0"));
bool visibileInGuide = (GetNodeAttribute(nodeChannel, "VisibleInGuide", "True") == "True");
bool FreeToAir = (GetNodeAttribute(nodeChannel, "FreeToAir", "True") == "True");
string displayName = GetNodeAttribute(nodeChannel, "DisplayName", name);
bool epgHasGaps = (GetNodeAttribute(nodeChannel, "EpgHasGaps", "False") == "True");
string externalId = GetNodeAttribute(nodeChannel, "ExternalId", "0");
// rtv: since analog allows NOT to merge channels we need to take care of this. US users e.g. have multiple stations named "Sport" with different tuningdetails.
// using AddChannel would incorrectly "merge" these totally different channels.
// see this: http://forum.team-mediaportal.com/1-0-rc1-svn-builds-271/importing-exported-channel-list-groups-channels-39368/
/*
if (DEBUG == true)
{
Log.Info("TvChannels: Adding {0}. channel: {1} ({2})", channelCount, name, displayName);
}*/
dbChannel = layer.AddNewChannel(name);
if (dbChannel == null)
{
textoutput("<RED>Failed to add channel " + name + " - aborting import");
return false;
}
dbChannel.GrabEpg = grabEpg;
dbChannel.IsRadio = isRadio;
dbChannel.IsTv = isTv;
dbChannel.LastGrabTime = lastGrabTime;
dbChannel.SortOrder = sortOrder;
dbChannel.TimesWatched = timesWatched;
dbChannel.TotalTimeWatched = totalTimeWatched;
dbChannel.VisibleInGuide = visibileInGuide;
#if (MP12)
#else
try
{
dbChannel.FreeToAir = FreeToAir;
}
catch //do nothing
{
}
#endif
dbChannel.DisplayName = displayName; //possible bug
dbChannel.EpgHasGaps = epgHasGaps;
dbChannel.ExternalId = externalId;
#if(MP13)
try
{
dbChannel.ChannelNumber = Int32.Parse(GetNodeAttribute(nodeChannel, "ChannelNumber", "10000"));
//Ilist string Groupnames
//Group CurrentGroup
//program CurrentProgram
//program NextProgram
}
catch //do nothing
{
}
#endif
dbChannel.Persist();
if (channelcardmappings == true)
{
foreach (XmlNode nodeMap in mappingList)
{
int idCard = Int32.Parse(nodeMap.Attributes["IdCard"].Value);
//get xml position
bool mapflag = false;
for (int j = 1; j <= allXMLcards; j++)
{
if (idCard == cardidpos[j]) //position of card can be different to id
{
if (xmlcardassigned[cardmaptranslator[j]] == true)
{
try
{
layer.MapChannelToCard(TVcards[cardmaptranslator[j]], dbChannel, false);
mapflag = true;
}
catch (Exception exe)
{
textoutput("<RED>Failed to map channel " + dbChannel.DisplayName + " to card id " + cardmaptranslator[j].ToString());
textoutput("<RED>Exception message is " + exe.Message);
}
}
}
}
if (mapflag == false)
{
textoutput("<RED>Failed to map channel " + dbChannel.DisplayName + " to any card");
}
}
}
foreach (XmlNode nodeTune in tuningList)
{
#if (MP12)
#else
int pcrPid = -1;
int audioPid = -1;
int videoPid = -1;
try
{
pcrPid = Int32.Parse(nodeTune.Attributes["PcrPid"].Value);
}
catch { }
try
{
audioPid = Int32.Parse(nodeTune.Attributes["AudioPid"].Value);
}
catch { }
try
{
videoPid = Int32.Parse(GetNodeAttribute(nodeTune, "VideoPid", "-1"));
}
catch { }
#endif
int bandwidth = Int32.Parse(nodeTune.Attributes["Bandwidth"].Value);
int channelNumber = Int32.Parse(nodeTune.Attributes["ChannelNumber"].Value);
int channelType = Int32.Parse(nodeTune.Attributes["ChannelType"].Value);
int countryId = Int32.Parse(nodeTune.Attributes["CountryId"].Value);
int diseqc = Int32.Parse(nodeTune.Attributes["Diseqc"].Value);
bool fta = (nodeTune.Attributes["FreeToAir"].Value == "True");
int frequency = Int32.Parse(nodeTune.Attributes["Frequency"].Value);
int majorChannel = Int32.Parse(nodeTune.Attributes["MajorChannel"].Value);
int minorChannel = Int32.Parse(nodeTune.Attributes["MinorChannel"].Value);
int modulation = Int32.Parse(nodeTune.Attributes["Modulation"].Value);
name = nodeTune.Attributes["Name"].Value;
int networkId = Int32.Parse(nodeTune.Attributes["NetworkId"].Value);
int pmtPid = Int32.Parse(nodeTune.Attributes["PmtPid"].Value);
int polarisation = Int32.Parse(nodeTune.Attributes["Polarisation"].Value);
string provider = GetNodeAttribute(nodeTune, "Provider", "");
int serviceId = Int32.Parse(nodeTune.Attributes["ServiceId"].Value);
int switchingFrequency = Int32.Parse(nodeTune.Attributes["SwitchingFrequency"].Value);
int symbolrate = Int32.Parse(nodeTune.Attributes["Symbolrate"].Value);
int transportId = Int32.Parse(nodeTune.Attributes["TransportId"].Value);
int tuningSource = Int32.Parse(GetNodeAttribute(nodeTune, "TuningSource", "0"));
int videoSource = Int32.Parse(GetNodeAttribute(nodeTune, "VideoSource", "0"));
int audioSource = Int32.Parse(GetNodeAttribute(nodeTune, "AudioSource", "0"));
int SatIndex = Int32.Parse(GetNodeAttribute(nodeTune, "SatIndex", "-1"));
int InnerFecRate = Int32.Parse(GetNodeAttribute(nodeTune, "InnerFecRate", "-1"));
int band = Int32.Parse(GetNodeAttribute(nodeTune, "Band", "0"));
int pilot = Int32.Parse(GetNodeAttribute(nodeTune, "Pilot", "-1"));
int rollOff = Int32.Parse(GetNodeAttribute(nodeTune, "RollOff", "-1"));
string url = GetNodeAttribute(nodeTune, "Url", "");
int bitrate = Int32.Parse(GetNodeAttribute(nodeTune, "Bitrate", "0"));
bool isVCRSignal = (GetNodeAttribute(nodeChannel, "IsVCRSignal", "False") == "True");
switch (channelType)
{
case 0: //AnalogChannel
AnalogChannel analogChannel = new AnalogChannel();
if (analogChannel == null)
{
textoutput("<RED>Could not create analog channel for " + name);
return false;
}
analogChannel.ChannelNumber = channelNumber;
analogChannel.Country = collection.Countries[countryId];
analogChannel.Frequency = frequency;
analogChannel.IsRadio = isRadio;
analogChannel.IsTv = isTv;
analogChannel.Name = name;
analogChannel.TunerSource = (TunerInputType)tuningSource;
analogChannel.VideoSource = (AnalogChannel.VideoInputType)videoSource;
#if(MP100)
//do nothing
#elif(MP101)
//do nothing
#else //MP11BETA or SVN
analogChannel.AudioSource = (AnalogChannel.AudioInputType)audioSource;
analogChannel.IsVCRSignal = isVCRSignal;
#endif
layer.AddTuningDetails(dbChannel, analogChannel);
if (DEBUG)
Log.Info("TvChannels: Added tuning details for analog channel: {0} number: {1}", name, channelNumber);
break;
case 1: //ATSCChannel
ATSCChannel atscChannel = new ATSCChannel();
if (atscChannel == null)
{
textoutput("<RED>Could not create ATSC channel for " + name);
return false;
}
atscChannel.MajorChannel = majorChannel;
atscChannel.MinorChannel = minorChannel;
atscChannel.PhysicalChannel = channelNumber;
atscChannel.LogicalChannelNumber = channelNumber;
atscChannel.FreeToAir = fta;
atscChannel.Frequency = frequency;
atscChannel.IsRadio = isRadio;
atscChannel.IsTv = isTv;
atscChannel.Name = name;
atscChannel.NetworkId = networkId;
#if (MP12)
#else
if (pcrPid > -1)
atscChannel.PcrPid = pcrPid;
if (audioPid > -1)
atscChannel.AudioPid = audioPid;
if (videoPid > -1)
atscChannel.VideoPid = videoPid;
#endif
atscChannel.PmtPid = pmtPid;
atscChannel.Provider = provider;
atscChannel.ServiceId = serviceId;
//atscChannel.SymbolRate = symbolrate;
atscChannel.TransportId = transportId;
atscChannel.ModulationType = (ModulationType)modulation;
layer.AddTuningDetails(dbChannel, atscChannel);
if (DEBUG)
Log.Info("TvChannels: Added tuning details for ATSC channel: {0} number: {1} provider: {2}", name, channelNumber, provider);
break;
case 2: //DVBCChannel
DVBCChannel dvbcChannel = new DVBCChannel();
if (dvbcChannel == null)
{
textoutput("<RED>Could not create DVB channel for " + name);
return false;
}
dvbcChannel.ModulationType = (ModulationType)modulation;
dvbcChannel.FreeToAir = fta;
dvbcChannel.Frequency = frequency;
dvbcChannel.IsRadio = isRadio;
dvbcChannel.IsTv = isTv;
dvbcChannel.Name = name;
dvbcChannel.NetworkId = networkId;
#if (MP12)
#else
if (pcrPid > -1)
dvbcChannel.PcrPid = pcrPid;
if (audioPid > -1)
dvbcChannel.AudioPid = audioPid;
if (videoPid > -1)
dvbcChannel.VideoPid = videoPid;
#endif
dvbcChannel.PmtPid = pmtPid;
dvbcChannel.Provider = provider;
dvbcChannel.ServiceId = serviceId;
dvbcChannel.SymbolRate = symbolrate;
dvbcChannel.TransportId = transportId;
dvbcChannel.LogicalChannelNumber = channelNumber;
layer.AddTuningDetails(dbChannel, dvbcChannel);
if (DEBUG)
Log.Info("TvChannels: Added tuning details for DVB-C channel: {0} provider: {1}", name, provider);
break;
case 3: //DVBSChannel
DVBSChannel dvbsChannel = new DVBSChannel();
if (dvbsChannel == null)
{
textoutput("<RED>Could not create DVBS channel for " + name);
return false;
}
dvbsChannel.DisEqc = (DisEqcType)diseqc;
dvbsChannel.Polarisation = (Polarisation)polarisation;
dvbsChannel.SwitchingFrequency = switchingFrequency;
dvbsChannel.FreeToAir = fta;
dvbsChannel.Frequency = frequency;
dvbsChannel.IsRadio = isRadio;
dvbsChannel.IsTv = isTv;
dvbsChannel.Name = name;
dvbsChannel.NetworkId = networkId;
#if (MP12)
#else
if (pcrPid > -1)
dvbsChannel.PcrPid = pcrPid;
if (audioPid > -1)
dvbsChannel.AudioPid = audioPid;
if (videoPid > -1)
dvbsChannel.VideoPid = videoPid;
#endif
dvbsChannel.PmtPid = pmtPid;
dvbsChannel.Provider = provider;
dvbsChannel.ServiceId = serviceId;
dvbsChannel.SymbolRate = symbolrate;
dvbsChannel.TransportId = transportId;
dvbsChannel.SatelliteIndex = SatIndex;
dvbsChannel.ModulationType = (ModulationType)modulation;
dvbsChannel.InnerFecRate = (BinaryConvolutionCodeRate)InnerFecRate;
dvbsChannel.BandType = (BandType)band;
dvbsChannel.Pilot = (Pilot)pilot;
dvbsChannel.Rolloff = (RollOff)rollOff;
dvbsChannel.LogicalChannelNumber = channelNumber;
layer.AddTuningDetails(dbChannel, dvbsChannel);
if (DEBUG)
Log.Info("TvChannels: Added tuning details for DVB-S channel: {0} provider: {1}", name, provider);
break;
case 4: //DVBTChannel
DVBTChannel dvbtChannel = new DVBTChannel();
if (dvbtChannel == null)
{
textoutput("<RED>Could not create DVBT channel for " + name);
return false;
}
dvbtChannel.BandWidth = bandwidth;
dvbtChannel.FreeToAir = fta;
dvbtChannel.Frequency = frequency;
dvbtChannel.IsRadio = isRadio;
dvbtChannel.IsTv = isTv;
dvbtChannel.Name = name;
dvbtChannel.NetworkId = networkId;
#if (MP12)
#else
if (pcrPid > -1)
dvbtChannel.PcrPid = pcrPid;
if (audioPid > -1)
dvbtChannel.AudioPid = audioPid;
if (videoPid > -1)
dvbtChannel.VideoPid = videoPid;
#endif
dvbtChannel.PmtPid = pmtPid;
dvbtChannel.Provider = provider;
dvbtChannel.ServiceId = serviceId;
dvbtChannel.TransportId = transportId;
dvbtChannel.LogicalChannelNumber = channelNumber;
layer.AddTuningDetails(dbChannel, dvbtChannel);
if (DEBUG)
Log.Info("TvChannels: Added tuning details for DVB-T channel: {0} provider: {1}", name, provider);
break;
case 5: //Webstream
layer.AddWebStreamTuningDetails(dbChannel, url, bitrate);
if (DEBUG)
Log.Info("TvChannels: Added wWeb stream: {0} ", url);
break;
//used IP channel from mvedrina patch only for MP1.1 and SVN
#if(MP100)
//do nothing
#elif(MP101)
//do nothing
#else //MP11BETA or SVN
case 7: //DVBIPChannel
DVBIPChannel dvbipChannel = new DVBIPChannel();
#if (MP12)
#else
if (pcrPid > -1)
dvbipChannel.PcrPid = pcrPid;
if (audioPid > -1)
dvbipChannel.AudioPid = audioPid;
if (videoPid > -1)
dvbipChannel.VideoPid = videoPid;
#endif
dvbipChannel.FreeToAir = fta;
dvbipChannel.Frequency = frequency;
dvbipChannel.IsRadio = isRadio;
dvbipChannel.IsTv = isTv;
dvbipChannel.LogicalChannelNumber = channelNumber;
dvbipChannel.Name = name;
dvbipChannel.NetworkId = networkId;
dvbipChannel.PmtPid = pmtPid;
dvbipChannel.Provider = provider;
dvbipChannel.ServiceId = serviceId;
dvbipChannel.TransportId = transportId;
dvbipChannel.Url = url;
layer.AddTuningDetails(dbChannel, dvbipChannel);
if (DEBUG)
Log.Info("TvChannels: Added tuning details for DVB-IP channel: {0} provider: {1}", name, provider);
break;
#endif
}
}
}
catch (Exception exc)
{
textoutput("<RED>TvChannels: Failed to add channel " + IdChannel + " name " + name);
if (DEBUG == true)
{
textoutput("<RED>Exception message is " + exc.Message);
}
return false;
}
}
textoutput(channelCount + " channel settings imported");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_Channels);
}
if (schedules == true)
{
// begin import schedule settings
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_Schedules);
textoutput("Importing schedule settings");
XmlNodeList scheduleList = doc.SelectNodes("/tvserver/schedules/schedule");
scheduleCount = 0;
foreach (XmlNode nodeSchedule in scheduleList)
{
string programName = nodeSchedule.Attributes["ProgramName"].Value;
string displayname = nodeSchedule.Attributes["DisplayName"].Value;
int idSchedule = Int32.Parse(nodeSchedule.Attributes["IdSchedule"].Value);
try
{
scheduleCount++;
Channel tmpchannel = mygetChannelbyName(displayname);
if (tmpchannel == null)
{
textoutput("<RED>Channel " + displayname + " (Display: " + displayname + ") not found for schedule " + idSchedule);
}
int idChannel = tmpchannel.IdChannel;
DateTime startTime = DateTime.ParseExact(nodeSchedule.Attributes["StartTime"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
DateTime endTime = DateTime.ParseExact(nodeSchedule.Attributes["EndTime"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
int scheduletype = Int32.Parse(nodeSchedule.Attributes["ScheduleType"].Value);
Schedule schedule = layer.AddSchedule(idChannel, programName, startTime, endTime, scheduletype);
schedule.ScheduleType = scheduletype; //do not remove! AddSchedule(idChannel, programName, startTime,endTime,scheduletype); does not work!
schedule.KeepDate = DateTime.ParseExact(nodeSchedule.Attributes["KeepDate"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
schedule.PreRecordInterval = Int32.Parse(nodeSchedule.Attributes["PreRecordInterval"].Value);
schedule.PostRecordInterval = Int32.Parse(nodeSchedule.Attributes["PostRecordInterval"].Value);
schedule.Priority = Int32.Parse(nodeSchedule.Attributes["Priority"].Value);
schedule.Quality = Int32.Parse(nodeSchedule.Attributes["Quality"].Value);
schedule.Directory = nodeSchedule.Attributes["Directory"].Value;
schedule.KeepMethod = Int32.Parse(nodeSchedule.Attributes["KeepMethod"].Value);
schedule.MaxAirings = Int32.Parse(nodeSchedule.Attributes["MaxAirings"].Value);
schedule.RecommendedCard = 0;
try
{
int unmappedcard = Int32.Parse(nodeSchedule.Attributes["RecommendedCard"].Value);
if (xmlcardassigned[unmappedcard] == true) //cardmapping does exist
{
schedule.RecommendedCard = cardmaptranslator[unmappedcard];
}
}
catch// do nothing in case of error: recommended card = 0
{
}
schedule.Series = (GetNodeAttribute(nodeSchedule, "Series", "False") == "True");
schedule.BitRateMode = (VIDEOENCODER_BITRATE_MODE)Int32.Parse(GetNodeAttribute(nodeSchedule, "BitRateMode", "-1"));
schedule.QualityType = (QualityType)Int32.Parse(GetNodeAttribute(nodeSchedule, "QualityType", "1"));
try
{
schedule.Canceled = DateTime.ParseExact(nodeSchedule.Attributes["Canceled"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
}
catch
{
}
schedule.Persist();
}
catch (Exception ex)
{
scheduleCount--;
textoutput("<RED>Could not create schedule " + idSchedule + " for " + displayname + " (Display: " + displayname + ") with program " + programName);
if (DEBUG)
{
textoutput("<RED>Exception message is " + ex.Message);
}
//return false;
}
}
textoutput(scheduleCount + " schedule settings imported");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_Schedules);
}
// Import programs
if (epg == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_EPG);
textoutput("Importing program settings - please be patient");
XmlNodeList programList = doc.SelectNodes("/tvserver/programs/program");
programCount = 0;
foreach (XmlNode nodeProgram in programList)
{
int idProgram = Int32.Parse(nodeProgram.Attributes["IdProgram"].Value);
//string channelname = nodeProgram.Attributes["ChannelName"].Value;
string displayname = nodeProgram.Attributes["DisplayName"].Value;
string title = nodeProgram.Attributes["Title"].Value;
try
{
programCount++;
string description = nodeProgram.Attributes["Description"].Value;
string classification = nodeProgram.Attributes["Classification"].Value;
string episodeNum = nodeProgram.Attributes["EpisodeNum"].Value;
#if(MP100)
//do nothing
#elif(MP101)
//do nothing
#else //MP11BETA or SVN
string episodeName = "";
string episodePart = "";
try
{
episodeName = nodeProgram.Attributes["EpisodeName"].Value;
episodePart = nodeProgram.Attributes["EpisodePart"].Value;
}
catch
{
textoutput("<YELLOW>Warning: Episode name or part not found - will set to \"notavailable\" ");
episodeName = "not available";
episodePart = "not available";
}
#endif
string genre = nodeProgram.Attributes["Genre"].Value;
string seriesNum = nodeProgram.Attributes["SeriesNum"].Value;
DateTime startTime = DateTime.ParseExact(nodeProgram.Attributes["StartTime"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
if (startTime.CompareTo(DateTime.Now) > 0)
{
DateTime endTime = DateTime.ParseExact(nodeProgram.Attributes["EndTime"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
DateTime originalAirDate = DateTime.ParseExact(nodeProgram.Attributes["OriginalAirDate"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
bool notify = false;
try
{
notify = Convert.ToBoolean(nodeProgram.Attributes["Notify"].Value);
}
catch //do nothing
{
}
int parentalRating = Int32.Parse(nodeProgram.Attributes["ParentalRating"].Value);
int starRating = Int32.Parse(nodeProgram.Attributes["StarRating"].Value);
Channel tmpchannel = mygetChannelbyName(displayname);
if (tmpchannel == null)
{
textoutput("<RED>Channel " + displayname + " (Display: " + displayname + ") not found for program " + idProgram);
}
int idChannel = tmpchannel.IdChannel;
#if(MP100)
Program program = new Program(idChannel, startTime, endTime, title, description, genre, notify, originalAirDate, seriesNum, episodeNum, starRating, classification, parentalRating);
#elif (MP101)
Program program = new Program(idChannel, startTime, endTime, title, description, genre, notify, originalAirDate, seriesNum, episodeNum, starRating, classification, parentalRating);
#elif (MP11BETA)
Program program = new Program(idChannel, startTime, endTime, title, description, genre, notify, originalAirDate, seriesNum, episodeNum, episodeName, episodePart, starRating, classification, parentalRating);
#else //SVN 1.0.4.24281
Program program = new Program(idChannel, startTime, endTime, title, description, genre, Program.ProgramState.None, originalAirDate, seriesNum, episodeNum, episodeName, episodePart, starRating, classification, parentalRating);
#endif
program.Persist();
/*
if (DEBUG)
Log.Info("Added program title: {0} on channel: {1} display {2}", title, channelname,displayname);
*/
}
else
{
programCount++;
}
}
catch (Exception ex)
{
programCount--;
textoutput("<RED>Could not create program " + idProgram + " for title " + title + " with program " + displayname + " (Display: " + displayname + ")");
if (DEBUG)
{
textoutput("<RED>Exception message is " + ex.Message);
}
//return false;
}
}
textoutput(programCount + " program settings imported");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_EPG);
}
// Import recordings
if (recordings == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_Recordings);
textoutput("Importing recording settings");
XmlNodeList recordingList = doc.SelectNodes("/tvserver/recordings/recording");
recordingCount = 0;
foreach (XmlNode nodeRecording in recordingList)
{
string fileName = nodeRecording.Attributes["FileName"].Value;
string title = nodeRecording.Attributes["Title"].Value;
int idRecording = Int32.Parse(nodeRecording.Attributes["IdRecording"].Value);
try
{
recordingCount++;
string description = nodeRecording.Attributes["Description"].Value;
string genre = nodeRecording.Attributes["Genre"].Value;
//string channelname = nodeRecording.Attributes["ChannelName"].Value;
string displayname = string.Empty;
try
{
displayname = nodeRecording.Attributes["DisplayName"].Value;
}
catch
{
}
Channel tmpchannel = mygetChannelbyName(displayname);
int idChannel = -1;
if (tmpchannel == null)
{
textoutput("<RED>Channel " + displayname + " (Display: " + displayname + ") not found for recording " + idRecording);
}
else
{
idChannel = tmpchannel.IdChannel;
}
string servername = nodeRecording.Attributes["ServerName"].Value;
Server tmpserver = mygetServerbyName(servername);
if (tmpserver == null)
{
textoutput("<RED>Server " + servername + " not found for recording " + idRecording);
}
int idServer = tmpserver.IdServer;
DateTime startTime = DateTime.ParseExact(nodeRecording.Attributes["StartTime"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
DateTime endTime = DateTime.ParseExact(nodeRecording.Attributes["EndTime"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
//, , , episodePart
string episodeName = "";
try
{
episodeName = nodeRecording.Attributes["EpisodeName"].Value;
}
catch
{
}
string seriesNum = "";
try
{
seriesNum = nodeRecording.Attributes["SeriesNum"].Value;
}
catch
{
}
string episodeNum = "";
try
{
episodeNum = nodeRecording.Attributes["EpisodeNum"].Value;
}
catch
{
}
string episodePart = "";
try
{
episodePart = nodeRecording.Attributes["EpisodePart"].Value;
}
catch
{
}
DateTime keepUntilDate = DateTime.ParseExact(nodeRecording.Attributes["KeepUntilDate"].Value, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
int keepUntil = Int32.Parse(nodeRecording.Attributes["KeepUntil"].Value);
int timesWatched = Int32.Parse(nodeRecording.Attributes["TimesWatched"].Value);
#if(SVN)
Recording recording = new Recording(idChannel, 0, false, startTime, endTime, title, description, genre, fileName, keepUntil, keepUntilDate, timesWatched, idServer, episodeName, seriesNum, episodeNum, episodePart);
//idChannel, idSchedule, isRecording, startTime
#elif(MP11BETA)
Recording recording = new Recording(idChannel, startTime, endTime, title, description, genre, fileName, keepUntil, keepUntilDate, timesWatched, idServer, episodeName, seriesNum, episodeNum, episodePart);
#else
Recording recording = new Recording(idChannel, startTime, endTime, title, description, genre, fileName, keepUntil, keepUntilDate, timesWatched, idServer);
#endif
try
{
recording.StopTime = Int32.Parse(nodeRecording.Attributes["StopTime"].Value);
}
catch
{
}
recording.Persist();
if (File.Exists(fileName) == false)
{
textoutput("<YELLOW>Filename " + fileName + " does not exist for recording " + title + " - recording is not added to database");
recording.Delete();
recordingCount--;
}
}
catch (Exception ex)
{
recordingCount--;
textoutput("<RED>Could not create recording " + idRecording + " for title " + title + " and file " + fileName + " - use \"Recording -> database ImportedFromTypeLibAttribute\" for manual import");
if (DEBUG)
{
textoutput("<RED>Exception message is " + ex.Message);
}
//return false;
}
}
textoutput(recordingCount + " recording settings imported");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_Recordings);
}
// Import channel groups
if (tvgroups == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_TvGroups);
textoutput("Importing channel group settings");
XmlNodeList channelGroupList = doc.SelectNodes("/tvserver/channelgroups/channelgroup");
channelGroupCount = 0;
foreach (XmlNode nodeChannelGroup in channelGroupList)
{
int idGroup = Int32.Parse(nodeChannelGroup.Attributes["IdGroup"].Value);
string groupName = nodeChannelGroup.Attributes["GroupName"].Value;
try
{
channelGroupCount++;
int mapcount = 0;
int groupSortOrder = Int32.Parse(nodeChannelGroup.Attributes["SortOrder"].Value);
ChannelGroup group = layer.GetGroupByName(groupName, groupSortOrder);
if (group == null)
group = new ChannelGroup(groupName, groupSortOrder);
group.Persist();
XmlNodeList mappingList = nodeChannelGroup.SelectNodes("mappings/map");
foreach (XmlNode nodeMap in mappingList)
{
mapcount++;
//string channelname = nodeMap.Attributes["ChannelName"].Value;
string displayname = nodeMap.Attributes["DisplayName"].Value;
Channel channel = mygetChannelbyName(displayname);
int idMap = Int32.Parse(GetNodeAttribute(nodeMap, "IdMap", "0"));
int sortOrder = Int32.Parse(GetNodeAttribute(nodeMap, "SortOrder", "9999"));
/*
Log.Debug("**************************");
Log.Debug("group.GroupName=" + group.GroupName);
Log.Debug("displayname=" + displayname);
Log.Debug("sortOrder=" + sortOrder.ToString());
Log.Debug("idMap=" + idMap.ToString());*/
if (channel != null)
{
//GroupMap map = new GroupMap(group.IdGroup, channel.IdChannel, sortOrder); //!!!!!!!sortorder is overwritten when setuptv is exited
//POSTIMPORT += "GROUPMAPSORTORDER\t" + group.IdGroup.ToString() + "\t" + channel.IdChannel.ToString() + "\t" + sortOrder.ToString() + "\n";
GroupMap map = new GroupMap(group.IdGroup, channel.IdChannel, sortOrder);
map.SortOrder = sortOrder;
map.Persist();
/*map.SortOrder = sortOrder;
Log.Debug("map.IsPersisted=" + map.IsPersisted.ToString());
map.Persist();
Log.Debug("map.SortOrder=" + map.SortOrder.ToString());
Log.Debug("map.IdMap=" + map.IdMap.ToString());
Log.Debug("map.IsPersisted=" + map.IsPersisted.ToString());*/
}
else
{
textoutput("<YELLOW>Channel " + displayname + " (Display: " + displayname + ") could not be assigned to group " + groupName + " in map number " + idMap);
}
Log.Debug("End");
}
textoutput(mapcount + " channels assigned to group " + groupName);
}
catch (Exception exc)
{
textoutput("<RED>TvChannels: Failed to add group " + idGroup + " group name " + groupName);
if (DEBUG == true)
{
textoutput("<RED>Exception message is " + exc.Message);
}
//return false;
}
}
textoutput(channelGroupCount + " channel group settings imported");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_TvGroups);
}
// Import Radio channel groups
if (radiogroups == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_Radiogroups);
textoutput("Importing radio channel group settings");
XmlNodeList radiochannelGroupList = doc.SelectNodes("/tvserver/radiochannelgroups/radiochannelgroup");
radiochannelGroupCount = 0;
foreach (XmlNode radionodeChannelGroup in radiochannelGroupList)
{
int idGroup = Int32.Parse(radionodeChannelGroup.Attributes["IdGroup"].Value);
string groupName = radionodeChannelGroup.Attributes["GroupName"].Value;
try
{
radiochannelGroupCount++;
string radiogroupName = radionodeChannelGroup.Attributes["GroupName"].Value;
int radiogroupSortOrder = Int32.Parse(radionodeChannelGroup.Attributes["SortOrder"].Value);
RadioChannelGroup radiogroup = layer.GetRadioChannelGroupByName(radiogroupName);
if (radiogroup == null)
radiogroup = new RadioChannelGroup(radiogroupName, radiogroupSortOrder);
radiogroup.Persist();
XmlNodeList radiomappingList = radionodeChannelGroup.SelectNodes("mappings/radiomap");
int mapcount = 0;
foreach (XmlNode radionodeMap in radiomappingList)
{
mapcount++;
//string channelname = radionodeMap.Attributes["ChannelName"].Value;
string displayname = radionodeMap.Attributes["DisplayName"].Value;
Channel channel = mygetChannelbyName(displayname);
int sortOrder = Int32.Parse(GetNodeAttribute(radionodeMap, "SortOrder", "9999"));
int idMap = Int32.Parse(GetNodeAttribute(radionodeMap, "IdMap", "0"));
if (channel != null)
{
RadioGroupMap radiomap = new RadioGroupMap(radiogroup.IdGroup, channel.IdChannel, sortOrder);
radiomap.SortOrder = sortOrder;
radiomap.Persist();
}
else
{
textoutput("<YELLOW>Channel " + displayname + " (Display: " + displayname + ") could not be assigned to group " + radiogroupName + " in map number " + idMap);
}
}
textoutput(mapcount + " channels assigned to group " + groupName);
}
catch (Exception exc)
{
textoutput("<RED>RadioChannels: Failed to add radio group " + idGroup + " group name " + groupName);
if (DEBUG == true)
{
textoutput("<RED>Exception message is " + exc.Message);
}
//return false;
}
}
textoutput(radiochannelGroupCount + " radio channel group settings imported");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_Radiogroups);
}
if (general_settings == true)
{
// import all settings
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_GeneralSettings);
textoutput("Importing TV server settings");
int ctr = 0;
XmlNodeList nodesettings = doc.SelectNodes("/tvserver/AllSettings/Setting");
foreach (XmlNode nodesetting in nodesettings)
{
XmlAttributeCollection allattributes = nodesetting.Attributes;
try
{
string myattribute = allattributes[0].Name.Replace("__SPACE__", " "); //reconverting attributes from export - do not change
myattribute = myattribute.Replace("__PLUS__", "+"); //reconverting attributes from export - do not change
if (DEBUG)
textoutput("Attribute: " + myattribute + " Value=" + allattributes[0].Value);
PostImport(doc, nodesetting, myattribute);
ctr++;
}
catch
{
textoutput("<RED>Error reading attribute");
}
}
textoutput(ctr.ToString() + " settings imported");
}
if (clickfinder == true)
{
progressbar((int)PB_action.START, ref PB_Import, (int)PB_part.TV_PluginSettings);
string plugversion = detectplugin("TV Movie EPG import");
if (plugversion != "NOT_FOUND")
{
textoutput("Importing TV movie");
//TVMovie mappings
textoutput("Delete old TV movie mappings");
tvmovieCount = 0;
#if(MP100)
IList mappingDb = TvMovieMapping.ListAll();
#elif(MP101)
IList<TvMovieMapping> mappingDb = TvMovieMapping.ListAll();
#else //MP11BETA or SVN
IList<TvMovieMapping> mappingDb = TvMovieMapping.ListAll();
#endif
if (mappingDb != null)
{
if (mappingDb.Count > 0)
{
foreach (TvMovieMapping mapping in mappingDb)
{
tvmovieCount++;
mapping.Remove();
}
}
}
textoutput(tvmovieCount + " TV movie mappings deleted");
layer = new TvBusinessLayer();
textoutput("Importing TV movie mappings");
XmlNodeList tvmoviemapping = doc.SelectNodes("/tvserver/TVMovieMappings/TVMovieMapping");
tvmovieCount = 0;
foreach (XmlNode nodetvmoviemapping in tvmoviemapping)
{
string dpname = nodetvmoviemapping.Attributes["MPDisplayName"].Value;
try
{
if (DEBUG)
{
textoutput("TvMovie mappings: Display ="+ dpname);
}
//Channel channel = layer.GetChannelByName(chname);
Channel channel = mygetChannelbyName(dpname);
if (channel == null)
{
textoutput("<YELLOW>TV movie EPG mapping failed (Display: " + dpname + ") was not found");
}
else
{
int idChannel = channel.IdChannel;
string stationName = nodetvmoviemapping.Attributes["StationName"].Value;
string timeSharingStart = nodetvmoviemapping.Attributes["TimeSharingStart"].Value;
string timeSharingEnd = nodetvmoviemapping.Attributes["TimeSharingEnd"].Value;
//TvMovieMapping tvmapping = new TvMovieMapping(idChannel, stationName, timeSharingStart, timeSharingEnd);
//tvmapping.Persist();
tvmovieCount++;
POSTIMPORT += "TVMOVIE\t" + idChannel + "\t" + stationName + "\t" + timeSharingStart + "\t" + timeSharingEnd + "\n";
}
}
catch (Exception exc)
{
textoutput("<RED>Tv movie mappings: Failed to add mapping for channel (Display:" + dpname + ") ");
if (DEBUG == true)
{
textoutput("<RED>Exception message is " + exc.Message);
}
return false;
}
}
textoutput(tvmovieCount + " TV movie mappings imported");
}
}
textoutput("TV server import finished");
progressbar((int)PB_action.STOP, ref PB_Import, (int)PB_part.TV_PluginSettings);
}
catch (Exception ex)
{
textoutput("<RED>Error while importing:" + ex.ToString() + " " + ex.StackTrace);
myMessageBox("Error while importing:\n\n" + ex.ToString() + " " + ex.StackTrace, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
return false;
}
return true;
}
public Card AddCard(string name, string devicePath, Server server)
{
Card card = GetCardByDevicePath(devicePath);
if (card != null)
{
card.Name = name;
card.IdServer = server.IdServer;
return card;
}
//
// Card(devicePath, name, priority, grabEPG, lastEpgGrab, recordingFolder, idServer, enabled, camType, timeshiftingFolder, recordingFormat, decryptLimit)
//
Card newCard = new Card(devicePath, name, 1, true, new DateTime(2000, 1, 1), "", server.IdServer, true, 0, "", 0,
0, false, true, false, (int)TvDatabase.DbNetworkProvider.Generic);
newCard.Persist();
return newCard;
}
/// <summary>
/// Retrieves additional status information for an busy TV card.
/// </summary>
/// <param name="card">The required TV card.</param>
/// <param name="status">The status of the card. (uWiMP.TVServer.Cards.Status)</param>
/// <returns></returns>
/// <remarks>Returns the recording ID or channel ID if recording or timeshifting.</remarks>
public static string GetCardUsageStatus(Card card, Status status)
{
SetupConnection();
User user = new User();
VirtualCard vcard;
user.CardId = card.IdCard;
IUser[] usersForCard = RemoteControl.Instance.GetUsersForCard(card.IdCard);
int id = 0;
string username = "******";
if (usersForCard.Length == 0)
{
vcard = new VirtualCard(user, RemoteControl.HostName);
try
{
if (vcard.IsRecording & status == Cards.Status.recording)
id = vcard.RecordingScheduleId;
if (vcard.IsTimeShifting & status == Cards.Status.timeshifting)
id = vcard.IdChannel;
}
catch (Exception ex)
{
id = 0;
}
}
else
{
int i = 0;
for (i = 0; i <= usersForCard.Length - 1; i++)
{
vcard = new VirtualCard(usersForCard[i], RemoteControl.HostName);
username = vcard.User.Name;
try
{
if (vcard.IsRecording & status == Cards.Status.recording)
id = vcard.RecordingScheduleId;
if (vcard.IsTimeShifting & status == Cards.Status.timeshifting)
id = vcard.IdChannel;
}
catch (Exception ex)
{
id = 0;
}
}
}
return string.Format("{0},{1}", username, id);
}
public bool IsChannelMappedToCard(Channel dbChannel, Card card, bool forEpg)
{
SqlBuilder sb = new SqlBuilder(StatementType.Select, typeof (ChannelMap));
SqlStatement origStmt = sb.GetStatement(true);
string sql = "select cm.* from ChannelMap cm where cm.idChannel =" +
dbChannel.IdChannel + " and cm.idCard=" + card.IdCard + (forEpg ? "" : " and cm.epgOnly=0");
SqlStatement statement = new SqlStatement(StatementType.Select, origStmt.Command, sql,
typeof (Channel));
IList<ChannelMap> maps = ObjectFactory.GetCollection<ChannelMap>(statement.Execute());
return maps != null && maps.Count > 0;
}
private void ColorLine(Card card, ListViewItem item)
{
Color lineColor = Color.White;
int subchannels = 0;
IUser user;
bool cardInUse = RemoteControl.Instance.IsCardInUse(card.IdCard, out user);
if (!cardInUse)
{
subchannels = RemoteControl.Instance.GetSubChannels(card.IdCard);
if (subchannels > 0)
{
lineColor = Color.Red;
}
}
item.UseItemStyleForSubItems = false;
item.BackColor = lineColor;
foreach (ListViewItem.ListViewSubItem lvi in item.SubItems)
{
lvi.BackColor = lineColor;
}
item.SubItems[3].Text = "";
item.SubItems[4].Text = "";
item.SubItems[5].Text = "";
item.SubItems[6].Text = card.Name;
item.SubItems[7].Text = Convert.ToString(subchannels);
}
/// <summary>
/// Stops and deletes an active recording.
/// </summary>
/// <param name="card"></param>
/// <returns></returns>
/// <remarks></remarks>
public static bool StopRecording(Card card)
{
SetupConnection();
VirtualCard vcard;
IUser[] usersForCard = RemoteControl.Instance.GetUsersForCard(card.IdCard);
foreach (IUser user in usersForCard)
{
vcard = new VirtualCard(user, RemoteControl.HostName);
try
{
if (vcard.IsRecording)
{
Recording recording = Recording.Retrieve(vcard.RecordingFileName);
vcard.StopRecording();
recording.Delete();
return true;
}
}
catch (Exception ex)
{
return false;
}
}
return false;
}
public void DeleteCard(Card card)
{
card.Remove();
}
public CardInfo(Card newcard)
{
card = newcard;
}
public ChannelMap MapChannelToCard(Card card, Channel channel, bool epgOnly)
{
IList<ChannelMap> channelMaps = card.ReferringChannelMap();
for (int i = 0; i < channelMaps.Count; ++i)
{
ChannelMap map = channelMaps[i];
if (map.IdChannel == channel.IdChannel && map.IdCard == card.IdCard)
{
return map;
}
}
ChannelMap newMap = new ChannelMap(channel.IdChannel, card.IdCard, epgOnly);
newMap.Persist();
return newMap;
}
private bool IsChannelMappedToCard(Channel dbChannel, Card card, IDictionary<int, IList<int>> channelMapping)
{
//check if channel is mapped to this card and that the mapping is not for "Epg Only"
IList<int> cards;
channelMapping.TryGetValue(dbChannel.IdChannel, out cards);
return cards != null && cards.Contains(card.IdCard);
}