예제 #1
0
 public IChannel GetTuningChannel(TuningDetail detail)
 {
   switch (detail.ChannelType)
   {
     case 0: //AnalogChannel
       AnalogChannel analogChannel = new AnalogChannel();
       analogChannel.ChannelNumber = detail.ChannelNumber;
       CountryCollection collection = new CountryCollection();
       analogChannel.Country = collection.Countries[detail.CountryId];
       analogChannel.Frequency = detail.Frequency;
       analogChannel.IsRadio = detail.IsRadio;
       analogChannel.IsTv = detail.IsTv;
       analogChannel.Name = detail.Name;
       analogChannel.TunerSource = (TunerInputType)detail.TuningSource;
       analogChannel.VideoSource = (AnalogChannel.VideoInputType)detail.VideoSource;
       analogChannel.AudioSource = (AnalogChannel.AudioInputType)detail.AudioSource;
       return analogChannel;
     case 1: //ATSCChannel
       ATSCChannel atscChannel = new ATSCChannel();
       atscChannel.MajorChannel = detail.MajorChannel;
       atscChannel.MinorChannel = detail.MinorChannel;
       atscChannel.PhysicalChannel = detail.ChannelNumber;
       atscChannel.FreeToAir = detail.FreeToAir;
       atscChannel.Frequency = detail.Frequency;
       atscChannel.IsRadio = detail.IsRadio;
       atscChannel.IsTv = detail.IsTv;
       atscChannel.Name = detail.Name;
       atscChannel.NetworkId = detail.NetworkId;
       atscChannel.PmtPid = detail.PmtPid;
       atscChannel.Provider = detail.Provider;
       atscChannel.ServiceId = detail.ServiceId;
       //atscChannel.SymbolRate = detail.Symbolrate;
       atscChannel.TransportId = detail.TransportId;
       atscChannel.ModulationType = (ModulationType)detail.Modulation;
       return atscChannel;
     case 2: //DVBCChannel
       DVBCChannel dvbcChannel = new DVBCChannel();
       dvbcChannel.ModulationType = (ModulationType)detail.Modulation;
       dvbcChannel.FreeToAir = detail.FreeToAir;
       dvbcChannel.Frequency = detail.Frequency;
       dvbcChannel.IsRadio = detail.IsRadio;
       dvbcChannel.IsTv = detail.IsTv;
       dvbcChannel.Name = detail.Name;
       dvbcChannel.NetworkId = detail.NetworkId;
       dvbcChannel.PmtPid = detail.PmtPid;
       dvbcChannel.Provider = detail.Provider;
       dvbcChannel.ServiceId = detail.ServiceId;
       dvbcChannel.SymbolRate = detail.Symbolrate;
       dvbcChannel.TransportId = detail.TransportId;
       dvbcChannel.LogicalChannelNumber = detail.ChannelNumber;
       return dvbcChannel;
     case 3: //DVBSChannel
       DVBSChannel dvbsChannel = new DVBSChannel();
       dvbsChannel.DisEqc = (DisEqcType)detail.Diseqc;
       dvbsChannel.Polarisation = (Polarisation)detail.Polarisation;
       dvbsChannel.SwitchingFrequency = detail.SwitchingFrequency;
       dvbsChannel.FreeToAir = detail.FreeToAir;
       dvbsChannel.Frequency = detail.Frequency;
       dvbsChannel.IsRadio = detail.IsRadio;
       dvbsChannel.IsTv = detail.IsTv;
       dvbsChannel.Name = detail.Name;
       dvbsChannel.NetworkId = detail.NetworkId;
       dvbsChannel.PmtPid = detail.PmtPid;
       dvbsChannel.Provider = detail.Provider;
       dvbsChannel.ServiceId = detail.ServiceId;
       dvbsChannel.SymbolRate = detail.Symbolrate;
       dvbsChannel.TransportId = detail.TransportId;
       dvbsChannel.BandType = (BandType)detail.Band;
       dvbsChannel.SatelliteIndex = detail.SatIndex;
       dvbsChannel.ModulationType = (ModulationType)detail.Modulation;
       dvbsChannel.InnerFecRate = (BinaryConvolutionCodeRate)detail.InnerFecRate;
       dvbsChannel.Pilot = (Pilot)detail.Pilot;
       dvbsChannel.Rolloff = (RollOff)detail.RollOff;
       dvbsChannel.LogicalChannelNumber = detail.ChannelNumber;
       return dvbsChannel;
     case 4: //DVBTChannel
       DVBTChannel dvbtChannel = new DVBTChannel();
       dvbtChannel.BandWidth = detail.Bandwidth;
       dvbtChannel.FreeToAir = detail.FreeToAir;
       dvbtChannel.Frequency = detail.Frequency;
       dvbtChannel.IsRadio = detail.IsRadio;
       dvbtChannel.IsTv = detail.IsTv;
       dvbtChannel.Name = detail.Name;
       dvbtChannel.NetworkId = detail.NetworkId;
       dvbtChannel.PmtPid = detail.PmtPid;
       dvbtChannel.Provider = detail.Provider;
       dvbtChannel.ServiceId = detail.ServiceId;
       dvbtChannel.TransportId = detail.TransportId;
       dvbtChannel.LogicalChannelNumber = detail.ChannelNumber;
       return dvbtChannel;
     case 7: //DVBIPChannel
       DVBIPChannel dvbipChannel = new DVBIPChannel();
       dvbipChannel.FreeToAir = detail.FreeToAir;
       dvbipChannel.IsRadio = detail.IsRadio;
       dvbipChannel.IsTv = detail.IsTv;
       dvbipChannel.Name = detail.Name;
       dvbipChannel.NetworkId = detail.NetworkId;
       dvbipChannel.PmtPid = detail.PmtPid;
       dvbipChannel.Provider = detail.Provider;
       dvbipChannel.ServiceId = detail.ServiceId;
       dvbipChannel.TransportId = detail.TransportId;
       dvbipChannel.LogicalChannelNumber = detail.ChannelNumber;
       dvbipChannel.Url = detail.Url;
       return dvbipChannel;
   }
   return null;
 }
예제 #2
0
    private void importButton_Click(object sender, EventArgs e)
    {
      bool importtv = imCheckTvChannels.Checked;
      bool importtvgroups = imCheckTvGroups.Checked;
      bool importradio = imCheckRadioChannels.Checked;
      bool importradiogroups = imCheckRadioGroups.Checked;
      bool importschedules = imCheckSchedules.Checked;

      openFileDialog1.CheckFileExists = true;
      openFileDialog1.DefaultExt = "xml";
      openFileDialog1.RestoreDirectory = true;
      openFileDialog1.Title = "Load channels, channel groups and schedules";
      openFileDialog1.InitialDirectory = String.Format(@"{0}\Team MediaPortal\MediaPortal TV Server",
                                                       Environment.GetFolderPath(
                                                         Environment.SpecialFolder.CommonApplicationData));
      openFileDialog1.FileName = "export.xml";
      openFileDialog1.AddExtension = true;
      openFileDialog1.Multiselect = false;
      if (openFileDialog1.ShowDialog(this) != DialogResult.OK)
        return;
      NotifyForm dlg = new NotifyForm("Importing tv channels...", "This can take some time\n\nPlease be patient...");
      try
      {
        dlg.Show();
        dlg.WaitForDisplay();
        CountryCollection collection = new CountryCollection();
        TvBusinessLayer layer = new TvBusinessLayer();
        bool mergeChannels = false; // every exported channel will be imported on its own.
        int channelCount = 0;
        int scheduleCount = 0;
        int tvChannelGroupCount = 0;
        int radioChannelGroupCount = 0;

        if (layer.Channels.Count > 0 && (importtv || importradio))
        {
          // rtv: we could offer to set a "merge" property here so tuningdetails would be updated for existing channels.
          if (
            MessageBox.Show(
              "Existing channels detected! \nIf you continue to import your old backup then all identically named channels will be treated equal - there is a risk of duplicate entries. \nDo you really want to go on?",
              "Channels found", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
            return;
          else
            mergeChannels = true;
        }

        XmlDocument doc = new XmlDocument();
        Log.Info("TvChannels: Trying to import channels from {0}", openFileDialog1.FileName);
        doc.Load(openFileDialog1.FileName);
        XmlNodeList channelList = doc.SelectNodes("/tvserver/channels/channel");
        XmlNodeList tvChannelGroupList = doc.SelectNodes("/tvserver/channelgroups/channelgroup");
        XmlNodeList radioChannelGroupList = doc.SelectNodes("/tvserver/radiochannelgroups/radiochannelgroup");
        XmlNodeList scheduleList = doc.SelectNodes("/tvserver/schedules/schedule");
        if (channelList != null)
        {
          foreach (XmlNode nodeChannel in channelList)
          {
            try
            {
              Channel dbChannel;
              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(GetNodeAttribute(nodeChannel, "LastGrabTime", "01.01.1900"),
                                                          "yyyy-M-d H:m:s", CultureInfo.InvariantCulture);
              int sortOrder = Int32.Parse(GetNodeAttribute(nodeChannel, "SortOrder", "0"));
              int timesWatched = Int32.Parse(GetNodeAttribute(nodeChannel, "TimesWatched", "0"));
              DateTime totalTimeWatched =
                DateTime.ParseExact(GetNodeAttribute(nodeChannel, "TotalTimeWatched", "01.01.1900"), "yyyy-M-d H:m:s",
                                    CultureInfo.InvariantCulture);
              bool visibileInGuide = (GetNodeAttribute(nodeChannel, "VisibleInGuide", "True") == "True");
              bool FreeToAir = (GetNodeAttribute(nodeChannel, "FreeToAir", "True") == "True");
              string displayName = GetNodeAttribute(nodeChannel, "DisplayName", "Unkown");
              int chChannelNumber = Int32.Parse(GetNodeAttribute(nodeChannel, "ChannelNumber", "10000"));

              // Only import TV or radio channels if the corresponding checkbox was checked
              if ((isTv && !importtv) || (isRadio && !importradio))
                continue;

              channelCount++;

              // 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/
              Log.Info("TvChannels: Adding {0}. channel: {1}", channelCount, displayName);
              IList<Channel> foundExistingChannels = layer.GetChannelsByName(displayName);
              if (mergeChannels && (foundExistingChannels != null && foundExistingChannels.Count > 0))
              {
                dbChannel = foundExistingChannels[0];
              }
              else
              {
                dbChannel = layer.AddNewChannel(displayName, chChannelNumber);
              }

              dbChannel.GrabEpg = grabEpg;
              dbChannel.IsRadio = isRadio;
              dbChannel.IsTv = isTv;
              dbChannel.LastGrabTime = lastGrabTime;
              dbChannel.SortOrder = sortOrder;
              dbChannel.TimesWatched = timesWatched;
              dbChannel.TotalTimeWatched = totalTimeWatched;
              dbChannel.VisibleInGuide = visibileInGuide;
              dbChannel.DisplayName = displayName;
              dbChannel.Persist();

              //
              // chemelli: When we import channels we need to add those to the "AllChannels" group
              //
              if (isTv)
              {
                layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
              }
              else
              {
                layer.AddChannelToRadioGroup(dbChannel, TvConstants.RadioGroupNames.AllChannels);
              }

              foreach (XmlNode nodeMap in mappingList)
              {
                int idCard = Int32.Parse(nodeMap.Attributes["IdCard"].Value);
                XmlNode nodeCard =
                  doc.SelectSingleNode(String.Format("/tvserver/servers/server/cards/card[@IdCard={0}]", idCard));
                Card dbCard = layer.GetCardByDevicePath(nodeCard.Attributes["DevicePath"].Value);
                if (dbCard != null)
                {
                  layer.MapChannelToCard(dbCard, dbChannel, false);
                }
              }
              foreach (XmlNode nodeTune in tuningList)
              {
                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);
                string 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"));
                bool isVCRSignal = (GetNodeAttribute(nodeChannel, "IsVCRSignal", "False") == "True");
                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"));

                switch (channelType)
                {
                  case 0: //AnalogChannel
                    AnalogChannel analogChannel = new AnalogChannel();
                    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.AudioSource = (AnalogChannel.AudioInputType)audioSource;
                    analogChannel.VideoSource = (AnalogChannel.VideoInputType)videoSource;
                    analogChannel.IsVCRSignal = isVCRSignal;
                    layer.AddTuningDetails(dbChannel, analogChannel);
                    Log.Info("TvChannels: Added tuning details for analog channel: {0} number: {1}", name, channelNumber);
                    break;
                  case 1: //ATSCChannel
                    ATSCChannel atscChannel = new ATSCChannel();
                    atscChannel.MajorChannel = majorChannel;
                    atscChannel.MinorChannel = minorChannel;
                    atscChannel.PhysicalChannel = channelNumber;
                    atscChannel.FreeToAir = fta;
                    atscChannel.Frequency = frequency;
                    atscChannel.IsRadio = isRadio;
                    atscChannel.IsTv = isTv;
                    atscChannel.Name = name;
                    atscChannel.NetworkId = networkId;
                    atscChannel.PmtPid = pmtPid;
                    atscChannel.Provider = provider;
                    atscChannel.ServiceId = serviceId;
                    atscChannel.TransportId = transportId;
                    atscChannel.ModulationType = (ModulationType)modulation;
                    layer.AddTuningDetails(dbChannel, atscChannel);
                    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();
                    dvbcChannel.ModulationType = (ModulationType)modulation;
                    dvbcChannel.FreeToAir = fta;
                    dvbcChannel.Frequency = frequency;
                    dvbcChannel.IsRadio = isRadio;
                    dvbcChannel.IsTv = isTv;
                    dvbcChannel.Name = name;
                    dvbcChannel.NetworkId = networkId;
                    dvbcChannel.PmtPid = pmtPid;
                    dvbcChannel.Provider = provider;
                    dvbcChannel.ServiceId = serviceId;
                    dvbcChannel.SymbolRate = symbolrate;
                    dvbcChannel.TransportId = transportId;
                    dvbcChannel.LogicalChannelNumber = channelNumber;
                    layer.AddTuningDetails(dbChannel, dvbcChannel);
                    Log.Info("TvChannels: Added tuning details for DVB-C channel: {0} provider: {1}", name, provider);
                    break;
                  case 3: //DVBSChannel
                    DVBSChannel dvbsChannel = new DVBSChannel();
                    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;
                    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);
                    Log.Info("TvChannels: Added tuning details for DVB-S channel: {0} provider: {1}", name, provider);
                    break;
                  case 4: //DVBTChannel
                    DVBTChannel dvbtChannel = new DVBTChannel();
                    dvbtChannel.BandWidth = bandwidth;
                    dvbtChannel.FreeToAir = fta;
                    dvbtChannel.Frequency = frequency;
                    dvbtChannel.IsRadio = isRadio;
                    dvbtChannel.IsTv = isTv;
                    dvbtChannel.Name = name;
                    dvbtChannel.NetworkId = networkId;
                    dvbtChannel.PmtPid = pmtPid;
                    dvbtChannel.Provider = provider;
                    dvbtChannel.ServiceId = serviceId;
                    dvbtChannel.TransportId = transportId;
                    dvbtChannel.LogicalChannelNumber = channelNumber;
                    layer.AddTuningDetails(dbChannel, dvbtChannel);
                    Log.Info("TvChannels: Added tuning details for DVB-T channel: {0} provider: {1}", name, provider);
                    break;
                  case 5: //Webstream
                    layer.AddWebStreamTuningDetails(dbChannel, url, bitrate);
                    break;
                  case 7: //DVBIPChannel
                    DVBIPChannel dvbipChannel = new DVBIPChannel();
                    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);
                    Log.Info("TvChannels: Added tuning details for DVB-IP channel: {0} provider: {1}", name, provider);
                    break;
                }
              }
            }
            catch (Exception exc)
            {
              Log.Error("TvChannels: Failed to add channel - {0}", exc.Message);
            }
          }
        }

        if (tvChannelGroupList != null && importtvgroups)
        {
          // Import tv channel groups
          foreach (XmlNode nodeChannelGroup in tvChannelGroupList)
          {
            try
            {
              tvChannelGroupCount++;
              string groupName = nodeChannelGroup.Attributes["GroupName"].Value;
              int groupSortOrder = Int32.Parse(nodeChannelGroup.Attributes["SortOrder"].Value);
              ChannelGroup group = null;
              if (groupName == TvConstants.TvGroupNames.AllChannels)
              {
                group = layer.GetGroupByName(groupName) ??
                        new ChannelGroup(groupName, groupSortOrder);
              }
              else
              {
                group = layer.GetGroupByName(groupName, groupSortOrder) ??
                        new ChannelGroup(groupName, groupSortOrder);
              }
              group.Persist();
              XmlNodeList mappingList = nodeChannelGroup.SelectNodes("mappings/map");
              foreach (XmlNode nodeMap in mappingList)
              {
                IList<Channel> channels = layer.GetChannelsByName(nodeMap.Attributes["ChannelName"].Value);
                int sortOrder = Int32.Parse(GetNodeAttribute(nodeMap, "SortOrder", "9999"));
                if (channels != null && channels.Count > 0)
                {
                  Channel channel = channels[0];
                  if (!channel.GroupNames.Contains(group.GroupName))
                  {
                    GroupMap map = new GroupMap(group.IdGroup, channel.IdChannel, sortOrder);
                    map.Persist();
                  }
                  else
                  {
                    foreach (GroupMap map in channel.ReferringGroupMap())
                    {
                      if (map.IdGroup == group.IdGroup)
                      {
                        map.SortOrder = sortOrder;
                        map.Persist();
                        break;
                      }
                    }
                  }
                }
              }
            }
            catch (Exception exg)
            {
              Log.Error("TvChannels: Failed to add group - {0}", exg.Message);
            }
          }
        }

        if (radioChannelGroupList != null && importradiogroups)
        {
          // Import radio channel groups
          foreach (XmlNode nodeChannelGroup in radioChannelGroupList)
          {
            try
            {
              radioChannelGroupCount++;
              string groupName = nodeChannelGroup.Attributes["GroupName"].Value;
              int groupSortOrder = Int32.Parse(nodeChannelGroup.Attributes["SortOrder"].Value);
              RadioChannelGroup group = layer.GetRadioChannelGroupByName(groupName) ??
                                        new RadioChannelGroup(groupName, groupSortOrder);
              group.Persist();
              XmlNodeList mappingList = nodeChannelGroup.SelectNodes("mappings/map");
              foreach (XmlNode nodeMap in mappingList)
              {
                IList<Channel> channels = layer.GetChannelsByName(nodeMap.Attributes["ChannelName"].Value);
                int sortOrder = Int32.Parse(GetNodeAttribute(nodeMap, "SortOrder", "9999"));
                if (channels != null && channels.Count > 0)
                {
                  Channel channel = channels[0];
                  if (!channel.GroupNames.Contains(group.GroupName))
                  {
                    RadioGroupMap map = new RadioGroupMap(group.IdGroup, channel.IdChannel, sortOrder);
                    map.Persist();
                  }
                  else
                  {
                    foreach (RadioGroupMap map in channel.ReferringRadioGroupMap())
                    {
                      if (map.IdGroup == group.IdGroup)
                      {
                        map.SortOrder = sortOrder;
                        map.Persist();
                        break;
                      }
                    }
                  }
                }
              }
            }
            catch (Exception exg)
            {
              Log.Error("Radio Channels: Failed to add group - {0}", exg.Message);
            }
          }
        }

        if (scheduleList != null && importschedules)
        {
          // Import schedules
          foreach (XmlNode nodeSchedule in scheduleList)
          {
            try
            {
              int idChannel = -1;

              string programName = nodeSchedule.Attributes["ProgramName"].Value;
              string channel = nodeSchedule.Attributes["ChannelName"].Value;
              if (!string.IsNullOrEmpty(channel))
              {
                IList<Channel> channels = layer.GetChannelsByName(channel);
                if (channels != null && channels.Count > 0)
                {
                  idChannel = channels[0].IdChannel;
                }
              }
              DateTime startTime = DateTime.ParseExact(nodeSchedule.Attributes["StartTime"].Value, "yyyy-M-d H:m:s",
                                                       CultureInfo.InvariantCulture);
              DateTime endTime = DateTime.ParseExact(nodeSchedule.Attributes["EndTime"].Value, "yyyy-M-d H:m:s",
                                                     CultureInfo.InvariantCulture);
              int scheduleType = Int32.Parse(nodeSchedule.Attributes["ScheduleType"].Value);
              Schedule schedule = layer.AddSchedule(idChannel, programName, startTime, endTime, scheduleType);

              schedule.ScheduleType = scheduleType;
              schedule.KeepDate = DateTime.ParseExact(nodeSchedule.Attributes["KeepDate"].Value, "yyyy-M-d H:m:s",
                                                      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.ScheduleType = Int32.Parse(nodeSchedule.Attributes["ScheduleType"].Value);
              schedule.Series = (GetNodeAttribute(nodeSchedule, "Series", "False") == "True");
              if (idChannel > -1)
              {
                schedule.Persist();
                scheduleCount++;
                Log.Info("TvChannels: Added schedule: {0} on channel: {1}", programName, channel);
              }
              else
                Log.Info("TvChannels: Skipped schedule: {0} because the channel was unknown: {1}", programName, channel);
            }
            catch (Exception ex)
            {
              Log.Error("TvChannels: Failed to add schedule - {0}", ex.Message);
            }
          }
        }

        dlg.Close();
        Log.Info(
          "TvChannels: Imported {0} channels, {1} tv channel groups, {2} radio channel groups and {3} schedules",
          channelCount, tvChannelGroupCount, radioChannelGroupCount, scheduleCount);
        MessageBox.Show(
          String.Format("Imported {0} channels, {1} tv channel groups, {2} radio channel groups and {3} schedules",
                        channelCount, tvChannelGroupCount, radioChannelGroupCount, scheduleCount));
      }
      catch (Exception ex)
      {
        MessageBox.Show(this, "Error while importing:\n\n" + ex + " " + ex.StackTrace);
      }
      finally
      {
        dlg.Close();
        OnSectionActivated();
      }
    }
        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;
        }
예제 #4
0
    private void DoTvScan()
    {
      int channelsNew = 0;
      int channelsUpdated = 0;

      string buttonText = mpButtonScanTv.Text;
      checkButton.Enabled = false;
      try
      {
        _isScanning = true;
        _stopScanning = false;
        mpButtonScanTv.Text = "Cancel...";
        RemoteControl.Instance.EpgGrabberEnabled = false;
        TvBusinessLayer layer = new TvBusinessLayer();
        Card card = layer.GetCardByDevicePath(RemoteControl.Instance.CardDevice(_cardNumber));
        mpComboBoxCountry.Enabled = false;
        mpComboBoxSource.Enabled = false;
        mpComboBoxSensitivity.Enabled = false;
        checkBoxCreateSignalGroup.Enabled = false;
        checkBoxNoMerge.Enabled = false;
        mpButtonScanRadio.Enabled = false;
        mpButtonAddSvideoChannels.Enabled = false;
        mpListView1.Items.Clear();
        CountryCollection countries = new CountryCollection();
        IUser user = new User();
        user.CardId = _cardNumber;
        AnalogChannel temp = new AnalogChannel();
        temp.TunerSource = mpComboBoxSource.SelectedIndex == 0 ? TunerInputType.Antenna : TunerInputType.Cable;
        temp.VideoSource = AnalogChannel.VideoInputType.Tuner;
        temp.AudioSource = AnalogChannel.AudioInputType.Tuner;
        temp.Country = countries.Countries[mpComboBoxCountry.SelectedIndex];
        temp.IsRadio = false;
        temp.IsTv = true;
        TvResult tuneResult = RemoteControl.Instance.Tune(ref user, temp, -1);
        if (tuneResult == TvResult.SWEncoderMissing)
        {
          Log.Error("analog: DoTvScan error (missing software encoder)");
          MessageBox.Show("Please install a supported audio/video encoder for your software analog card",
                          "Unable to scan", MessageBoxButtons.OK, MessageBoxIcon.Error);
          return;
        }
        if (tuneResult == TvResult.GraphBuildingFailed)
        {
          Log.Error("analog: DoTvScan error (missing software encoder)");
          MessageBox.Show(
            "The graph building. Mostly your card is not supported by TvServer. Please create a report in our forum",
            "Unable to scan", MessageBoxButtons.OK, MessageBoxIcon.Error);
          return;
        }
        if (string.IsNullOrEmpty(_configuration.Graph.Capture.Name))
        {
          _configuration = Configuration.readConfiguration(_cardNumber, _cardName, _devicePath);
          ReCheckSettings();
        }
        int minChannel = RemoteControl.Instance.MinChannel(_cardNumber);
        int maxChannel = RemoteControl.Instance.MaxChannel(_cardNumber);
        if (maxChannel <= 0)
        {
          maxChannel = mpComboBoxSource.SelectedIndex == 0 ? 69 : 125;
        }
        if (minChannel < 0)
          minChannel = 1;
        Log.Info("Min channel = {0}. Max channel = {1}", minChannel, maxChannel);
        for (int channelNr = minChannel; channelNr <= maxChannel; channelNr++)
        {
          if (_stopScanning)
            return;
          float percent = ((float)((channelNr - minChannel)) / (maxChannel - minChannel));
          percent *= 100f;
          if (percent > 100f)
            percent = 100f;
          if (percent < 0)
            percent = 0f;
          progressBar1.Value = (int)percent;
          AnalogChannel channel = new AnalogChannel();
          channel.TunerSource = mpComboBoxSource.SelectedIndex == 0 ? TunerInputType.Antenna : TunerInputType.Cable;
          channel.Country = countries.Countries[mpComboBoxCountry.SelectedIndex];
          channel.ChannelNumber = channelNr;
          channel.IsTv = true;
          channel.IsRadio = false;
          channel.VideoSource = AnalogChannel.VideoInputType.Tuner;
          channel.AudioSource = AnalogChannel.AudioInputType.Automatic;
          string line = String.Format("channel:{0} source:{1} ", channel.ChannelNumber, mpComboBoxSource.SelectedItem);
          ListViewItem item = mpListView1.Items.Add(new ListViewItem(line));
          item.EnsureVisible();

          IChannel[] channels = RemoteControl.Instance.Scan(_cardNumber, channel);
          UpdateStatus();
          if (channels == null || channels.Length == 0)
          {
            if (RemoteControl.Instance.TunerLocked(_cardNumber) == false)
            {
              line = String.Format("channel:{0} source:{1} : No Signal", channel.ChannelNumber,
                                   mpComboBoxSource.SelectedItem);
              item.Text = line;
              item.ForeColor = Color.Red;
              continue;
            }
            line = String.Format("channel:{0} source:{1} : Nothing found", channel.ChannelNumber,
                                 mpComboBoxSource.SelectedItem);
            item.Text = line;
            item.ForeColor = Color.Red;
            continue;
          }
          bool exists = false;
          channel = (AnalogChannel)channels[0];
          if (channel.Name == "")
            channel.Name = String.Format(channel.ChannelNumber.ToString());
          Channel dbChannel = null;
          if (checkBoxNoMerge.Checked)
          {
            dbChannel = layer.AddNewChannel(channel.Name);
          }
          else
          {
            IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channel.Name, 0);
            if (tuningDetails != null && tuningDetails.Count > 0)
            {
              dbChannel = tuningDetails[0].ReferencedChannel();
            }

            if (dbChannel != null)
            {
              exists = true;
            }
            else
            {
              dbChannel = layer.AddNewChannel(channel.Name);
            }
          }
          dbChannel.IsTv = channel.IsTv;
          dbChannel.IsRadio = channel.IsRadio;
          dbChannel.Persist();
          layer.AddTuningDetails(dbChannel, channel);
          layer.MapChannelToCard(card, dbChannel, false);

          if (dbChannel.IsTv)
          {
            layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
            if (checkBoxCreateSignalGroup.Checked)
            {
              layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.Analog);
            }
          }
          if (dbChannel.IsRadio)
          {
            layer.AddChannelToGroup(dbChannel, TvConstants.RadioGroupNames.AllChannels);
            if (checkBoxCreateSignalGroup.Checked)
            {
              layer.AddChannelToRadioGroup(dbChannel, TvConstants.RadioGroupNames.Analog);
            }
          }

          if (exists)
          {
            line = String.Format("channel:{0} source:{1} : Channel update found - {2}", channel.ChannelNumber,
                                 mpComboBoxSource.SelectedItem, channel.Name);
            channelsUpdated++;
          }
          else
          {
            line = String.Format("channel:{0} source:{1} : New channel found - {2}", channel.ChannelNumber,
                                 mpComboBoxSource.SelectedItem, channel.Name);
            channelsNew++;
          }
          item.Text = line;
        }
      }
      catch (TvExceptionSWEncoderMissing)
      {
        Log.Error("analog: DoTvScan error (missing software encoder)");
        MessageBox.Show("Please install a supported audio/video encoder for your software analog card", "Unable to scan",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
      }
      catch (TvExceptionGraphBuildingFailed)
      {
        Log.Error("analog: DoTvScan error (missing software encoder)");
        MessageBox.Show(
          "The graph building. Mostly your card is not supported by TvServer. Please create a report in our forum",
          "Unable to scan", MessageBoxButtons.OK, MessageBoxIcon.Error);
      }
      catch (Exception ex)
      {
        Log.Error("analog: DoTvScan error ({0})", ex.StackTrace);
        MessageBox.Show(string.Format("Generic error: {0}", ex.Message), "Unable to scan", MessageBoxButtons.OK,
                        MessageBoxIcon.Error);
      }
      finally
      {
        IUser user = new User();
        user.CardId = _cardNumber;
        RemoteControl.Instance.StopCard(user);
        RemoteControl.Instance.EpgGrabberEnabled = true;
        mpButtonScanTv.Text = buttonText;
        progressBar1.Value = 100;
        mpComboBoxCountry.Enabled = true;
        mpComboBoxSource.Enabled = true;
        mpComboBoxSensitivity.Enabled = true;
        checkBoxCreateSignalGroup.Enabled = true;
        checkBoxNoMerge.Enabled = true;
        mpButtonScanTv.Enabled = true;
        mpButtonScanRadio.Enabled = true;
        mpButtonAddSvideoChannels.Enabled = true;
        _isScanning = false;
        checkButton.Enabled = true;
      }
      ListViewItem lastItem =
        mpListView1.Items.Add(
          new ListViewItem(String.Format("Total tv channels new:{0} updated:{1}", channelsNew, channelsUpdated)));
      lastItem.EnsureVisible();
    }
예제 #5
0
 private void checkButton_Click(object sender, EventArgs e)
 {
   IUser user;
   try
   {
     TvBusinessLayer layer = new TvBusinessLayer();
     Card card = layer.GetCardByDevicePath(RemoteControl.Instance.CardDevice(_cardNumber));
     if (card.Enabled == false)
     {
       MessageBox.Show(this, "Card is disabled, please enable the card before checking quality control");
       return;
     }
     else if (!RemoteControl.Instance.CardPresent(card.IdCard))
     {
       MessageBox.Show(this, "Card is not found, please make sure card is present before checking quality control");
       return;
     }
     // Check if the card is locked for scanning.
     if (RemoteControl.Instance.IsCardInUse(_cardNumber, out user))
     {
       MessageBox.Show(this,
                       "Card is locked. Checking quality control not possible at the moment ! Perhaps you are scanning an other part of a hybrid card.");
       return;
     }
     user = new User();
     user.CardId = _cardNumber;
     AnalogChannel temp = new AnalogChannel();
     temp.VideoSource = AnalogChannel.VideoInputType.Tuner;
     temp.AudioSource = AnalogChannel.AudioInputType.Tuner;
     temp.IsRadio = false;
     temp.IsTv = true;
     RemoteControl.Instance.Tune(ref user, temp, -1);
     if (RemoteControl.Instance.SupportsQualityControl(_cardNumber))
     {
       _cardName = RemoteControl.Instance.CardName(_cardNumber);
       _devicePath = RemoteControl.Instance.CardDevice(_cardNumber);
       bitRateModeGroup.Enabled = RemoteControl.Instance.SupportsBitRateModes(_cardNumber);
       if (RemoteControl.Instance.SupportsPeakBitRateMode(_cardNumber))
       {
         vbrPeakPlayback.Enabled = true;
         vbrPeakRecord.Enabled = true;
       }
       else
       {
         vbrPeakPlayback.Enabled = false;
         vbrPeakRecord.Enabled = false;
       }
       if (RemoteControl.Instance.SupportsBitRate(_cardNumber))
       {
         bitRate.Enabled = true;
         customSettingsGroup.Enabled = true;
         customValue.Enabled = true;
         customValuePeak.Enabled = true;
       }
       else
       {
         bitRate.Enabled = false;
         customSettingsGroup.Enabled = false;
         customValue.Enabled = false;
         customValuePeak.Enabled = false;
       }
       _configuration = Configuration.readConfiguration(_cardNumber, _cardName, _devicePath);
       customValue.Value = _configuration.CustomQualityValue;
       customValuePeak.Value = _configuration.CustomPeakQualityValue;
       SetBitRateModes();
       SetBitRate();
       ReCheckSettings();
     }
     else
     {
       Log.WriteFile("Card doesn't support quality control");
       MessageBox.Show("The used encoder doesn't support quality control.",
                       "MediaPortal - TV Server management console", MessageBoxButtons.OK, MessageBoxIcon.Information);
       if (string.IsNullOrEmpty(_configuration.Graph.Capture.Name))
       {
         _configuration = Configuration.readConfiguration(_cardNumber, _cardName, _devicePath);
         ReCheckSettings();
       }
     }
   }
   finally
   {
     user = new User();
     user.CardId = _cardNumber;
     RemoteControl.Instance.StopCard(user);
   }
 }
예제 #6
0
    private void mpButton1_Click(object sender, EventArgs e)
    {
      if (string.IsNullOrEmpty(_configuration.Graph.Crossbar.Name))
      {
        IUser user = new User();
        user.CardId = _cardNumber;
        AnalogChannel temp = new AnalogChannel();
        temp.TunerSource = TunerInputType.Antenna;
        temp.VideoSource = AnalogChannel.VideoInputType.Tuner;
        temp.AudioSource = AnalogChannel.AudioInputType.Tuner;
        temp.IsRadio = false;
        temp.IsTv = true;
        RemoteControl.Instance.Tune(ref user, temp, -1);
        _configuration = Configuration.readConfiguration(_cardNumber, _cardName, _devicePath);
        if (string.IsNullOrEmpty(_configuration.Graph.Crossbar.Name))
        {
          MessageBox.Show(this, "The S-Video channels could not be detected.");
          return;
        }
        ReCheckSettings();
      }

      TvBusinessLayer layer = new TvBusinessLayer();
      Dictionary<AnalogChannel.VideoInputType, int> videoPinMap = _configuration.Graph.Crossbar.VideoPinMap;
      AnalogChannel tuningDetail;
      Card card = layer.GetCardByDevicePath(RemoteControl.Instance.CardDevice(_cardNumber));
      Channel dbChannel;
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.VideoInput1))
      {
        string channelName = "CVBS#1 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.VideoInput1;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.VideoInput2))
      {
        string channelName = "CVBS#2 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.VideoInput2;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.VideoInput3))
      {
        string channelName = "CVBS#3 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.VideoInput3;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.SvhsInput1))
      {
        string channelName = "S-Video#1 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.SvhsInput1;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.SvhsInput2))
      {
        string channelName = "S-Video#2 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.SvhsInput2;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.SvhsInput3))
      {
        string channelName = "S-Video#3 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.SvhsInput3;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.RgbInput1))
      {
        string channelName = "RGB#1 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.RgbInput1;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.RgbInput2))
      {
        string channelName = "RGB#2 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.RgbInput2;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.RgbInput3))
      {
        string channelName = "RGB#3 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.RgbInput3;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.YRYBYInput1))
      {
        string channelName = "YRYBY#1 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.YRYBYInput1;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.YRYBYInput2))
      {
        string channelName = "YRYBY#2 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.YRYBYInput2;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.YRYBYInput3))
      {
        string channelName = "YRYBY#3 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.YRYBYInput3;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.HdmiInput1))
      {
        string channelName = "HDMI#1 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.HdmiInput1;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.HdmiInput2))
      {
        string channelName = "HDMI#2 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.HdmiInput2;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      if (videoPinMap.ContainsKey(AnalogChannel.VideoInputType.HdmiInput3))
      {
        string channelName = "HDMI#3 on " + card.IdCard;
        IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channelName, 0);
        if (tuningDetails != null && tuningDetails.Count > 0)
        {
          dbChannel = tuningDetails[0].ReferencedChannel();
        }
        else
        {
          dbChannel = layer.AddNewChannel(channelName);
        }
        dbChannel.IsTv = true;
        dbChannel.Persist();
        tuningDetail = new AnalogChannel();
        tuningDetail.IsTv = true;
        tuningDetail.Name = dbChannel.DisplayName;
        tuningDetail.VideoSource = AnalogChannel.VideoInputType.HdmiInput3;
        layer.AddTuningDetails(dbChannel, tuningDetail);
        layer.MapChannelToCard(card, dbChannel, false);
        layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
      }
      MessageBox.Show(this, "Channels added.");
    }
예제 #7
0
    private void DoRadioScan()
    {
      int channelsNew = 0;
      int channelsUpdated = 0;

      checkButton.Enabled = false;
      int sensitivity = 1;
      switch (mpComboBoxSensitivity.Text)
      {
        case "High":
          sensitivity = 10;
          break;
        case "Medium":
          sensitivity = 2;
          break;
        case "Low":
          sensitivity = 1;
          break;
      }
      string buttonText = mpButtonScanRadio.Text;
      try
      {
        _isScanning = true;
        _stopScanning = false;
        mpButtonScanRadio.Text = "Cancel...";
        RemoteControl.Instance.EpgGrabberEnabled = false;
        TvBusinessLayer layer = new TvBusinessLayer();
        Card card = layer.GetCardByDevicePath(RemoteControl.Instance.CardDevice(_cardNumber));
        mpComboBoxCountry.Enabled = false;
        mpComboBoxSource.Enabled = false;
        mpComboBoxSensitivity.Enabled = false;
        checkBoxCreateSignalGroup.Enabled = false;
        checkBoxNoMerge.Enabled = false;
        mpButtonScanTv.Enabled = false;
        mpButtonAddSvideoChannels.Enabled = false;
        UpdateStatus();
        mpListView1.Items.Clear();
        CountryCollection countries = new CountryCollection();
        for (int freq = 87500000; freq < 108000000; freq += 100000)
        {
          if (_stopScanning)
            return;
          float percent = ((freq - 87500000)) / (108000000f - 87500000f);
          percent *= 100f;
          if (percent > 100f)
            percent = 100f;
          progressBar1.Value = (int)percent;
          AnalogChannel channel = new AnalogChannel();
          channel.IsRadio = true;
          channel.TunerSource = mpComboBoxSource.SelectedIndex == 0 ? TunerInputType.Antenna : TunerInputType.Cable;
          channel.VideoSource = AnalogChannel.VideoInputType.Tuner;
          channel.AudioSource = AnalogChannel.AudioInputType.Automatic;
          channel.Country = countries.Countries[mpComboBoxCountry.SelectedIndex];
          channel.Frequency = freq;
          channel.IsTv = false;
          channel.IsRadio = true;
          float freqMHz = channel.Frequency;
          freqMHz /= 1000000f;
          string line = String.Format("frequence:{0} MHz ", freqMHz.ToString("f2"));
          ListViewItem item = mpListView1.Items.Add(new ListViewItem(line));
          item.EnsureVisible();
          IUser user = new User();
          user.CardId = _cardNumber;
          TvResult tuneResult = RemoteControl.Instance.Tune(ref user, channel, -1);
          if (tuneResult == TvResult.SWEncoderMissing)
          {
            Log.Error("analog: DoTvScan error (missing software encoder)");
            MessageBox.Show("Please install a supported audio/video encoder for your software analog card",
                            "Unable to scan", MessageBoxButtons.OK, MessageBoxIcon.Error);
            break;
          }
          if (tuneResult == TvResult.GraphBuildingFailed)
          {
            Log.Error("analog: DoTvScan error (missing software encoder)");
            MessageBox.Show(
              "The graph building. Mostly your card is not supported by TvServer. Please create a report in our forum",
              "Unable to scan", MessageBoxButtons.OK, MessageBoxIcon.Error);
            break;
          }
          UpdateStatus();
          Thread.Sleep(2000);
          if (SignalStrength(sensitivity) == 100)
          {
            channel.Name = String.Format("{0}", freq);
            Channel dbChannel = null;
            IList<TuningDetail> tuningDetails = layer.GetTuningDetailsByName(channel.Name, 0);
            if (tuningDetails != null && tuningDetails.Count > 0)
            {
              dbChannel = tuningDetails[0].ReferencedChannel();
            }
            if (dbChannel != null)
            {
              line = String.Format("frequence:{0} MHz : Channel update found - {1}", freqMHz.ToString("f2"),
                                   channel.Name);
              channelsUpdated++;
            }
            else
            {
              dbChannel = layer.AddNewChannel(channel.Name);
              line = String.Format("frequence:{0} MHz : New channel found - {1}", freqMHz.ToString("f2"), channel.Name);
              channelsNew++;
            }
            item.Text = line;
            dbChannel.IsTv = channel.IsTv;
            dbChannel.IsRadio = channel.IsRadio;
            dbChannel.Persist();

            layer.AddChannelToRadioGroup(dbChannel, TvConstants.RadioGroupNames.AllChannels);
            if (checkBoxCreateSignalGroup.Checked)
            {
              layer.AddChannelToRadioGroup(dbChannel, TvConstants.RadioGroupNames.Analog);
            }

            layer.AddTuningDetails(dbChannel, channel);
            layer.MapChannelToCard(card, dbChannel, false);
            freq += 300000;
          }
          else
          {
            line = String.Format("frequence:{0} MHz : No Signal", freqMHz.ToString("f2"));
            item.Text = line;
            item.ForeColor = Color.Red;
          }
        }
      }
      catch (Exception ex)
      {
        Log.Write(ex);
      }
      finally
      {
        checkButton.Enabled = true;
        IUser user = new User();
        user.CardId = _cardNumber;
        RemoteControl.Instance.StopCard(user);
        RemoteControl.Instance.EpgGrabberEnabled = true;
        mpButtonScanRadio.Text = buttonText;
        progressBar1.Value = 100;
        mpComboBoxCountry.Enabled = true;
        mpComboBoxSource.Enabled = true;
        mpComboBoxSensitivity.Enabled = true;
        checkBoxCreateSignalGroup.Enabled = true;
        checkBoxNoMerge.Enabled = true;
        mpButtonScanTv.Enabled = true;
        mpButtonScanRadio.Enabled = true;
        mpButtonAddSvideoChannels.Enabled = true;
        _isScanning = false;
      }
      ListViewItem lastItem =
        mpListView1.Items.Add(
          new ListViewItem(String.Format("Total radio channels new:{0} updated:{1}", channelsNew, channelsUpdated)));
      lastItem.EnsureVisible();
    }
예제 #8
0
 private void mpButtonScanRadio_Click(object sender, EventArgs e)
 {
   if (_isScanning == false)
   {
     TvBusinessLayer layer = new TvBusinessLayer();
     Card card = layer.GetCardByDevicePath(RemoteControl.Instance.CardDevice(_cardNumber));
     if (card.Enabled == false)
     {
       MessageBox.Show(this, "Card is disabled, please enable the card before scanning");
       return;
     }
     if (!RemoteControl.Instance.CardPresent(card.IdCard))
     {
       MessageBox.Show(this, "Card is not found, please make sure card is present before scanning");
       return;
     }
     // Check if the card is locked for scanning.
     IUser user;
     if (RemoteControl.Instance.IsCardInUse(_cardNumber, out user))
     {
       MessageBox.Show(this,
                       "Card is locked. Scanning not possible at the moment ! Perhaps you are scanning an other part of a hybrid card.");
       return;
     }
     AnalogChannel radioChannel = new AnalogChannel();
     radioChannel.Frequency = 96000000;
     radioChannel.IsRadio = true;
     radioChannel.VideoSource = AnalogChannel.VideoInputType.Tuner;
     radioChannel.AudioSource = AnalogChannel.AudioInputType.Automatic;
     if (!RemoteControl.Instance.CanTune(_cardNumber, radioChannel))
     {
       MessageBox.Show(this, "The Tv Card does not support radio");
       return;
     }
     if (string.IsNullOrEmpty(_configuration.Graph.Capture.Name))
     {
       _configuration = Configuration.readConfiguration(_cardNumber, _cardName, _devicePath);
       ReCheckSettings();
     }
     Thread scanThread = new Thread(DoRadioScan);
     scanThread.Name = "Analog Radio scan thread";
     scanThread.Start();
   }
   else
   {
     _stopScanning = true;
   }
 }