[Bobbot-cvs] Plugins/Sphere/PunishSystem BanEntry.cs,NONE,1.1 BanSystem.cs,NONE,1.1 JailEntry.cs,NONE,1.1 JailSystem.cs,NONE,1.1

[Mr S. C. <mrs...@us...>]

Update of /cvsroot/bobbot/Plugins/Sphere/PunishSystem
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv22510/Sphere/PunishSystem

Added Files:
	BanEntry.cs BanSystem.cs JailEntry.cs JailSystem.cs 
Log Message:
- Renamed the NameSpace 'JailSystem' to 'PunishSystem'
- Added BanSystem class
   - Bans accounts from the Sphere Server.
   - Works exactly the same as the JailSystem class, without having sentence lengths.
- Added BanEntry class

--- NEW FILE: JailEntry.cs ---
#region LGPL License
/*
Bastard of a Bot Library
Copyright (C) 2004  Bastard of a Bot Team

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#endregion

using System;
using System.Xml;
using System.Collections;
using System.Timers;

namespace Bot.Plugins.Sphere.PunishSystem
{
	public class JailEntry
	{
		#region Private members

		protected string m_Account;
		protected string m_Character;
		protected string m_GMName;
		protected DateTime m_JailEnd = DateTime.Now;
		protected DateTime m_JailStart = DateTime.Now;
		protected string m_Reason;

		protected JailSystem m_JailSystem;
		protected Timer m_JailTimer;

		#endregion

		#region Public properties

		public virtual string Account
		{
			get { return m_Account; }
			set { m_Account = value; }
		}

		public virtual string Character
		{
			get { return m_Character; }
			set { m_Character = value; }
		}

		public virtual string JailedBy
		{
			get { return m_GMName; }
			set { m_GMName = value; }
		}

		public virtual string Reason
		{
			get { return m_Reason; }
			set { m_Reason = value; }
		}

		public virtual DateTime JailedOn
		{
			get { return m_JailStart; }
			set { m_JailStart = value; }
		}

		public virtual DateTime JailedUntil
		{
			get { return m_JailEnd; }
			set { m_JailEnd = value; }
		}

		public virtual string TimeLeft
		{
			get 
			{
				if (m_JailTimer == null || !m_JailTimer.Enabled)
					return "Sentence Disabled";

				TimeSpan sentence = m_JailEnd.Subtract(DateTime.Now);

				return String.Format("{0} hours left", Convert.ToInt32(sentence.TotalHours));
			}
		}

		#endregion

		#region Public methods	

		public void StartSentence()
		{
			if (m_JailTimer != null)
			{
				m_JailTimer.Stop();
				m_JailTimer.Dispose();
			}

			TimeSpan sentence = m_JailEnd.Subtract(DateTime.Now);

			if (sentence.TotalMilliseconds < 30)
				m_JailTimer = new Timer(30);
			else
				m_JailTimer = new Timer(sentence.TotalMilliseconds);

			m_JailTimer.AutoReset = false;
			m_JailTimer.Elapsed += new ElapsedEventHandler(this.OnSentenceServed);
			m_JailTimer.Start();
		}

		public bool Load(XmlElement xmlElement)
		{
			string account = xmlElement.GetAttribute("account");
			string jailedon = xmlElement.GetAttribute("jailedon");
			
			if(account == String.Empty)
				return false;

			m_Account = account;
			m_JailStart = DateTime.FromFileTime(long.Parse(jailedon));

			m_Character = xmlElement["JailedChar"].InnerText;
			m_GMName = xmlElement["JailedBy"].InnerText;
			m_JailEnd = DateTime.FromFileTime(long.Parse(xmlElement["JailedUntil"].InnerText));
			m_Reason = xmlElement["Reason"].InnerText;

			StartSentence();

			return true;
		}

		public bool Save(XmlElement xmlElement)
		{
			xmlElement.SetAttribute("account", m_Account);
			xmlElement.SetAttribute("jailedon", m_JailStart.ToFileTime().ToString());
			
			XmlNode valueText;
			XmlElement valueElement;

			valueText = xmlElement.OwnerDocument.CreateNode(XmlNodeType.Text, "JailedChar", "");
			valueText.Value = m_Character;
			valueElement = xmlElement.OwnerDocument.CreateElement("JailedChar");
			valueElement.AppendChild(valueText);
			xmlElement.AppendChild(valueElement);
			
			valueText = xmlElement.OwnerDocument.CreateNode(XmlNodeType.Text, "JailedBy", "");
			valueText.Value = m_GMName;
			valueElement = xmlElement.OwnerDocument.CreateElement("JailedBy");
			valueElement.AppendChild(valueText);
			xmlElement.AppendChild(valueElement);
			
			valueText = xmlElement.OwnerDocument.CreateNode(XmlNodeType.Text, "JailedUntil", "");
			valueText.Value = m_JailEnd.ToFileTime().ToString();
			valueElement = xmlElement.OwnerDocument.CreateElement("JailedUntil");
			valueElement.AppendChild(valueText);
			xmlElement.AppendChild(valueElement);
			
			valueText = xmlElement.OwnerDocument.CreateNode(XmlNodeType.Text, "Reason", "");
			valueText.Value = m_Reason;
			valueElement = xmlElement.OwnerDocument.CreateElement("Reason");
			valueElement.AppendChild(valueText);
			xmlElement.AppendChild(valueElement);

			return true;
		}
		#endregion

		#region Event Handlers

		private void OnSentenceServed(object sender, ElapsedEventArgs e)
		{
			try
			{
				if (!m_JailSystem.Release(this))
				{
					Bot.Core.Log.WriteLine("Sphere (JailDB)", "Failed to release '{0}'. Retrying in 5 minutes.", m_Account);
					m_JailTimer.AutoReset = false;
					m_JailTimer.Interval = 300000;  // Try to release again in 5 minutes.
					m_JailTimer.Start();
					return;
				}

				return;
			}

			catch (System.Exception ex)
			{
				Bot.Core.Log.WriteLine("Sphere (JailDB)", "Account '{0}' isn't released due to an error! - {1}", m_Account, ex.ToString());
				m_JailTimer.AutoReset = false;
				m_JailTimer.Interval = 300000;  // Try to release again in 5 minutes.
				m_JailTimer.Start();
				return;
			}
		}

		#endregion

		#region Constructor

		public JailEntry(JailSystem system)
		{
			m_JailSystem = system;
		}

		#endregion
	}
}

--- NEW FILE: BanSystem.cs ---
#region LGPL License
/*
Bastard of a Bot Library
Copyright (C) 2004  Bastard of a Bot Team

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#endregion

using System;
using System.IO;
using System.Collections;
using System.Xml;
using System.Text;

using Bot.Core;
using Bot.Core.Irc;
using Bot.Core.Irc.Messages;

using Bot.Plugins.Sphere;
using Bot.Plugins.Sphere.Messages;
using Bot.Plugins.Sphere.Accounting;

using Bot.Other.Sphere;
using Bot.Other.Sphere.Messages;

namespace Bot.Plugins.Sphere.PunishSystem
{
	public class BanSystem
	{
		#region Private Members
		private string BanDatabase = "BanDatabase.xml";
		private SphereConnection m_Server;
		private SpherePlugin m_Parent;

		private BanEntry[] m_BanEntries
		{
			get { return (BanEntry[]) m_BanEntryList.ToArray(typeof(BanEntry)); }
		}

		private ArrayList m_BanEntryList;
		#endregion

		#region Public Properties

		public int BannedAccounts
		{
			get { return m_BanEntryList.Count; }
		}

		#endregion

		#region Constructor
		public BanSystem(SpherePlugin parent)
		{
			m_Parent = parent;
			m_Server = m_Parent.InnerConnection;
			Init();
		}

		public BanSystem(SpherePlugin parent, string database)
		{
			m_Parent = parent;
			m_Server = m_Parent.InnerConnection;
			this.BanDatabase = database;
			Init();
		}

		private void Init()
		{
			m_BanEntryList = new ArrayList();

			if (!File.Exists(this.BanDatabase))
			{
				Log.WriteLine("Sphere (BanDB)", "Database Not Found. Creating '{0}'", this.BanDatabase);
				StreamWriter newDb = File.CreateText(BanDatabase);
				newDb.WriteLine("<!-- Wireplay Lothlorien Ban Database -->");
				newDb.WriteLine("<!-- Database Created at {0}", DateTime.Now.ToString());
				newDb.Close();
				SaveDatabase();
			}

			if (!LoadDatabase())
				Log.WriteLine("Sphere (BanDB)", "Error occured whilst loading the Ban Database.");

			Log.WriteLine("Sphere (BanDB)", "{0} Ban Entries Loaded", this.m_BanEntries.Length);

			SaveDatabase();

			m_Server.CustomEvent += new EventHandler(OnCustomEvent);
		}
		#endregion

		#region Database Save/Load
		public bool LoadDatabase()
		{
			try
			{
				Log.WriteLine("Sphere (BanDB)", "Loading Ban Database from '{0}'...", this.BanDatabase);

				XmlDocument xmlDoc = new XmlDocument();
				xmlDoc.Load(this.BanDatabase);

				XmlElement xmlRoot = xmlDoc.DocumentElement;
				XmlNodeList xmlList = xmlRoot.GetElementsByTagName("BanEntry");

				if(xmlList.Count == 0)
					return true;

				foreach(XmlElement xmlElement in xmlList)
				{
					BanEntry entry = new BanEntry( this );
				
					if(entry.Load(xmlElement))
						m_BanEntryList.Add(entry);
				}

				return true;
			}

			catch(Exception ex)
			{
				Log.WriteLine("Sphere (BanDB)", "Failed to load Ban Database file, reason: {0}", ex.ToString());
				return false;
			}
		}

		public bool SaveDatabase()
		{
			try
			{
				Log.WriteLine("Sphere (BanDB)", "Writing database to '{0}'...", this.BanDatabase);

				XmlTextWriter xmlWriter = new XmlTextWriter(this.BanDatabase, Encoding.UTF8);
				xmlWriter.Formatting = Formatting.Indented;
				xmlWriter.Indentation = 4;

				XmlDocument xmlDoc = new XmlDocument();
				XmlNode xmlRoot = xmlDoc.CreateNode(XmlNodeType.Element, "BanDatabase", "");

				xmlDoc.AppendChild(xmlRoot);
								
				
				foreach(BanEntry entry in m_BanEntries)
				{
					XmlElement xmlElement = xmlDoc.CreateElement("BanEntry");
					xmlRoot.AppendChild(xmlElement);

					(entry).Save(xmlElement);
				}

				xmlDoc.Save(xmlWriter);

				xmlWriter.Flush();
				xmlWriter.Close();
				return true;
			}

			catch(Exception ex)
			{
				Log.WriteLine("Sphere (BanDB)", "Failed to write Ban Database file, reason: {0}", ex.Message);
				return false;
			}
		}
		#endregion

		#region Public Methods
		public bool AddEntry(string account, string character, string gm, string reason)
		{
			try
			{
				if (IsBanned(account))
					return false;

				BanEntry entry = new BanEntry( this );
				entry.Account = account;
				entry.Character = character;
				entry.BannedBy = gm;
				entry.BannedOn = DateTime.Now;
				entry.Reason = reason;
				m_BanEntryList.Add(entry);
				return true;
			}

			catch { return false; }
		}

		public bool DelEntry(string account)
		{
			try
			{
				if (!IsBanned(account))
					return false;

				for (int i = 0; i < m_BanEntryList.Count; i++)
				{
					if (((BanEntry) m_BanEntryList[i]).Account.ToLower() == account.ToLower())
					{
						m_BanEntryList.RemoveAt(i);
						return true;
					}

				}
				return false;
			}

			catch { return false; }
		}

		public bool EditEntry(string account, string gm, string reason)
		{
			try
			{
				if (!IsBanned(account))
					return false;

				BanEntry entry = GetBanEntry(account);

				if (entry.BannedBy.IndexOf(" (Amended by ") > -1)
					entry.BannedBy = entry.BannedBy.Substring(0, entry.BannedBy.IndexOf(' '));
				if (gm != entry.BannedBy)
					entry.BannedBy += " (Amended by " + gm + ")";

				if (reason != null)
					entry.Reason = reason;

				if (!DelEntry(account))
					return false;

				m_BanEntryList.Add(entry);
				return true;
			}

			catch { return false; }
		}

		public BanEntry[] GetBanEntryList()
		{
			return m_BanEntries;
		}

		public BanEntry GetBanEntry(string account)
		{
			foreach (BanEntry i in m_BanEntries)
			{
				if (i.Account.ToLower() == account.ToLower())
					return i;

			}

			return null;
		}

		public bool Ban(string[] args)
		{
			if (args.Length < 5)
				return false;

			return Ban(args[0], args[1], args[2], args[3]);
		}

		public bool Ban(string account, string character, string gm, string reason)
		{
			if (!m_Server.IsConnected) { return false; }

			try
			{
				if (reason == null || reason == "")
					reason = "None Set";

				if (character == null || character == "")
					character = "All";

				m_Server.WriteLine("account {0} block 1", account);

				if (!AddEntry(account, character, gm, reason))
					return false;

				Log.WriteLine("Sphere (BanDB)", "Account '{0}' is banned by {1}! (Reason: {3})", account, gm, reason);
				return true;
			}

			catch { return false; }
		}

		public bool EditBan(string[] args)
		{
			if (args.Length < 5)
				return false;

			return EditBan(args[0], args[1], args[2]);
		}

		public bool EditBan(string account, string gm, string reason)
		{
			if (!m_Server.IsConnected) { return false; }

			try
			{
				if (!IsBanned(account))
					return false;

				if (reason == null || reason == "")
					reason = null;

				if (!EditEntry(account, gm, reason))
					return false;

				Log.WriteLine("Sphere (BanDB)", "Account Entry '{0}' is edited by {1}! (Reason: {3})", account, gm, (reason == null || reason == ""? "Unedited" : reason ));
				return true;
			}

			catch { return false; }
		}

		public bool UnBan(string[] args)
		{
			return UnBan(args[0], args[1]);
		}

		public bool UnBan(BanEntry entry)
		{
			return UnBan(entry.Account, entry.BannedBy);
		}

		public bool UnBan(string account, string gm)
		{
			if (!m_Server.IsConnected) { return false; }

			try
			{
				if (!IsBanned(account))
					return false;

				m_Server.WriteLine("account {0} block 0", account);

				if (!DelEntry(account))
					return false;

				Log.WriteLine("Sphere (BanDB)", "Account '{0}' is unbanned by '{1}'!", account, gm);
				return true;
			}

			catch { return false; }
		}

		public bool IsBanned(string account)
		{
			for (int i = 0; i < m_BanEntryList.Count; i++)
			{
				if (((BanEntry) m_BanEntryList[i]).Account.ToLower() == account.ToLower())
					return true;

			}
			
			return false;
		}

		#endregion

		private void OnCustomEvent(object sender, EventArgs args)
		{
			/*
			if(args is PlayerBannedEventArgs)
				OnPlayerBanned(sender, (PlayerBannedEventArgs) args);
			else if(args is PlayerUnBannedEventArgs)
				OnPlayerUnBanned(sender, (PlayerUnBannedEventArgs) args);*/
		}

/*		private void OnPlayerBanned(object sender, PlayerBannedEventArgs args)
		{
			
			string account = m_Server.GetItemProperty(args.Message.Player, "account");
			string character = m_Server.GetItemProperty(args.Message.Player, "name");
			string gm = m_Server.GetItemProperty(args.Message.GM, "name");

			if (!Ban(account, character, gm, args.Message.Reason))
				Kernel.Instance.Network.SendChannelMessage(m_Parent.InnerConfig.OutputChannel, "Unable to Ban Account '{0}'.", account);
				
		}

		private void OnPlayerUnBanned(object sender, PlayerUnBannedEventArgs args)
		{

			string account = m_Server.GetItemProperty(args.Message.Player, "account");
			string gm = m_Server.GetItemProperty(args.Message.GM, "name");

			if (!UnBan(account, gm))
				Kernel.Instance.Network.SendChannelMessage(m_Parent.InnerConfig.OutputChannel, "Unable to UnBan Account '{0}'.", account);
				
		}
	*/
	}
}

--- NEW FILE: BanEntry.cs ---
#region LGPL License
/*
Bastard of a Bot Library
Copyright (C) 2004  Bastard of a Bot Team

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#endregion

using System;
using System.Xml;
using System.Collections;
using System.Timers;

namespace Bot.Plugins.Sphere.PunishSystem
{
	public class BanEntry
	{
		#region Private members

		protected string m_Account;
		protected string m_Character;
		protected string m_GMName;
		protected DateTime m_BanTime = DateTime.Now;
		protected string m_Reason;

		protected BanSystem m_BanSystem;

		#endregion

		#region Public properties

		public virtual string Account
		{
			get { return m_Account; }
			set { m_Account = value; }
		}

		public virtual string Character
		{
			get { return m_Character; }
			set { m_Character = value; }
		}

		public virtual string BannedBy
		{
			get { return m_GMName; }
			set { m_GMName = value; }
		}

		public virtual string Reason
		{
			get { return m_Reason; }
			set { m_Reason = value; }
		}

		public virtual DateTime BannedOn
		{
			get { return m_BanTime; }
			set { m_BanTime = value; }
		}

		#endregion

		#region Public methods	

		public bool Load(XmlElement xmlElement)
		{
			string account = xmlElement.GetAttribute("account");
			string bannedon = xmlElement.GetAttribute("datetime");
			
			if(account == String.Empty)
				return false;

			m_Account = account;
			m_BanTime = DateTime.FromFileTime(long.Parse(bannedon));

			m_Character = xmlElement["BannedChar"].InnerText;
			m_GMName = xmlElement["BannedBy"].InnerText;
			m_Reason = xmlElement["Reason"].InnerText;

			return true;
		}
		
		public bool Save(XmlElement xmlElement)
		{
			xmlElement.SetAttribute("account", m_Account);
			xmlElement.SetAttribute("datetime", m_BanTime.ToFileTime().ToString());
			
			XmlNode valueText;
			XmlElement valueElement;

			valueText = xmlElement.OwnerDocument.CreateNode(XmlNodeType.Text, "BannedChar", "");
			valueText.Value = m_Character;
			valueElement = xmlElement.OwnerDocument.CreateElement("BannedChar");
			valueElement.AppendChild(valueText);
			xmlElement.AppendChild(valueElement);
			
			valueText = xmlElement.OwnerDocument.CreateNode(XmlNodeType.Text, "BannedBy", "");
			valueText.Value = m_GMName;
			valueElement = xmlElement.OwnerDocument.CreateElement("BannedBy");
			valueElement.AppendChild(valueText);
			xmlElement.AppendChild(valueElement);
						
			valueText = xmlElement.OwnerDocument.CreateNode(XmlNodeType.Text, "Reason", "");
			valueText.Value = m_Reason;
			valueElement = xmlElement.OwnerDocument.CreateElement("Reason");
			valueElement.AppendChild(valueText);
			xmlElement.AppendChild(valueElement);

			return true;
		}
		#endregion

		#region Constructor

		public BanEntry(BanSystem system)
		{
			m_BanSystem = system;
		}

		#endregion
	}
}

--- NEW FILE: JailSystem.cs ---
#region LGPL License
/*
Bastard of a Bot Library
Copyright (C) 2004  Bastard of a Bot Team

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#endregion

using System;
using System.IO;
using System.Collections;
using System.Xml;
using System.Text;

using Bot.Core;
using Bot.Core.Irc;
using Bot.Core.Irc.Messages;

using Bot.Plugins.Sphere;
using Bot.Plugins.Sphere.Messages;
using Bot.Plugins.Sphere.Accounting;

using Bot.Other.Sphere;
using Bot.Other.Sphere.Messages;

namespace Bot.Plugins.Sphere.PunishSystem
{
	public class JailSystem
	{
		#region Private Members
		private string JailDatabase = "JailDatabase.xml";
		private SphereConnection m_Server;
		private SpherePlugin m_Parent;

		private JailEntry[] m_JailEntries
		{
			get { return (JailEntry[]) m_JailEntryList.ToArray(typeof(JailEntry)); }
		}

		private ArrayList m_JailEntryList;
		#endregion

		#region Public Properties

		public int JailedAccounts
		{
			get { return m_JailEntryList.Count; }
		}

		#endregion

		#region Constructor
		public JailSystem(SpherePlugin parent)
		{
			m_Parent = parent;
			m_Server = m_Parent.InnerConnection;
			Init();
		}

		public JailSystem(SpherePlugin parent, string database)
		{
			m_Parent = parent;
			m_Server = m_Parent.InnerConnection;
			this.JailDatabase = database;
			Init();
		}

		private void Init()
		{
			m_JailEntryList = new ArrayList();

			if (!File.Exists(this.JailDatabase))
			{
				Log.WriteLine("Sphere (JailDB)", "Database Not Found. Creating '{0}'", this.JailDatabase);
				StreamWriter newDb = File.CreateText(JailDatabase);
				newDb.WriteLine("<!-- Wireplay Lothlorien Jail Database -->");
				newDb.WriteLine("<!-- Database Created at {0}", DateTime.Now.ToString());
				newDb.Close();
				SaveDatabase();
			}

			if (!LoadDatabase())
				Log.WriteLine("Sphere (JailDB)", "Error occured whilst loading the Jail Database.");

			Log.WriteLine("Sphere (JailDB)", "{0} Jail Entries Loaded", this.m_JailEntries.Length);

			SaveDatabase();

			m_Server.CustomEvent += new EventHandler(OnCustomEvent);
		}
		#endregion

		#region Database Save/Load
		public bool LoadDatabase()
		{
			try
			{
				Log.WriteLine("Sphere (JailDB)", "Loading Jail Database from '{0}'...", this.JailDatabase);

				XmlDocument xmlDoc = new XmlDocument();
				xmlDoc.Load(this.JailDatabase);

				XmlElement xmlRoot = xmlDoc.DocumentElement;
				XmlNodeList xmlList = xmlRoot.GetElementsByTagName("JailEntry");

				if(xmlList.Count == 0)
					return true;

				foreach(XmlElement xmlElement in xmlList)
				{
					JailEntry entry = new JailEntry( this );
				
					if(entry.Load(xmlElement))
						m_JailEntryList.Add(entry);
				}

				return true;
			}

			catch(Exception ex)
			{
				Log.WriteLine("Sphere (JailDB)", "Failed to load Jail Database file, reason: {0}", ex.ToString());
				return false;
			}
		}

		public bool SaveDatabase()
		{
			try
			{
				Log.WriteLine("Sphere (JailDB)", "Writing database to '{0}'...", this.JailDatabase);

				XmlTextWriter xmlWriter = new XmlTextWriter(this.JailDatabase, Encoding.UTF8);
				xmlWriter.Formatting = Formatting.Indented;
				xmlWriter.Indentation = 4;

				XmlDocument xmlDoc = new XmlDocument();
				XmlNode xmlRoot = xmlDoc.CreateNode(XmlNodeType.Element, "JailDatabase", "");

				xmlDoc.AppendChild(xmlRoot);
								
				
				foreach(JailEntry entry in m_JailEntries)
				{
					XmlElement xmlElement = xmlDoc.CreateElement("JailEntry");
					xmlRoot.AppendChild(xmlElement);

					(entry).Save(xmlElement);
				}

				xmlDoc.Save(xmlWriter);

				xmlWriter.Flush();
				xmlWriter.Close();
				return true;
			}

			catch(Exception ex)
			{
				Log.WriteLine("Sphere (JailDB)", "Failed to write Jail Database file, reason: {0}", ex.Message);
				return false;
			}
		}
		#endregion

		#region Public Methods
		public bool AddEntry(string account, string character, string gm, TimeSpan length, string reason)
		{
			try
			{
				if (IsJailed(account))
					return false;

				JailEntry entry = new JailEntry( this );
				entry.Account = account;
				entry.Character = character;
				entry.JailedBy = gm;
				entry.JailedOn = DateTime.Now;
				entry.JailedUntil = DateTime.Now.Add(length);
				entry.Reason = reason;
				entry.StartSentence();
				m_JailEntryList.Add(entry);
				return true;
			}

			catch { return false; }
		}

		public bool DelEntry(string account)
		{
			try
			{
				if (!IsJailed(account))
					return false;

				for (int i = 0; i < m_JailEntryList.Count; i++)
				{
					if (((JailEntry) m_JailEntryList[i]).Account.ToLower() == account.ToLower())
					{
						m_JailEntryList.RemoveAt(i);
						return true;
					}

				}
				return false;
			}

			catch { return false; }
		}

		public bool EditEntry(string account, string gm, TimeSpan length, string reason)
		{
			try
			{
				if (!IsJailed(account))
					return false;

				JailEntry entry = GetJailEntry(account);

				if (entry.JailedBy.IndexOf(" (Amended by ") > -1)
					entry.JailedBy = entry.JailedBy.Substring(0, entry.JailedBy.IndexOf(' '));
				if (gm != entry.JailedBy)
					entry.JailedBy += " (Amended by " + gm + ")";

				if (length.TotalMilliseconds > DateTime.Now.Subtract(entry.JailedUntil).TotalMilliseconds)
					entry.JailedUntil = entry.JailedUntil.Add(length);

				if (reason != null)
					entry.Reason = reason;

				entry.StartSentence();

				if (!DelEntry(account))
					return false;

				m_JailEntryList.Add(entry);
				return true;
			}

			catch { return false; }
		}

		public JailEntry[] GetJailEntryList()
		{
			return m_JailEntries;
		}

		public JailEntry GetJailEntry(string account)
		{
			foreach (JailEntry i in m_JailEntries)
			{
				if (i.Account.ToLower() == account.ToLower())
					return i;

			}

			return null;
		}

		public bool Jail(string[] args)
		{
			if (args.Length < 5)
				return false;

			return Jail(args[0], args[1], args[2], args[3], args[4]);
		}

		public bool Jail(string account, string character, string gm, string length, string reason)
		{
			if (!m_Server.IsConnected) { return false; }

			try
			{
				if (reason == null || reason == "")
					reason = "None Set";

				if (character == null || character == "")
					character = "All";

				m_Server.WriteLine("account {0} jail 1", account);

				Account jailed = AccountRegistration.Instance.GetAccount(account);
				for (int i = 0; i < jailed.Chars; i++)
				{
					m_Server.WriteLine("account {0} char.{1}.send_to_jail={2}", account, i, length);
				}

				if (!AddEntry(account, character, gm, TimeSpan.FromHours(double.Parse(length)), reason))
					return false;

				Log.WriteLine("Sphere (JailDB)", "Account '{0}' is jailed by {1}! ({2} hours) (Reason: {3})", account, gm, length, reason);
				return true;
			}

			catch { return false; }
		}

		public bool EditJail(string[] args)
		{
			if (args.Length < 5)
				return false;

			return EditJail(args[0], args[1], args[2], args[3]);
		}

		public bool EditJail(string account, string gm, string length, string reason)
		{
			if (!m_Server.IsConnected) { return false; }

			try
			{
				if (!IsJailed(account))
					return false;

				if (reason == null || reason == "")
					reason = null;

				if (!EditEntry(account, gm, TimeSpan.FromHours(double.Parse(length)), reason))
					return false;

				Log.WriteLine("Sphere (JailDB)", "Account Entry '{0}' is edited by {1}! ({2} hours) (Reason: {3})", account, gm, (double.Parse(length) != 0? length : "Unedited"), (reason == null || reason == ""? "Unedited" : reason ));
				return true;
			}

			catch { return false; }
		}

		public bool Release(string[] args)
		{
			return Release(args[0], args[1]);
		}

		public bool Release(JailEntry entry)
		{
			return Release(entry.Account, entry.JailedBy);
		}

		public bool Release(string account, string gm)
		{
			if (!m_Server.IsConnected) { return false; }

			try
			{
				if (!IsJailed(account))
					return false;

				m_Server.WriteLine("account {0} jail 0", account);
				
				Account jailed = AccountRegistration.Instance.GetAccount(account);
				for (int i = 0; i < jailed.Chars; i++)
				{
					m_Server.WriteLine("account {0} char.{1}.release_from_jail", account, i);
				}

				if (!DelEntry(account))
					return false;

				Log.WriteLine("Sphere (JailDB)", "Account '{0}' is released from jail!", account);
				return true;
			}

			catch { return false; }
		}

		public bool IsJailed(string account)
		{
			for (int i = 0; i < m_JailEntryList.Count; i++)
			{
				if (((JailEntry) m_JailEntryList[i]).Account.ToLower() == account.ToLower())
					return true;

			}
			
			return false;
		}

		#endregion

		private void OnCustomEvent(object sender, EventArgs args)
		{
			if(args is PlayerJailedEventArgs)
				OnPlayerJailed(sender, (PlayerJailedEventArgs) args);
			else if(args is PlayerReleasedEventArgs)
				OnPlayerReleased(sender, (PlayerReleasedEventArgs) args);
		}

		private void OnPlayerJailed(object sender, PlayerJailedEventArgs args)
		{
			string account = m_Server.GetItemProperty(args.Message.Player, "account");
			string character = m_Server.GetItemProperty(args.Message.Player, "name");
			string gm = m_Server.GetItemProperty(args.Message.GM, "name");

			if (!Jail(account, character, gm, args.Message.Length.ToString(), args.Message.Reason))
				Kernel.Instance.Network.SendChannelMessage(m_Parent.InnerConfig.OutputChannel, "Unable to Jail Account '{0}'.", account);
		}

		private void OnPlayerReleased(object sender, PlayerReleasedEventArgs args)
		{
			string account = m_Server.GetItemProperty(args.Message.Player, "account");
			string gm = m_Server.GetItemProperty(args.Message.GM, "name");

			if (!Release(account, gm))
				Kernel.Instance.Network.SendChannelMessage(m_Parent.InnerConfig.OutputChannel, "Unable to Release Account '{0}'.", account);
		}
	}
}