libxmltv/Core/XMLTVProgram.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using libxmltv.Interfaces;
using System.Xml.Linq;
using System.Reflection;
using System.IO;
using System.Diagnostics;
using System.Globalization;

namespace libxmltv.Core
{
    [Serializable]
    internal class XMLTVProgram : XMLTVBase<XMLTVRuntimeInstance>, IXMLTVProgram
    {
        public XMLTVProgram()
            : base(null, XMLTVConstants.Programs.RootElement)
        {
            InternalDictionaryAddKnownProperties();
         
        }
        public XMLTVProgram(XMLTVRuntimeInstance instance, XElement node)
            : base(instance, XMLTVConstants.Programs.RootElement)
        {
            InternalDictionaryAddKnownProperties();
            try {
            xmltv_logger.Verbose.Debug.WriteLine("Creating Instance of XMLTVProgram");
            Create(node);
            xmltv_logger.Verbose.Debug.WriteLine("Created Instance of XMLTVProgram");
            UpdateInstance();
            }
            catch (IOException ex) { Debug.WriteLine(ex.ToString()); }
        }
        #region IXMLTVProgram members
        //public int Id { get; set; }
        //public DateTime Start { get; set; }
        //public DateTime Stop { get; set; }
        //public IXMLTVChannel Channel { get; set; }
        //public string Title { get; set; }
        //public string SubTitle { get; set; }
        //public string Description { get; set; }

        private void InternalDictionaryAddKnownProperties()
        {
            MetaData = new PropertyDictionary();
            MetaData.AddProperty("Id", 0);
            MetaData.AddProperty(XMLTVConstants.Programs.ProgramStart, new DateTime());
            MetaData.AddProperty(XMLTVConstants.Programs.ProgramStop, new DateTime());
            MetaData.AddProperty(XMLTVConstants.Programs.ProgramChannelId, string.Empty);
            MetaData.AddProperty(XMLTVConstants.Programs.ProgramTitle, string.Empty);
            MetaData.AddProperty(XMLTVConstants.Programs.ProgramSubTitle, string.Empty);
            MetaData.AddProperty(XMLTVConstants.Programs.ProgramDescription, string.Empty);
        }

        #region Property Dictionary Support
        public PropertyDictionary MetaData { get; private set; }
        #endregion

        #endregion
        public override string ToString()
        {
            return string.Format("{0}: {1} - {2} ({3}) ['{4}' <==> '{5}']",
                MetaData["Id"].ToString(),
                 MetaData[(XMLTVConstants.Programs.ProgramTitle)].ToString(),
                 MetaData[(XMLTVConstants.Programs.ProgramSubTitle)].ToString(),
                 MetaData[(XMLTVConstants.Programs.ProgramChannelId)].ToString(),
                ((DateTime)MetaData[XMLTVConstants.Programs.ProgramStart]).ToString("yyyy/MM/dd hh:mm tt"),
                ((DateTime)MetaData[XMLTVConstants.Programs.ProgramStop]).ToString("yyyy/MM/dd hh:mm tt"));
        }


        private void UpdateInstance()
        {
            bool found_field = false;
            var instance_type = this.GetInstance().GetType();
            var fields = instance_type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            foreach (var field in fields)
            {
                if (field.FieldType == typeof(List<IXMLTVProgram>))
                {
                    found_field = true;
                    try
                    {
                        
                        var list = (List<IXMLTVProgram>)field.GetValue(this.GetInstance());
                        MetaData["Id"] = list.Count + 1;
                        list.Add(this);
                        xmltv_logger.Verbose.Debug.WriteLine("Updating instance with program information: {0}", this.ToString());
                        field.SetValue(this.GetInstance(), list);
                        break;
                    }
                    catch (Exception ex)
                    {
                        xmltv_logger.Verbose.Error.WriteLine("Unable to update instance with program information.");
                        xmltv_logger.Verbose.Error.WriteLine(ex.ToString());
                    }
                }
            }
            if (!found_field)
            {
                xmltv_logger.Verbose.Error.WriteLine("Unable to update instance with program information.");
            }
        }

        private void Create(XElement node)
        {
            CreateHandlerForProgramMetaDataNode(node);
            var nodes = node.Elements().ToList();
            foreach (var sub_node in nodes)
            {
                if (this.GetInstance().IsAborting)
                {
                    break;
                }
                CreateHandlerForProgramMetaDataNode(sub_node);
            }
        }
        private static DateTime ParseDate(string timeStamp)
        {
            DateTime dt = new DateTime();
            try
            {
                dt = DateTime.ParseExact(timeStamp, "yyyyMMddHHmmss zzzz", System.Globalization.CultureInfo.CurrentCulture);
            }
            catch (Exception ex) { throw ex; }
            return dt;
        }

        private void CreateHandlerForProgramMetaDataNode(XElement node)
        {

            Type t = this.GetType();
            Assembly asm = t.Assembly;
            var types = asm.GetTypes();
            var classes = types.ToList().FindAll(
                m => 
                    m.DeclaringType == t &&
                    m.IsClass &&
                    !m.IsSealed
                );
            classes.TrimExcess();

            object raw_instance = null;
            BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
            CultureInfo culture = CultureInfo.CurrentCulture;
            Type handler_type = null;
            foreach (var type in classes)
            {
                if (type.BaseType != null && type.BaseType == typeof(XMLTVBase<XMLTVProgram>))
                {
                    var iface = type.GetInterface("IXMLTVHandler", true);
                    if (iface != null)
                    {
                        var handler_prop = type.GetProperty("Handler");
                        if (handler_prop != null)
                        {
                            var ctors = type.GetConstructors(flags);
                            bool has_default_ctor = false;
                            foreach (var ctor in ctors) { if (ctor.GetParameters().Count() == 0) { has_default_ctor = true; } }
                            if (!has_default_ctor) { continue; }
                            raw_instance = Activator.CreateInstance(type, flags, null, new object[0], culture);
                            if (raw_instance != null)
                            {
                                object handler_value = handler_prop.GetValue(raw_instance, null);
                                if (handler_value != null && handler_value.ToString() == node.Name.ToString())
                                {
                                    handler_type = type;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            if (handler_type == null)
            {
                StringBuilder node_builder = new StringBuilder();
                node_builder.AppendFormat("<{0} ", node.Name);
                if (node.HasAttributes) { foreach (var attribute in node.Attributes()) { node_builder.AppendFormat("{0}=\"{1}\" ", attribute.Name, attribute.Value); } }
                string node_text = string.Format("{0}>", node_builder.ToString().TrimEnd(new char[] { ' ' }));
                xmltv_logger.Verbose.Warn.WriteLine("Ignoring unhandled extra meta-data: {0}", node_text);
            }
            else
            {
                raw_instance = Activator.CreateInstance(handler_type, flags, null, new object[] { this, node }, culture);
            }
        }


        #region sub-classes
        #region program title
        private class title : XMLTVBase<XMLTVProgram>
        {
            public title() : base(null, XMLTVConstants.Programs.ProgramTitle) { }
            public title(XMLTVProgram instance, XElement node)
                : base(instance, XMLTVConstants.Programs.ProgramTitle)
            {                
                if(node == null){throw new NullReferenceException("The node instance was null");}                
                if (node.Value != null)
                {
                    instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramTitle, node.Value);
                    xmltv_logger.Verbose.Debug.WriteLine("\tprogram_title: {0}", node.Value);
                }                
            }
        }
        #endregion
        #region program stop/start/channel (programme)
        private class programme : XMLTVBase<XMLTVProgram>
        {
            public programme() : base(null, XMLTVConstants.Programs.RootElement) { }
            public programme(XMLTVProgram instance, XElement node)
                : base(instance, XMLTVConstants.Programs.RootElement)
            {
                if (node == null) { throw new NullReferenceException("The node instance was null"); }
                if (node.HasAttributes)
                {                    
                    var start = node.Attribute(XMLTVConstants.Programs.ProgramStart);
                    var t_start = start == null ? new DateTime() : ParseDate(start.Value);
                    if (!t_start.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_start: {0}", start); }
                    instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramStart, t_start);

                    var stop = node.Attribute(XMLTVConstants.Programs.ProgramStop);
                    var t_stop = stop == null ? new DateTime() : ParseDate(stop.Value);
                    if (!t_stop.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_stop: {0}", stop); }
                    instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramStop, t_stop);

                    var channelid = node.Attribute(XMLTVConstants.Programs.ProgramChannelId);
                    if (channelid != null)
                    {
                        if (!string.IsNullOrEmpty(channelid.Value)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_channelid: {0}", channelid.Value); }
                        instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramChannelId, channelid.Value);
                    }
                    
                }
            }
        }
        #endregion

        #region sub title
        private class subtitle : XMLTVBase<XMLTVProgram>
        {
            public subtitle() : base(null, XMLTVConstants.Programs.ProgramSubTitle) { }
            public subtitle(XMLTVProgram instance, XElement node)
                : base(instance, XMLTVConstants.Programs.ProgramSubTitle)
            {
                if (node == null) { throw new NullReferenceException("The node instance was null"); }
                if (node.Value != null)
                {
                    instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramSubTitle, node.Value);
                    xmltv_logger.Verbose.Debug.WriteLine("\tprogram_subtitle: {0}", node.Value);
                }
            }
        }
        #endregion
        #region sub title
        private class description : XMLTVBase<XMLTVProgram>
        {
            public description() : base(null, XMLTVConstants.Programs.ProgramDescription) { }
            public description(XMLTVProgram instance, XElement node)
                : base(instance, XMLTVConstants.Programs.ProgramDescription)
            {
                if (node == null) { throw new NullReferenceException("The node instance was null"); }
                if (node.Value != null)
                {
                    instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramDescription, node.Value);
                    xmltv_logger.Verbose.Debug.WriteLine("\tprogram_description: {0}", node.Value);
                }
            }
        }
        #endregion
        #endregion
    }
}
1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Text;
5	using libxmltv.Interfaces;
6	using System.Xml.Linq;
7	using System.Reflection;
8	using System.IO;
9	using System.Diagnostics;
10	using System.Globalization;
11
12	namespace libxmltv.Core
13	{
14	[Serializable]
15	internal class XMLTVProgram : XMLTVBase<XMLTVRuntimeInstance>, IXMLTVProgram
16	{
17	public XMLTVProgram()
18	: base(null, XMLTVConstants.Programs.RootElement)
19	{
20	InternalDictionaryAddKnownProperties();
21
22	}
23	public XMLTVProgram(XMLTVRuntimeInstance instance, XElement node)
24	: base(instance, XMLTVConstants.Programs.RootElement)
25	{
26	InternalDictionaryAddKnownProperties();
27	try {
28	xmltv_logger.Verbose.Debug.WriteLine("Creating Instance of XMLTVProgram");
29	Create(node);
30	xmltv_logger.Verbose.Debug.WriteLine("Created Instance of XMLTVProgram");
31	UpdateInstance();
32	}
33	catch (IOException ex) { Debug.WriteLine(ex.ToString()); }
34	}
35	#region IXMLTVProgram members
36	//public int Id { get; set; }
37	//public DateTime Start { get; set; }
38	//public DateTime Stop { get; set; }
39	//public IXMLTVChannel Channel { get; set; }
40	//public string Title { get; set; }
41	//public string SubTitle { get; set; }
42	//public string Description { get; set; }
43
44	private void InternalDictionaryAddKnownProperties()
45	{
46	MetaData = new PropertyDictionary();
47	MetaData.AddProperty("Id", 0);
48	MetaData.AddProperty(XMLTVConstants.Programs.ProgramStart, new DateTime());
49	MetaData.AddProperty(XMLTVConstants.Programs.ProgramStop, new DateTime());
50	MetaData.AddProperty(XMLTVConstants.Programs.ProgramChannelId, string.Empty);
51	MetaData.AddProperty(XMLTVConstants.Programs.ProgramTitle, string.Empty);
52	MetaData.AddProperty(XMLTVConstants.Programs.ProgramSubTitle, string.Empty);
53	MetaData.AddProperty(XMLTVConstants.Programs.ProgramDescription, string.Empty);
54	}
55
56	#region Property Dictionary Support
57	public PropertyDictionary MetaData { get; private set; }
58	#endregion
59
60	#endregion
61	public override string ToString()
62	{
63	return string.Format("{0}: {1} - {2} ({3}) ['{4}' <==> '{5}']",
64	MetaData["Id"].ToString(),
65	MetaData[(XMLTVConstants.Programs.ProgramTitle)].ToString(),
66	MetaData[(XMLTVConstants.Programs.ProgramSubTitle)].ToString(),
67	MetaData[(XMLTVConstants.Programs.ProgramChannelId)].ToString(),
68	((DateTime)MetaData[XMLTVConstants.Programs.ProgramStart]).ToString("yyyy/MM/dd hh:mm tt"),
69	((DateTime)MetaData[XMLTVConstants.Programs.ProgramStop]).ToString("yyyy/MM/dd hh:mm tt"));
70	}
71
72
73
74
75	private void UpdateInstance()
76	{
77	bool found_field = false;
78	var instance_type = this.GetInstance().GetType();
79	var fields = instance_type.GetFields(BindingFlags.Public \| BindingFlags.NonPublic \| BindingFlags.Instance);
80	foreach (var field in fields)
81	{
82	if (field.FieldType == typeof(List<IXMLTVProgram>))
83	{
84	found_field = true;
85	try
86	{
87
88	var list = (List<IXMLTVProgram>)field.GetValue(this.GetInstance());
89	MetaData["Id"] = list.Count + 1;
90	list.Add(this);
91	xmltv_logger.Verbose.Debug.WriteLine("Updating instance with program information: {0}", this.ToString());
92	field.SetValue(this.GetInstance(), list);
93	break;
94	}
95	catch (Exception ex)
96	{
97	xmltv_logger.Verbose.Error.WriteLine("Unable to update instance with program information.");
98	xmltv_logger.Verbose.Error.WriteLine(ex.ToString());
99	}
100	}
101	}
102	if (!found_field)
103	{
104	xmltv_logger.Verbose.Error.WriteLine("Unable to update instance with program information.");
105	}
106	}
107
108	private void Create(XElement node)
109	{
110	CreateHandlerForProgramMetaDataNode(node);
111	var nodes = node.Elements().ToList();
112	foreach (var sub_node in nodes)
113	{
114	if (this.GetInstance().IsAborting)
115	{
116	break;
117	}
118	CreateHandlerForProgramMetaDataNode(sub_node);
119	}
120	}
121	private static DateTime ParseDate(string timeStamp)
122	{
123	DateTime dt = new DateTime();
124	try
125	{
126	dt = DateTime.ParseExact(timeStamp, "yyyyMMddHHmmss zzzz", System.Globalization.CultureInfo.CurrentCulture);
127	}
128	catch (Exception ex) { throw ex; }
129	return dt;
130	}
131
132	private void CreateHandlerForProgramMetaDataNode(XElement node)
133	{
134
135	Type t = this.GetType();
136	Assembly asm = t.Assembly;
137	var types = asm.GetTypes();
138	var classes = types.ToList().FindAll(
139	m =>
140	m.DeclaringType == t &&
141	m.IsClass &&
142	!m.IsSealed
143	);
144	classes.TrimExcess();
145
146	object raw_instance = null;
147	BindingFlags flags = BindingFlags.Public \| BindingFlags.NonPublic \| BindingFlags.Instance;
148	CultureInfo culture = CultureInfo.CurrentCulture;
149	Type handler_type = null;
150	foreach (var type in classes)
151	{
152	if (type.BaseType != null && type.BaseType == typeof(XMLTVBase<XMLTVProgram>))
153	{
154	var iface = type.GetInterface("IXMLTVHandler", true);
155	if (iface != null)
156	{
157	var handler_prop = type.GetProperty("Handler");
158	if (handler_prop != null)
159	{
160	var ctors = type.GetConstructors(flags);
161	bool has_default_ctor = false;
162	foreach (var ctor in ctors) { if (ctor.GetParameters().Count() == 0) { has_default_ctor = true; } }
163	if (!has_default_ctor) { continue; }
164	raw_instance = Activator.CreateInstance(type, flags, null, new object[0], culture);
165	if (raw_instance != null)
166	{
167	object handler_value = handler_prop.GetValue(raw_instance, null);
168	if (handler_value != null && handler_value.ToString() == node.Name.ToString())
169	{
170	handler_type = type;
171	break;
172	}
173	}
174	}
175	}
176	}
177	}
178	if (handler_type == null)
179	{
180	StringBuilder node_builder = new StringBuilder();
181	node_builder.AppendFormat("<{0} ", node.Name);
182	if (node.HasAttributes) { foreach (var attribute in node.Attributes()) { node_builder.AppendFormat("{0}=\"{1}\" ", attribute.Name, attribute.Value); } }
183	string node_text = string.Format("{0}>", node_builder.ToString().TrimEnd(new char[] { ' ' }));
184	xmltv_logger.Verbose.Warn.WriteLine("Ignoring unhandled extra meta-data: {0}", node_text);
185	}
186	else
187	{
188	raw_instance = Activator.CreateInstance(handler_type, flags, null, new object[] { this, node }, culture);
189	}
190	}
191
192
193
194	#region sub-classes
195	#region program title
196	private class title : XMLTVBase<XMLTVProgram>
197	{
198	public title() : base(null, XMLTVConstants.Programs.ProgramTitle) { }
199	public title(XMLTVProgram instance, XElement node)
200	: base(instance, XMLTVConstants.Programs.ProgramTitle)
201	{
202	if(node == null){throw new NullReferenceException("The node instance was null");}
203	if (node.Value != null)
204	{
205	instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramTitle, node.Value);
206	xmltv_logger.Verbose.Debug.WriteLine("\tprogram_title: {0}", node.Value);
207	}
208	}
209	}
210	#endregion
211	#region program stop/start/channel (programme)
212	private class programme : XMLTVBase<XMLTVProgram>
213	{
214	public programme() : base(null, XMLTVConstants.Programs.RootElement) { }
215	public programme(XMLTVProgram instance, XElement node)
216	: base(instance, XMLTVConstants.Programs.RootElement)
217	{
218	if (node == null) { throw new NullReferenceException("The node instance was null"); }
219	if (node.HasAttributes)
220	{
221	var start = node.Attribute(XMLTVConstants.Programs.ProgramStart);
222	var t_start = start == null ? new DateTime() : ParseDate(start.Value);
223	if (!t_start.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_start: {0}", start); }
224	instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramStart, t_start);
225
226	var stop = node.Attribute(XMLTVConstants.Programs.ProgramStop);
227	var t_stop = stop == null ? new DateTime() : ParseDate(stop.Value);
228	if (!t_stop.Equals(new DateTime())) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_stop: {0}", stop); }
229	instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramStop, t_stop);
230
231	var channelid = node.Attribute(XMLTVConstants.Programs.ProgramChannelId);
232	if (channelid != null)
233	{
234	if (!string.IsNullOrEmpty(channelid.Value)) { xmltv_logger.Verbose.Debug.WriteLine("\tprogram_channelid: {0}", channelid.Value); }
235	instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramChannelId, channelid.Value);
236	}
237
238	}
239	}
240	}
241	#endregion
242
243	#region sub title
244	private class subtitle : XMLTVBase<XMLTVProgram>
245	{
246	public subtitle() : base(null, XMLTVConstants.Programs.ProgramSubTitle) { }
247	public subtitle(XMLTVProgram instance, XElement node)
248	: base(instance, XMLTVConstants.Programs.ProgramSubTitle)
249	{
250	if (node == null) { throw new NullReferenceException("The node instance was null"); }
251	if (node.Value != null)
252	{
253	instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramSubTitle, node.Value);
254	xmltv_logger.Verbose.Debug.WriteLine("\tprogram_subtitle: {0}", node.Value);
255	}
256	}
257	}
258	#endregion
259	#region sub title
260	private class description : XMLTVBase<XMLTVProgram>
261	{
262	public description() : base(null, XMLTVConstants.Programs.ProgramDescription) { }
263	public description(XMLTVProgram instance, XElement node)
264	: base(instance, XMLTVConstants.Programs.ProgramDescription)
265	{
266	if (node == null) { throw new NullReferenceException("The node instance was null"); }
267	if (node.Value != null)
268	{
269	instance.MetaData.AddProperty(XMLTVConstants.Programs.ProgramDescription, node.Value);
270	xmltv_logger.Verbose.Debug.WriteLine("\tprogram_description: {0}", node.Value);
271	}
272	}
273	}
274	#endregion
275	#endregion
276	}
277	}