ZefaniaBible.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.IO;
using System.Text;
using System.Xml.Linq;


namespace UniversalBibleAPI
{
    public class ZefaniaBible : IBibleModul
    {
        private List<CurrentContentKey> FMyVerses = new List<CurrentContentKey>();
        private VplBible InternalVPL = new VplBible();
        private Scriptureparser BibleParser = new Scriptureparser();
        private string FModuleName = "No Name";
        private string FModulePath = "";
        private XDocument FZefaniaBibleModul;
        private BackgroundWorker BackGroundWorkerLoadModul;
       
        #region IBibleModul Members
        public event EventHandler<ModulConnectedEventArgs> OnConnected;
        public event EventHandler<ParseEventArgs> OnQueryFinished;
        public void Connect(string PathToBibleModul)
        {
            FModulePath = PathToBibleModul;
            BackGroundWorkerLoadModul = new BackgroundWorker();
            BackGroundWorkerLoadModul.DoWork += new DoWorkEventHandler(BackGroundWorkerLoadModul_DoWork);
            BackGroundWorkerLoadModul.RunWorkerAsync(PathToBibleModul);

        }
        void BackGroundWorkerLoadModul_DoWork(object sender, DoWorkEventArgs e)
        {
            InternalVPL.Connect();
            InternalVPL.OnQueryFinished += new EventHandler<ParseEventArgs>(InternalVPL_OnQueryFinished);
            FZefaniaBibleModul = XDocument.Load((e.Argument as String));
            var verses  = FZefaniaBibleModul.Descendants("VERS");            
            foreach (var vers in verses)
            {
                InternalVPL.SetCurrentContentKeys.Add(GetContentKey(vers));
            }

            if (OnConnected != null)
            {

                ModulConnectedEventArgs args = new ModulConnectedEventArgs();
                args.ModulName = FZefaniaBibleModul.Descendants("title").ElementAt(0).Value;
                FModuleName = args.ModulName;
                OnConnected(this, args);

            }


        }
        private CurrentContentKey GetContentKey(XElement vers)
        {
            CurrentContentKey CK = new CurrentContentKey();
            try
            {
                CK.Book = vers.Parent.Parent.Attribute("bnumber").Value;
                CK.Chapter = vers.Parent.Attribute("cnumber").Value;
                CK.Verse = vers.Attribute("vnumber").Value;
                CK.ContentText = vers.ToString();
                CK.ContentType = CurrentContentKey.TypeOfContentKey.Verse;

                return CK;
            }
            catch (Exception e)
            {
                
                throw e;
            }
        }
        void InternalVPL_OnQueryFinished(object sender, ParseEventArgs e)
        {
            if (OnQueryFinished != null)
            {
                ParseEventArgs PEV = new ParseEventArgs();
                PEV.QueryResultList = e.QueryResultList;
                OnQueryFinished(this, PEV);

            }
        }     
        public bool HasVersRef(string SingleVersRef)
        {

            try
            {
                return InternalVPL.HasVersRef(SingleVersRef);
            }
            catch (Exception e)
            {

                throw e;
            }
        }
        public void ParseQuery(string BibleQuery)
        {
            try
            {
                if (BibleQuery != string.Empty)
                {
                    InternalVPL.ParseQuery(BibleQuery);
                }
            }
            catch (Exception e)
            {

                throw e;
            }
        }
        public void NextVerse()
        {

            try
            {

                InternalVPL.NextVerse();

            }
            catch (Exception e)
            {

                throw e;
            }
        }
        public void PreviousVerse()
        {

            try
            {
                InternalVPL.PreviousVerse();
            }
            catch (Exception e)
            {

                throw e;
            }
        }
        public void NextChapter()
        {
            try
            {
                InternalVPL.NextChapter();
            }

            catch (Exception e)
            {

                throw e;
            }
        }
        public void PreviousChapter()
        {
            try
            {
                InternalVPL.PreviousChapter();
            }

            catch (Exception e)
            {

                throw e;
            }
        }
        public void NextBook()
        {
            try
            {

                InternalVPL.NextBook();
            }
            catch (Exception e)
            {

                throw e;
            }
        }
        public void PreviousBook()
        {
            try
            {
                InternalVPL.PreviousBook();
            }
            catch (Exception e)
            {

                throw e;
            }
        }
        public IFilter MyFilter {

            get { return InternalVPL.MyFilter; }
            set {InternalVPL.MyFilter=value; }
        
        }
        public bool IsOnEnd()
        {
            try
            {
                return InternalVPL.IsOnEnd();
            }
            catch (Exception e)
            {

                throw e;
            }
        }
        public bool IsOnStart()
        {
            try
            {
                return InternalVPL.IsOnStart();
            }
            catch (Exception e)
            {

                throw e;
            }
        }
        public string ModuleName
        {
            get
            {
                return FModuleName;
            }
            set
            {
                FModuleName = value;
            }
        }
        public string ModulePath
        {
            get { return FModulePath; }
        }
        public List<CurrentContentKey> GetAllVerses()
        {
            try
            {
                return InternalVPL.GetAllVerses();
            }

            catch (Exception e)
            {

                throw e;
            }
        }

        public void ConvertTo(IBibleModul ModulToConvert)
        {
            try
            {
                string OutPath = Path.ChangeExtension(ModulToConvert.ModulePath, ".xml");
                string FileName = Path.GetFileNameWithoutExtension(OutPath);
                
                OutPath = OutPath.Replace(FileName, FileName + "_convto");
                File.Delete(OutPath);
                File.AppendAllText(OutPath, "<XMLBIBLE>\n", Encoding.UTF8);
                File.AppendAllText(OutPath, "<INFORMATION><title>NoName</title></INFORMATION>\n", Encoding.UTF8);

                var BGR = from BG in ModulToConvert.GetAllVerses() group BG by BG.Book;
                foreach (var Book in BGR) {
                    File.AppendAllText(OutPath, "<BIBLEBOOK bnumber=\""+Book.Key+"\">\n", Encoding.UTF8);
                    var CGR = from CG in Book group CG by CG.Chapter;
                    foreach (var Chapter in CGR) {
                        File.AppendAllText(OutPath, "<CHAPTER cnumber=\""+Chapter.Key+"\">\n", Encoding.UTF8);
                        foreach (var item in Chapter){

                            if (item.ContentType == CurrentContentKey.TypeOfContentKey.Verse) {
                                File.AppendAllText(OutPath, "<VERS vnumber=\"" + item.Verse + "\">"+item.ContentText+ "</VERS>\n", Encoding.UTF8);
                                continue;
                            }
                            if (item.ContentType == CurrentContentKey.TypeOfContentKey.Caption)
                            {
                                File.AppendAllText(OutPath, "<CAPTION>"+item.ContentText+"</CAPTION>\n", Encoding.UTF8);
                                continue;
                            }
                        } 
                      File.AppendAllText(OutPath, "</CHAPTER>\n", Encoding.UTF8);
                    }
                   
                    File.AppendAllText(OutPath, "</BIBLEBOOK>\n", Encoding.UTF8);
                
                }
                
               

                File.AppendAllText(OutPath, "</XMLBIBLE>\n", Encoding.UTF8);
                this.Connect(OutPath);

            }
            catch (Exception e)
            {
                
                throw e;
            }
        }

        #endregion
    }
}