コード例 #1
0
        public static void SetSingleStateSeriesPending(DateTime startTime, int idChannel, string title)
        {
            //select * from 'foreigntable'
            SqlBuilder sb = new SqlBuilder(StatementType.Select, typeof(Program));

            // where foreigntable.foreignkey = ourprimarykey
            sb.AddConstraint(Operator.Equals, "Title", title);
            sb.AddConstraint(Operator.Equals, "startTime", startTime);
            sb.AddConstraint(Operator.Equals, "idChannel", idChannel);

            // passing true indicates that we'd like a list of elements, i.e. that no primary key
            // constraints from the type being retrieved should be added to the statement
            SqlStatement stmt = sb.GetStatement(true);

            IList <Program> result = ObjectFactory.GetCollection <Program>(stmt.Execute());

            if (result == null || result.Count == 0)
            {
                return;
            }

            Program prg = result[0];

            prg.IsRecordingOncePending   = false;
            prg.IsRecordingSeriesPending = true;
            prg.Persist();
        }
コード例 #2
0
        public static void ResetPendingState(int idProgram)
        {
            Program prg = Program.Retrieve(idProgram);

            if (prg != null)
            {
                prg.IsRecordingOncePending          = false;
                prg.IsRecordingSeriesPending        = false;
                prg.IsPartialRecordingSeriesPending = false;
            }
            prg.Persist();
        }
コード例 #3
0
        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
        /// <summary>
        /// Update the Program in the database if it exists or add if it is new.
        /// </summary>
        /// <param name="mpProgram">The Program to add to the database</param>
        protected void UpdateProgram(Program mpProgram)
        {
            IFormatProvider mmddFormat = new System.Globalization.CultureInfo(String.Empty, false);
             SqlBuilder sb = new SqlBuilder(Gentle.Framework.StatementType.Select, typeof(Program));
             // startTime < MyEndTime AND endTime > MyStartTime
             // OR ==
             string sqlW1 = String.Format("(StartTime < '{0}' and EndTime > '{1}')", mpProgram.EndTime.ToString(tvLayer.GetDateTimeString(), mmddFormat), mpProgram.StartTime.ToString(tvLayer.GetDateTimeString(), mmddFormat));
             string sqlW2 = String.Format("(StartTime = '{0}' and EndTime = '{1}')", mpProgram.StartTime.ToString(tvLayer.GetDateTimeString(), mmddFormat), mpProgram.EndTime.ToString(tvLayer.GetDateTimeString(), mmddFormat));

             sb.AddConstraint(Operator.Equals, "idChannel", mpProgram.IdChannel);
             sb.AddConstraint(string.Format("({0} or {1}) ", sqlW1, sqlW2));
             sb.AddOrderByField(true, "starttime");

             SqlStatement stmt = sb.GetStatement(true);
             IList progList = ObjectFactory.GetCollection(typeof(Program), stmt.Execute());

             if (progList.Count > 0)
             {
            bool bMatch = false;
            foreach (Program prog in progList)
            {
               if (!bMatch && prog.StartTime == mpProgram.StartTime && prog.EndTime == mpProgram.EndTime && prog.Title == mpProgram.Title)
               {
                  //update - but only allow one match
                  bMatch = true;
                  prog.Classification  = mpProgram.Classification;
                  prog.Description     = mpProgram.Description;
                  prog.EpisodeNum      = mpProgram.EpisodeNum;
                  prog.Genre           = mpProgram.Genre;
                  prog.OriginalAirDate = mpProgram.OriginalAirDate;
                  prog.SeriesNum       = mpProgram.SeriesNum;
                  prog.StarRating      = mpProgram.StarRating;
                  prog.Title           = mpProgram.Title;
                  prog.EpisodeName     = mpProgram.EpisodeName;
                  prog.Persist();
               }
               else
                  prog.Delete();
            }
            if (!bMatch)
               mpProgram.Persist();
             }
             else
             {
            mpProgram.Persist();
             }
        }