[Adapdev-commits] Adapdev/src/Adapdev.Data/Schema CompareDatabaseSchemas.cs,NONE,1.1 LoadDatabaseSchema.cs,NONE,1.1 SaveDatabaseSchema.cs,NONE,1.1 SchemaConstants.cs,NONE,1.1

[jhbate <jh...@us...>]

Update of /cvsroot/adapdev/Adapdev/src/Adapdev.Data/Schema
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30219/src/Adapdev.Data/Schema

Added Files:
	CompareDatabaseSchemas.cs LoadDatabaseSchema.cs 
	SaveDatabaseSchema.cs SchemaConstants.cs 
Log Message:
added to support the schema XML serialization

--- NEW FILE: SaveDatabaseSchema.cs ---
using System;

namespace Adapdev.Data.Schema
{

	using System.IO;
	using System.Xml.Serialization;
	

	/// <summary>
	/// Summary description for SaveDatabaseSchema.
	/// </summary>
	public class SaveDatabaseSchema
	{
		private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
		private DatabaseSchema _dbSchema;
		private String schemaFile;
		private String _savedSchemaName;

		public SaveDatabaseSchema(DatabaseSchema dbSchema, String savedSchemaName)
		{
			this._dbSchema = dbSchema;
			this._savedSchemaName = savedSchemaName;
		}

		public void Save()
		{	
			schemaFile = System.IO.Path.Combine(SchemaConstants.SCHEMAPATH,_savedSchemaName);
			XmlSerializer dbSerializer = new XmlSerializer(typeof(DatabaseSchema));
			StreamWriter schemaWriter = new StreamWriter(schemaFile);
			dbSerializer.Serialize(schemaWriter, _dbSchema);
			schemaWriter.Close();
		}
	}
}

--- NEW FILE: LoadDatabaseSchema.cs ---
using System;

namespace Adapdev.Data.Schema
{
	using System.Collections;
	using System.IO;
	using System.Xml.Serialization;

	/// <summary>
	/// Summary description for LoadDatabaseSchema.
	/// </summary>
	public class LoadDatabaseSchema
	{
		private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
		private DatabaseSchema _dbSchema;
		private String schemaFile;
		private String _savedSchemaName;

		public LoadDatabaseSchema(String savedSchemaName, DatabaseSchema dbSchema)
		{
			this._savedSchemaName = savedSchemaName;
			this._dbSchema = dbSchema;
		}

		public DatabaseSchema Load()
		{
			schemaFile = System.IO.Path.Combine(SchemaConstants.SCHEMAPATH,this._savedSchemaName);

			if(File.Exists(schemaFile))
			{	
				XmlSerializer dbSerializer = new XmlSerializer(typeof(DatabaseSchema));
				FileStream dbStream = new FileStream(schemaFile, FileMode.Open);
				_dbSchema = (DatabaseSchema) dbSerializer.Deserialize(dbStream);
				dbStream.Close();
			}	
			return _dbSchema;
		}
	}
}
--- NEW FILE: SchemaConstants.cs ---
using System;

namespace Adapdev.Data.Schema
{
	/// <summary>
	/// Summary description for Constants Associated with the Schema
	/// </summary>
	public class SchemaConstants
	{		
		public static readonly string SCHEMAPATH = System.Environment.GetFolderPath(System.Environment.SpecialFolder.LocalApplicationData);
	}
}

--- NEW FILE: CompareDatabaseSchemas.cs ---
using System;

namespace Adapdev.Data.Schema
{
	using System.Reflection;
	using Adapdev.Attributes;

	/// <summary>
	/// Summary description for CompareSchemasCommand.
	/// </summary>
	public class CompareDatabaseSchemas
	{
		private DatabaseSchema _databaseSchema;
		private DatabaseSchema _savedDatabaseSchema;

		public CompareDatabaseSchemas(DatabaseSchema databaseSchema, DatabaseSchema savedDatabaseSchema)
		{
			this._databaseSchema = databaseSchema;
			this._savedDatabaseSchema = savedDatabaseSchema;
		}

		/// <summary>
		/// Compare the saved Schema and the database Schema by iterating through the DatabaseSchema's tables
		/// </summary>
		/// <returns>DatabaseSchema - the updated DatabaseSchema</returns>
		public DatabaseSchema Compare()
		{
			foreach(TableSchema table in _databaseSchema.SortedTables.Values)
			{	
				//If the table exists check it otherwise add the table
				if(null != this._savedDatabaseSchema.GetTable(table.Name))
				{
					foreach (PropertyInfo property in table.GetType().GetProperties())
					{
						foreach (object attribute in property.GetCustomAttributes(typeof(SchemaDataRewritableAttribute),true))
						{
							if(isRewritable(attribute, property))
							{
								rewritePropertyForTable(table, property);
							}	
						}
					}	
					findAndUpdateColumns(table);				
				}
				else
				{
					this._savedDatabaseSchema.AddTable(table);
				}
			}
			return _savedDatabaseSchema;
		}
		
		/// <summary>
		/// Iterate through the ColumnSchema's for a TableSchema and update properties that are rewritable from the Database Schema
		/// </summary>
		/// <param name="table">TableSchema table that we will check it's ColumnSchema's</param>
		private void findAndUpdateColumns(TableSchema table)
		{
			foreach(ColumnSchema column in table.SortedColumns.Values)
			{
				//If the column exists check it otherwise add the column
				if(null != this._savedDatabaseSchema.GetTable(table.Name).GetColumn(column.Name))
				{
					foreach (PropertyInfo property in column.GetType().GetProperties())
					{	
						foreach(object attribute in property.GetCustomAttributes(typeof(SchemaDataRewritableAttribute),true))
						{
							if(isRewritable(attribute,property))
							{
								rewritePropertyForColumn(table,column,property);
							}
						}
					}	
				}
				else
				{
					this._savedDatabaseSchema.GetTable(table.Name).AddColumn(column);
				}
			}
		}

		/// <summary>
		/// Rewrite the TableSchema proprety to match that from the Database
		/// </summary>
		/// <param name="tableToUpdateFrom">TableSchema object that we will use to update from</param>
		/// <param name="property">PropertyInfo</param>
		private void rewritePropertyForTable(TableSchema tableToUpdateFrom, PropertyInfo property)
		{	
			TableSchema tableToUpdate = this._savedDatabaseSchema.GetTable(tableToUpdateFrom.Name);
			PropertyInfo tablePropertyToUpdate = tableToUpdate.GetType().GetProperty(property.Name);
			tablePropertyToUpdate.SetValue(this._savedDatabaseSchema.GetTable(tableToUpdateFrom.Name), property.GetValue(tableToUpdateFrom,null),null);
		}

		/// <summary>
		/// Rewrite the ColumnSchema proprety to match that from the Database
		/// </summary>
		/// <param name="tableToUpdateFrom">TableSchema object that we will use to update from</param>
		/// <param name="columnToUpdateFrom">ColumnSchema object that we will use to update from</param>
		/// <param name="property">PropertyInfo</param>
		private void rewritePropertyForColumn(TableSchema tableToUpdateFrom, ColumnSchema columnToUpdateFrom, PropertyInfo property)
		{
			ColumnSchema columnToUpdate = this._savedDatabaseSchema.GetTable(tableToUpdateFrom.Name).GetColumn(columnToUpdateFrom.Name);
			PropertyInfo columnPropertyToUpdate = columnToUpdate.GetType().GetProperty(property.Name);
			columnPropertyToUpdate.SetValue(columnToUpdate, property.GetValue(columnToUpdateFrom, null),null);
		}
		
		/// <summary>
		/// Is the SchemaDataRewritableAttribute set to update.
		/// </summary>
		/// <param name="attribute">The custom attribute for the property</param>
		/// <param name="property">The Schema PropertyInfo</param>
		/// <returns>bool</returns>
		private bool isRewritable(object attribute,PropertyInfo property)
		{
			return ((SchemaDataRewritableAttribute) attribute).Rewrite && property.CanWrite;
		}
		
	}
}