##|TYPE Template
##|UNIQUEID ce9c6b98-62fe-4a36-9a31-cd33b283f574
##|TITLE CSLA Business Objects
##|NAMESPACE CSLA_21
##|SOURCE_TYPE Source
##|OUTPUT_LANGUAGE C#
##|GUI_ENGINE .Net Script
##|GUI_LANGUAGE C#
##|GUI_BEGIN
<%#NAMESPACE System, System.Text, System.Collections, Zeus, Zeus.UserInterface, Zeus.DotNetScript %>

public class GeneratedGui : DotNetScriptGui
{
	public GeneratedGui( ZeusGuiContext context ) : base( context ) {}
	private bool bInitializing=false;
	public override void Setup()
	{
		bInitializing = true;
		if ( !input.Contains( "chooseTables" ) || !input.Contains( "txtPath" ) ||
				( !input.Contains( "chkClass" ) && !input.Contains( "chkNaming" ) ) )
		{
			if(context.Objects.ContainsKey("DnpUtils"))DnpUtils.ReadInputFromCache(context);
			ui.Title = "CSLA Object Mapping";
			ui.Width = 600;
			ui.Height = 660;
	
			// Grab default output path
			string sOutputPath = "";
			
			if( input.Contains( "defaultOutputPath" ) ) 
			{
				sOutputPath = input["defaultOutputPath"].ToString();
			}
			//int top=0;
			// Setup Folder selection input control.
			GuiLabel label1 = ui.AddLabel( "label1", "Select the output path:", "Select the output path in the field below." );
			label1.Width = 200;
			GuiTextBox outputPath = ui.AddTextBox( "outputPath", sOutputPath, "Select the Output Path." );
			outputPath.Width = 450;
			GuiFilePicker selectPath = ui.AddFilePicker( "selectPath", "Select Path", "Select the Output Path.", "outputPath", true );
			selectPath.Top = outputPath.Top;
			selectPath.Width = 100;
			selectPath.Left = outputPath.Left + outputPath.Width + 20;
			
			// Setup Database selection combobox.
			GuiLabel label4 = ui.AddLabel( "label4", "Select a database:", "Select a database in the dropdown below." );
			label4.Width = 250;
			GuiComboBox chooseDatabase = ui.AddComboBox( "chooseDatabase", "Select a database." );
			chooseDatabase.Width = 250;
			// Namespace
			GuiLabel label2 = ui.AddLabel( "label2", "Namespace: ",  "Provide your objects namespace." );
			label2.Width = 280;
			GuiTextBox classNamespace = ui.AddTextBox( "classNamespace", "VEPROMS.CSLA.Library", "Provide your objects namespace." );				
			classNamespace.Width = 280;
			
						GuiLabel label3 = ui.AddLabel( "label3", "Member prefix: ", "Provide your Prefix." );
			label3.Width = 100;
			label3.Top = label2.Top;
			label3.Left = label2.Width + 20;
			GuiTextBox memberPrefix = ui.AddTextBox( "memberPrefix", "_", "" );
			memberPrefix.Width = 100;
			memberPrefix.Top = classNamespace.Top;
			memberPrefix.Left = classNamespace.Width + 20;
					 
			GuiLabel label3A = ui.AddLabel( "label3A", "dbConnection: ", "Provide a Connection." );
			label3A.Width = 150;
			label3A.Top = label3.Top;
			label3A.Left = label3.Left+label3.Width + 10;
			GuiTextBox dbConnection = ui.AddTextBox( "dbConnection", "VEPROMS", "" );
			dbConnection.Width = 150;
			dbConnection.Top = memberPrefix.Top;
			dbConnection.Left = memberPrefix.Left + memberPrefix.Width + 10;
			GuiCheckBox chkGenerateMain = MakeGuiCheckBox( "chkGenerateMain", "Main", true, "Create Main Object",100 );
			GuiCheckBox chkFKList = MakeGuiCheckBox( "chkFKList", "FK List", true, "Create FK List Object" ,70,chkGenerateMain,100,0);
			GuiCheckBox chkFKItem = MakeGuiCheckBox( "chkFKItem", "FK Item", true, "Create FK Item Object" ,70,chkFKList,0,-1);
			GuiCheckBox chkInfoList = MakeGuiCheckBox( "chkInfoList", "Info List", true, "Create FK Info List Object" ,70,chkFKItem,0,-1);
			GuiCheckBox chkInfo = MakeGuiCheckBox( "chkInfo", "Info", true, "Create Info Object" ,70,chkInfoList,0,-1);
			GuiCheckBox chkPartBM = MakeGuiCheckBox("chkPartBM","Business Methods",true,"Create Business Methods",130,chkGenerateMain,170,0);
			GuiCheckBox chkPartDA = MakeGuiCheckBox("chkPartDA","Data Access",true,"Create Data Access",130,chkGenerateMain,300,0);
			GuiCheckBox chkPartVR = MakeGuiCheckBox("chkPartVR","Validation Rules",true,"Create Validation Rules",130,chkPartBM,0,-1);
			GuiCheckBox chkPartEX = MakeGuiCheckBox("chkPartEX","Exists",true,"Create Exists",130,chkPartDA,0,-1);
			GuiCheckBox chkPartAR = MakeGuiCheckBox("chkPartAR","Authorization Rules",true,"Create Authorization Rules",130,chkPartVR,0,-1);
			GuiCheckBox chkPartDF = MakeGuiCheckBox("chkPartDF","Defaults",true,"Create Defaults",130,chkPartEX,0,-1);
			GuiCheckBox chkPartFM = MakeGuiCheckBox("chkPartFM","Factory Methods",true,"Create Factory Methods",130,chkPartAR,0,-1);
			GuiCheckBox chkPartCM = MakeGuiCheckBox("chkPartCM","Component Model",true,"Create Component Model Interface",130,chkGenerateMain,430,0);
			GuiCheckBox chkPartL4N = MakeGuiCheckBox("chkPartL4N","Log4Net",true,"Create Log4Net Code",130,chkPartCM,0,-1);
			GuiCheckBox chkVolian = MakeGuiCheckBox("chkVolian","Volian Header",true,"Add Header",130,chkPartL4N,0,-1);
			GuiCheckBox chkDatabase = MakeGuiCheckBox("chkDatabase","Database.cs",true,"Create Database Object",130,chkGenerateMain,0,50);
			GuiCheckBox chkPartEXT = MakeGuiCheckBox("chkPartEXT","Extension Sample",true,"Create Extensions",130,chkPartDF,0,-1);
			GuiCheckBox chkCreateFiles = MakeGuiCheckBox( "chkCreateFiles", "Create Code Files", true, "Create Code Files" ,150);
			GuiCheckBox chkDebug = MakeGuiCheckBox("chkDebug","Debug Output",true,"Add Debug",130,chkCreateFiles,150,0);
			chkDebug.Checked = false;
			GuiTextBox tbDebug = ui.AddTextBox( "tbDebug", "", "Start Date" );
			tbDebug.Top = chkDebug.Top;
			tbDebug.Width = 150;
			tbDebug.Left = chkDebug.Left + 150;
			GuiLabel label7 = ui.AddLabel( "label7", "Select tables:", "Select tables from the listbox below." );
			//label7.Top = chkEqualsHashCode.Top + 20;
			GuiListBox chooseTables = ui.AddListBox( "chooseTables", "Select tables." );
			chooseTables.Height = 120;
	
			// Setup Views selection multi-select listbox.
			GuiLabel label8 = ui.AddLabel( "label8", "Select views:", "Select views from the listbox below." );
			GuiListBox chooseViews = ui.AddListBox( "chooseViews", "Select views." );
			chooseViews.Height = 120;
			
			// Attach the onchange event to the cmbDatabases control.
			setupDatabaseDropdown( chooseDatabase );
			chooseDatabase.AttachEvent( "onchange", "chooseDatabase_onchange" );
	
			ui.ShowGui = true;
		}
		else 
		{
			ui.ShowGui = false;
		}
		bInitializing = false;
	}
	public void setupDatabaseDropdown( GuiComboBox Databases )
	{
		try 
		{	
			if( MyMeta.IsConnected )
			{
				Databases.BindData( MyMeta.Databases );
				if( MyMeta.DefaultDatabase != null ) 
				{
					Databases.SelectedValue = MyMeta.DefaultDatabase.Alias;
					bindTables( Databases.SelectedValue );
					bindViews( Databases.SelectedValue );
				}
			}
		}
		catch
		{
		}
	}
	
	public void bindTables( string sDatabase )
	{
		int count = 0;
	
		GuiListBox lstTables = ui["chooseTables"] as GuiListBox;
		
		try 
		{	
			IDatabase db = MyMeta.Databases[sDatabase];
			lstTables.BindData( db.Tables );
		}
		catch
		{
		}
	}
	
	public void bindViews( string sDatabase )
	{
		int count = 0;
	
		GuiListBox lstViews = ui["chooseViews"] as GuiListBox;
		
		try 
		{	
			IDatabase db = MyMeta.Databases[sDatabase];
			lstViews.BindData( db.Views );
		}
		catch
		{
		}
	}
	
	public void chooseDatabase_onchange( GuiComboBox control )
	{
		int count = 0;
		GuiComboBox cmbDatabases = ui["chooseDatabase"] as GuiComboBox;
		bindTables( cmbDatabases.SelectedText );
		bindViews( cmbDatabases.SelectedText );
		GuiTextBox dbConnection = ui["dbConnection"] as GuiTextBox;
		dbConnection.Text=cmbDatabases.SelectedText;
		GuiTextBox classNamespace = ui["classNamespace"] as GuiTextBox;
		classNamespace.Text=cmbDatabases.SelectedText + ".CSLA.Library";
	}
	<%#FILE MakeGuiCheckBox.cs %>
	
}
##|GUI_END
##|BODY_MODE Markup
##|BODY_ENGINE .Net Script
##|BODY_LANGUAGE C#
##|BODY_TAG_START <%
##|BODY_TAG_END %>
##|BODY_BEGIN
<%#NAMESPACE System.IO, System.Text, System.Text.RegularExpressions, System.Globalization %><%
public class GeneratedTemplate : DotNetScriptTemplate
{
	private ArrayList _selectedTables;
	private ArrayList _selectedViews;
	private ArrayList _classList;
	private ArrayList _duplicateList;
	private ArrayList _PropDescList;
	private string _dbName;
	private string _tableName;
	private string _className;
	private string _exportPath;
	private string _nameSpace;
	private string _prefix;
	private string _dbConnection;
	private string _subclassName;
	private string _refreshMine;
	private ITable _workingTable;
	private Hashtable dicRead;
	//private Hashtable dicReadI;
	private bool _chkGenerateMain; 
	private bool _chkFKList; 
	private bool _chkFKItem; 
	private bool _chkInfoList; 
	private bool _chkInfo; 
	private bool _chkCreateFiles; 
	private bool _chkPartBM;
	private bool _chkPartDA;
	private bool _chkPartVR;
	private bool _chkPartEX;
	private bool _chkPartAR;
	private bool _chkPartDF;
	private bool _chkPartFM;
	private bool _chkPartEXT;
	private bool _chkPartCM;
	private bool _chkDatabase;
	private bool _chkPartL4N;
	private bool _chkDebug;
	private bool _chkVolian;
	private string _tbDebug;
	private string _databaseLogDebug;
	private string _databaseLogInfo;
	private string _databaseLogWarn;
	private string _databaseLogError;
	private string _databaseLogFatal;
	private bool _doOldParent=false;
	
	public bool AddToClassList(string className)
	{
		if (_classList.Contains(className))
		{
			_duplicateList.Add(className);
			return false;
		}
		else
		{
			_classList.Add(className);
			return true;
		}
	}
	public delegate bool Filter(IColumn column);
	public string Debug(string str)
	{
	if (_chkDebug && str.CompareTo(_tbDebug) >= 0)return "/**** MyGeneration Debug " + str + " ****/";
	return "";
	}
	public string DebugLine(string str)
	{
	if (_chkDebug && str.CompareTo(_tbDebug) >= 0)return "\r\n/**** MyGeneration Debug " + str + " ****/";
	return "";
	}
	public void SaveFile()
	{
		if (_chkCreateFiles)
		{
			output.save( Path.Combine( _exportPath, _className + ".cs" ), false );
			output.clear();
		}
	}
	public GeneratedTemplate( ZeusContext context ) : base( context ) {}

	public override void Render()
	{	
		DateTime tStart = DateTime.Now;
		if (context.Objects.ContainsKey("DnpUtils"))DnpUtils.SaveInputToCache(context);
		try{
			InitializeDictionaries();
			_dbName = input["chooseDatabase"].ToString();
			_PropDescList = new ArrayList();
			_selectedTables = input["chooseTables"] as ArrayList;
			_selectedViews = input["chooseViews"] as ArrayList;
			_exportPath = input["outputPath"].ToString();
			_nameSpace = input["classNamespace"].ToString();
			_prefix = input["memberPrefix"].ToString();
			_dbConnection = input["dbConnection"].ToString();
			_chkGenerateMain=(bool)input["chkGenerateMain"];
			_chkFKList=(bool)input["chkFKList"];
			_chkFKItem=(bool)input["chkFKItem"];
			_chkInfoList=(bool)input["chkInfoList"];
			_chkInfo=(bool)input["chkInfo"];
			_chkCreateFiles=(bool)input["chkCreateFiles"];
			_chkPartBM=(bool)input["chkPartBM"];
			_chkPartDA=(bool)input["chkPartDA"];
			_chkPartVR=(bool)input["chkPartVR"];
			_chkPartEX=(bool)input["chkPartEX"];
			_chkPartAR=(bool)input["chkPartAR"];
			_chkPartDF=(bool)input["chkPartDF"];
			_chkPartFM=(bool)input["chkPartFM"];
			_chkPartEXT=(bool)input["chkPartEXT"];
			_chkPartCM=(bool)input["chkPartCM"];
			_chkPartL4N=(bool)input["chkPartL4N"];
			if (_chkPartL4N)
			{
				_databaseLogDebug = "if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat";
				_databaseLogInfo = "if (_MyLog.IsInfoEnabled) _MyLog.InfoFormat";
				_databaseLogWarn = "if (_MyLog.IsWarnEnabled) _MyLog.WarnFormat";
				_databaseLogError = "if (_MyLog.IsErrorEnabled) _MyLog.Error";
				_databaseLogFatal = "if (_MyLog.IsFatalEnabled) _MyLog.Fatal";
			}
			else
			{
				_databaseLogDebug = "Database.LogInfo";
				_databaseLogInfo = "Database.LogInfo";
				_databaseLogWarn = "Database.LogInfo";
				_databaseLogError = "Database.LogException";
				_databaseLogFatal = "Database.LogException";
			}
			_chkDatabase=(bool)input["chkDatabase"];
			_chkDebug=(bool)input["chkDebug"];
			_chkVolian=(bool)input["chkVolian"];
			_tbDebug=(string)input["tbDebug"];
			_classList=new ArrayList();
			_duplicateList=new ArrayList();
			if (_chkDatabase)GenerateDatabase();
			foreach( string _newTable in _selectedTables )
			{
				_workingTable = MyMeta.Databases[_dbName].Tables[_newTable];
				GenerateClassFiles( _workingTable );
			}
			GeneratePropertyDescriptor();
			GenerateCommonRules();
			if (_duplicateList.Count > 0)
			{
				WriteLine("Duplicate Classes");
				foreach(string s in _duplicateList)
				{
					WriteLine("[{0}]",s);
				}
			}
			DateTime tEnd = DateTime.Now;
			WriteLine(string.Format("Total Generation Time: {0} Seconds",TimeSpan.FromTicks(tEnd.Ticks - tStart.Ticks).TotalSeconds));
			//foreach( string _newView in _selectedViews )
			//{
			//	IView _workingView = MyMeta.Databases[_dbName].Views[_newView];
			//		GenerateClassFiles( _workingView.Columns, _className);
			//}
		}
		catch(Exception ex)
		{
			output.write(ex.Message);
		}
	}
	private void InitializeDictionaries()
	{
		dicRead = new Hashtable();
		dicRead["Guid"]="{fmember} = dr.GetGuid(\"{fname}\");";
		dicRead["string"]="{fmember} = dr.GetString(\"{fname}\");";
		dicRead["SmartDate"]="{fmember} = dr.GetSmartDate(\"{fname}\").Text;";
		dicRead["DateTime"]="{fmember} = dr.GetDateTime(\"{fname}\");";
		dicRead["timestamp"]="dr.GetBytes(\"{fname}\", 0, {fmember}, 0, 8);";
		dicRead["image"]="{fmember} = (byte[])dr.GetValue(\"{fname}\");";
		dicRead["varbinary"]="{fmember} = (byte[])dr.GetValue(\"{fname}\");";
		dicRead["int"]="{fmember} = dr.GetInt32(\"{fname}\");";
		dicRead["Int32"]="{fmember} = dr.GetInt32(\"{fname}\");";
		dicRead["Int16"]="{fmember} = dr.GetInt16(\"{fname}\");";
		dicRead["Int16"]="{fmember} = dr.GetInt16(\"{fname}\");";
		dicRead["Int64"]="{fmember} = dr.GetInt64(\"{fname}\");";
		dicRead["byte"]="{fmember} = dr.GetByte(\"{fname}\");";
		dicRead["char"]="{fmember} = dr.GetChar(\"{fname}\");";
		dicRead["double"]="{fmember} = dr.GetDouble(\"{fname}\");";
		dicRead["float"]="{fmember} = dr.GetFloat(\"{fname}\");";
		dicRead["decimal"]="{fmember} = dr.GetDecimal(\"{fname}\");";
		dicRead["bool"]="{fmember} = dr.GetBoolean(\"{fname}\");";
		dicRead["long"]="{fmember} = dr.GetInt64(\"{fname}\");";
		dicRead["int?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["Int32?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["Int16?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["Int16?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["Int64?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["byte?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["char?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["double?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["float?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["decimal?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["bool?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["long?"]="{fmember} = ({ctype})dr.GetValue(\"{fname}\");";
		dicRead["DateTime?"]="if (!dr.IsDBNull(dr.GetOrdinal(\"{fname}\"))) {fmember} = dr.GetDateTime(\"{fname}\");";
	}
	private void GenerateClassFiles(ITable tbl)
	{
		if (_chkGenerateMain)GenerateMainClass(tbl);
		Hashtable dicAlias = new Hashtable();
		foreach(IForeignKey fk in tbl.ForeignKeys)
		{
			if (tbl == fk.PrimaryTable)
			{
				if (!IsPrimaryKey(fk))
				{
					//string sAlias = GetAlias(dicAlias,fk.ForeignTable);
					string sAlias = GetAlias(fk);
					if (_chkFKList)GenerateFKListClass(fk,sAlias);
					if (_chkFKItem && fk.PrimaryTable != fk.ForeignTable )GenerateFKClass(fk,sAlias);
				}
			}
		}
		if (_chkInfoList && AnyNotOneToOne(tbl))GenerateInfoListClass(tbl); // InfoList if any non 1 to 1 relationships
		if (_chkInfo)GenerateInfoClass(tbl);
	}
//	private void ShowForeignKey(ForeignKey fk)
//	{
//		output.writeln("Primary " + fk.PrimaryTable.Name);
//		foreach(IColumn col in fk.PrimaryColumns)output.writeln("  " + col.Name + " " + col.IsInPrimaryKey.ToString());
//		output.writeln(" Foreign " + fk.ForeignTable.Name);
//		foreach(IColumn col in fk.ForeignColumns)output.writeln("  " + col.Name + " " + col.IsInPrimaryKey.ToString());
//	}
	private void GenerateMainClass( ITable tbl )
	{
		_className = ClassName( tbl );
		_PropDescList.Add(_className);
		if (!AddToClassList(_className))return;
		_tableName = tbl.Alias;
		vlnHeader("\r\nusing System.Collections.Generic;\r\nusing Csla.Validation;");
		string sInterface="";
		if (_chkPartCM)
		{
			//sInterface = ", ICustomTypeDescriptor";
%>
	[TypeConverter(typeof(<%=_className%>Converter))]<%
		}
%>
	public partial class <%=_className%> : BusinessBase<<%=_className%>><%=sInterface%>, IDisposable, IVEHasBrokenRules
	{<%
		Log4Net();
		vlnRefreshInfo();
		vlnCollection(tbl,UniqueIndexes(tbl),false);
		if (_chkPartBM)vlnBusinessMethods(tbl.Columns);
		if (_chkPartVR)vlnValidationRules(tbl.Columns);
		if (_chkPartAR)vlnAuthorizationRules(tbl.Columns);
		if (_chkPartFM)vlnFactoryMethods(tbl.Columns);
		if (_chkPartDA)vlnDataAccessPortal(tbl.Columns);
		if (_chkPartEX)vlnExists(tbl.Columns);
		if (_chkPartDF)vlnDefaults(tbl.Columns);
		vlnFooterCM("");
		if (_chkPartEXT)vlnExtension(tbl.Columns);
		SaveFile();
	}
	private void GenerateFKListClass(IForeignKey fk,string sAlias)
	{
		_className =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable )+sAlias;
		_className = FKClassesName(fk)+sAlias;
		if (!AddToClassList(_className))return;
		if (fk.PrimaryTable == fk.ForeignTable)
			_subclassName =  ClassName( fk.PrimaryTable);
		else
			_subclassName =  ClassName( fk.PrimaryTable) + ClassName( fk.ForeignTable )+sAlias;
		_tableName =  "//CSLATODO: No Table Name";
		vlnHeader("\r\nusing System.Collections.Generic;\r\nusing Csla.Validation;");
		string sInterface = "";
		if (_chkPartCM)
		{
			sInterface = ", ICustomTypeDescriptor";
%>
	[TypeConverter(typeof(<%=_className%>Converter))]<%
		}
%>
	public partial class <%=_className%> : BusinessListBase<<%=_className%>, <%=_subclassName%>><%=sInterface%>, IVEHasBrokenRules , IDisposable
	{<%
		Log4Net();
		if (_chkPartBM)vlnBusinessMethodsFKList(fk,sAlias);
		if (_chkPartVR)vlnValidationRulesFKList(fk,sAlias);
		if (_chkPartFM)vlnFactoryMethodsFKList(fk,sAlias);
		if (_chkPartDA)vlnDataAccessPortalFKList(fk,sAlias);
		vlnFooterCM(ClassesName( fk.ForeignTable ) + sAlias);
		SaveFile();
	}
	private void GenerateFKClass(IForeignKey fk,string sAlias)
	{
		_className =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		_PropDescList.Add(_className);
		if (!AddToClassList(_className))return;
		_tableName =  fk.ForeignTable.Alias;
		vlnHeader("\r\nusing System.Collections.Generic;\r\nusing Csla.Validation;");
		string sInterface="";
		if (_chkPartCM)
		{
			//sInterface = ", ICustomTypeDescriptor";
%>
	[TypeConverter(typeof(<%=_className%>Converter))]<%
		}
%>
	public partial class <%=_className%> : BusinessBase<<%=_className%>><%=sInterface%>, IVEHasBrokenRules, IDisposable
	{<%
		Log4Net();
		if (_chkPartBM)vlnBusinessMethodsFKItem(fk,sAlias);
		if (_chkPartVR)vlnValidationRulesFKItem(fk,sAlias);
		if (_chkPartAR)vlnAuthorizationRulesFKItem(fk,sAlias);
		if (_chkPartFM)vlnFactoryMethodsFKItem(fk,sAlias);
		if (_chkPartDA)vlnDataAccessPortalFKItem(fk,sAlias);
		if (_chkPartDF)vlnDefaults(fk.ForeignTable.Columns);
		vlnFooterCM("");
		if (_chkPartEXT)vlnExtension(fk.ForeignTable.Columns);
		SaveFile();
	}
	private void vlnFooterCM(string displayName)
	{
		if (_chkPartCM)
		{
			if (displayName!="")vlnComponentModelFKList();
%>
	} // Class<%
			if (displayName!="")vlnPropertyDescriptorFKList();
			if (displayName!="")vlnConvertorFKList(displayName);
			else vlnConvertorFKItem();
%>
} // Namespace
<%
		}
		else
		{
%>
	} // Class
} // Namespace
<%
		}
	}
	private void GenerateInfoListClass( ITable tbl )
	{
		_className = ClassName( tbl ) + "InfoList";
		if (!AddToClassList(_className))return;
		_tableName = tbl.Alias;
		_subclassName =  ClassName( tbl ) + "Info";
		vlnHeader("\r\nusing System.Collections.Generic;");
		string sInterface="";
		if (_chkPartCM)
		{
			sInterface = ", ICustomTypeDescriptor";
%>
	[TypeConverter(typeof(<%=_className%>Converter))]<%
		}
%>
	public partial class <%=_className%> : ReadOnlyListBase<<%=_className%>, <%=_subclassName%>><%=sInterface%>, IDisposable
	{<%
		Log4Net();
		if (_chkPartBM)
		{
%>
		#region Business Methods
		internal new IList<<%=_subclassName%>> Items
		{ get { return base.Items; } }
		public void AddEvents()
		{
			foreach (<%=_subclassName%> tmp in this)
			{
				tmp.Changed += new <%=_subclassName%>Event(tmp_Changed);
			}
		}
		void tmp_Changed(object sender)
		{
			for (int i = 0; i < Count; i++)
			{
				if (base[i] == sender)
					this.OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, i));
			}
		}
		private bool _Disposed = false;
		private static int _CountCreated = 0;
		private static int _CountDisposed = 0;
		private static int _CountFinalized = 0;
		private static int IncrementCountCreated
		{ get { return ++_CountCreated; } }
		private int _CountWhenCreated = IncrementCountCreated;
		public static int CountCreated
		{ get { return _CountCreated; } }
		public static int CountNotDisposed
		{ get { return _CountCreated - _CountDisposed; } }
		public static int CountNotFinalized
		{ get { return _CountCreated - _CountFinalized; } }
		~<%=_className%>()
		{
			_CountFinalized++;
		}
		public void Dispose()
		{
			if (_Disposed) return;
			_CountDisposed++;
			_Disposed = true;
			foreach (<%=_subclassName%> tmp in this)
			{
				tmp.Changed -= new <%=_subclassName%>Event(tmp_Changed);
			}
		}
		#endregion<%}
		if (_chkPartFM)vlnFactoryMethodsInfoList(tbl.Columns);
		if (_chkPartDA)vlnDataAccessPortalInfoList(tbl.Columns);
		vlnFooterCM(ClassesName( tbl ) );
		SaveFile();
	}
	private void GenerateInfoClass( ITable tbl )
	{
		_className = ClassName( tbl ) + "Info";
		_PropDescList.Add(_className);
		if (!AddToClassList(_className))return;
		_tableName = tbl.Alias;
		vlnHeader("\r\nusing System.Collections.Generic;","\r\n\tpublic delegate void " + _className + "Event(object sender);");
		string sInterface="";
		if (_chkPartCM)
		{
			//sInterface = ", ICustomTypeDescriptor";
%>
	[TypeConverter(typeof(<%=_className%>Converter))]<%
		}
%>
	public partial class <%=_className%> : ReadOnlyBase<<%=_className%>><%=sInterface%>, IDisposable
	{
		public event <%=_className%>Event Changed;
		private void OnChange()
		{
			if (Changed != null) Changed(this);
		}<%
		Log4Net();
		vlnCollection(tbl,new ArrayList(),true);
		if (_chkPartBM)vlnBusinessMethodsInfo(tbl.Columns);
		if (_chkPartFM)vlnFactoryMethodsInfo(tbl.Columns);
		if (_chkPartDA)vlnDataAccessPortalInfo(tbl.Columns);
		vlnInfoExtension(tbl.Columns);//20070410
		vlnFooterCM("");
		SaveFile();
	}
	private void vlnHeader()
	{
		vlnHeader("");
	}
	private void vlnHeader(string sUsing)
	{
		vlnHeader(sUsing,"");
	}
	private void vlnHeader(string sUsing,bool serialize)
	{
		vlnHeader(sUsing,"",serialize);
	}
	private void vlnHeader(string sUsing,string sDelegate)
	{
		vlnHeader(sUsing,sDelegate,true);
	}
	private void vlnHeader(string sUsing,string sDelegate,bool serialize)
	{
		if (_chkVolian){
%>// ========================================================================
// Copyright 2007 - Volian Enterprises, Inc. All rights reserved.          
// Volian Enterprises - Proprietary Information - DO NOT COPY OR DISTRIBUTE
// ------------------------------------------------------------------------
// $Workfile: $     $Revision: $                                           
// $Author: $   $Date: $                                                   
//                                                                         
// $History: $                                                             
// ========================================================================
<%
		}
%>
using System;
using System.Data;
using System.Data.SqlClient;
using Csla;
using Csla.Data;
using System.Configuration;
using System.IO;<%
		if (_chkPartCM)
		{
%>
using System.ComponentModel;<%
		}
%><%=sUsing%>
namespace <%=_nameSpace%>
{<%=sDelegate%>
	/// <summary>
	///	<%=_className%> Generated by MyGeneration using the CSLA Object Mapping template
	/// </summary><%
		if (serialize)
		{
%>
	[Serializable()]<%
		}
	}
	private bool IsPrimaryKey(IIndex ind)
	{
		IColumns colsi = ind.Columns;
		IColumns colsp = ind.Table.PrimaryKeys;
		if (colsi.Count != colsp.Count)return false;
		for(int i=0;i<colsi.Count;i++)
		{
			if (colsi[i]!=colsp[i])
				return false;
		}
		return true;
	}
	private ArrayList UniqueIndexes(ITable tbl)
	{
		ArrayList retval = new ArrayList();
		foreach(Index ind in tbl.Indexes)
		{
			if (!IsPrimaryKey(ind) && ind.Unique)
			{
				retval.Add(ind);		
			}
		}
		return retval;
	}
	private void vlnCollection(ITable tbl,ArrayList uniqueIndexes,bool bInfo)
	{
		string pKey = FormatColumns("tmp.{prop}.ToString()",tbl.PrimaryKeys," + \"_\" + ","");
		string pKey2 = FormatColumns("{local}.ToString()",tbl.PrimaryKeys," + \"_\" + ","");
		string pKeys = FormatColumns("{local}",tbl.PrimaryKeys,", ","");
		string pKeysType = FormatColumns("{ctype} {local}",tbl.PrimaryKeys,", ","");
%>
		#region Collection
		private static List<<%=_className%>> _CacheList = new List<<%=_className%>>();
		protected static void AddToCache(<%=_className%> <%=LocalName(_className)%>)
		{
			if (!_CacheList.Contains(<%=LocalName(_className)%>)) _CacheList.Add(<%=LocalName(_className)%>); // In AddToCache
		}
		protected static void RemoveFromCache(<%=_className%> <%=LocalName(_className)%>)
		{
			while (_CacheList.Contains(<%=LocalName(_className)%>)) _CacheList.Remove(<%=LocalName(_className)%>); // In RemoveFromCache
		}
		private static Dictionary<string, List<<%=_className%>>> _CacheByPrimaryKey = new Dictionary<string, List<<%=_className%>>>();<%
		//ArrayList uniqueIndexes=UniqueIndexes(tbl);
		foreach(IIndex ind in uniqueIndexes)
		{
			string sBy = FormatColumns("{name}",ind.Columns,"_","");
%>
		private static Dictionary<string, List<<%=_className%>>> _CacheBy<%=sBy%> = new Dictionary<string, List<<%=_className%>>>();<%
		}
%>
		private static void ConvertListToDictionary()
		{
			while (_CacheList.Count > 0) // Move <%=_className%>(s) from temporary _CacheList to _CacheByPrimaryKey
			{
				<%=_className%> tmp = _CacheList[0]; // Get the first <%=_className%>
				string pKey = <%=pKey%>;
				if (!_CacheByPrimaryKey.ContainsKey(pKey))
				{
					_CacheByPrimaryKey[pKey] = new List<<%=_className%>>(); // Add new list for PrimaryKey<%
		foreach(IIndex ind in uniqueIndexes)
		{
			string sBy = FormatColumns("{name}",ind.Columns,"_","");
			string sKey = FormatColumns("tmp.{prop}.ToString()",ind.Columns," + \"_\" + ","");
%>
					_CacheBy<%=sBy%>[<%=sKey%>] = new List<<%=_className%>>(); // Add new list for <%=sBy%><%
		}
%>
				}
				_CacheByPrimaryKey[pKey].Add(tmp); // Add to Primary Key list<%
		foreach(IIndex ind in uniqueIndexes)
		{
			string sBy = FormatColumns("{name}",ind.Columns,"_","");
			string sKey = FormatColumns("tmp.{prop}.ToString()",ind.Columns," + \"_\" + ","");
%>
				_CacheBy<%=sBy%>[<%=sKey%>].Add(tmp); // Unique Index<%
		}
%>
				_CacheList.RemoveAt(0); // Remove the first <%=_className%>
			}
		}<%
		if (bInfo && AnyNotOneToOne(_workingTable)) // AddList function for infolist - Any non 1 to 1 relationships
		{
%>
		internal static void AddList(<%=_className%>List lst)
		{
			foreach (<%=_className%> item in lst) AddToCache(item);
		}<%
		}
%>
		protected static <%=_className%> GetCachedByPrimaryKey(<%=pKeysType%>)
		{
			ConvertListToDictionary();
			string key = <%=pKey2%>;
			if (_CacheByPrimaryKey.ContainsKey(key)) return _CacheByPrimaryKey[key][0];
			return null;
		}<%
		foreach(IIndex ind in uniqueIndexes)
		{
			string sBy = FormatColumns("{name}",ind.Columns,"_","");
			string sKey = FormatColumns("{local}.ToString()",ind.Columns," + \"_\" + ","");
			string sKeysType = FormatColumns("{ctype} {local}",ind.Columns,", ","");
			string sKeys = FormatColumns("{local}",ind.Columns,", ","");
%>
		protected static <%=_className%> GetCachedBy<%=sBy%>(<%=sKeysType%>)
		{
			ConvertListToDictionary();
			string key = <%=sKey%>;
			if (_CacheBy<%=sBy%>.ContainsKey(key)) return _CacheBy<%=sBy%>[key][0];
			return null;
		}<%
		}
%>
		#endregion<%
	}
	private void vlnBusinessMethods(IColumns Columns )
	{
%>
		#region Business Methods
		private string _ErrorMessage = string.Empty;
		public string ErrorMessage
		{
			get { return _ErrorMessage; }
		}<%
		vlnProperties(Columns);
		//vlnRelatedItems(Columns);
		vlnToString(Columns);
		vlnGetIDValue(_workingTable.PrimaryKeys);
%>
		#endregion<%
	}
	private string ParentCheck(IColumn col)  // 20070221 - Logic to check for parent value
	{
		IForeignKey pfk = FKParentFK(col.Table);
		if (pfk == null)return null;
		IColumn relCol = RelatedColumnF(col,pfk);
		if (relCol==null) return null;
		return FormatColumn("\r\n\t\t\t\tif (_" + ParentName(pfk) + " != null) return _" + ParentName(pfk) + ".{prop};",relCol); 
	}
	private void vlnProperties(IColumns Columns)
	{
		// Create all properties
		foreach(IColumn col in Columns)
		{
			bool bReadOnly = col.IsInPrimaryKey || col.IsAutoKey || col.IsComputed;
//			bool bRelatedObject = true;
			vlnIdentity(col);
//			string sParentCheck = ParentCheck(col);
//			if (sParentCheck != null)
//			{
//				bReadOnly=true;
//				bRelatedObject=false;
//			}
			// Need logic to handle parent child
			string sParentCheck="";
			if (IsRelObj(col))
				sParentCheck =FormatColumn("\r\n\t\t\t\tif ({!member} != null) {member} = {!member}.{!column};",col);
			vlnProperty(CSLAType( col ),MemberName(col)
				,PropertyName(col),InitializeValue( col ),GetDescription(col),bReadOnly || IsRelObj(col),col.IsInPrimaryKey,false,null,sParentCheck,null,null);
//			if (bRelatedObject)
			vlnRelObjProperty(col,bReadOnly,false);
		}
		// Add Foreign Key Properties - This should be controllable
//		foreach(IColumn field in Columns)
//		{
//			if (field.IsInForeignKey && field.IsInPrimaryKey)
//			{
				//A column that's in a fk and in the pk represents a fk relationship
				//from another table, a one-to-many relationship.  (This might be 
				//a bad assumption for a table with a composite primary key.)
				//... and then we have to add collections for the foreign tables.
				string sExtDirty="";
				string sExtValid="";
//				foreach( IForeignKey fk in field.ForeignKeys )
				Hashtable dicAlias = new Hashtable();
				foreach(IForeignKey fk in _workingTable.ForeignKeys)
				{
					if (fk.PrimaryTable == _workingTable){
						//string sAlias = GetAlias(dicAlias,fk.ForeignTable);
						string sAlias = GetAlias(fk);
//							string sList = _className + ClassesName( fk.ForeignTable );
							string sList = FKClassName(fk );
							string sLists = FKClassesName(fk );
							vlnProperty("int",MemberName(sList) + sAlias + "Count" ,sList + sAlias + "Count", " = 0;",
								"Count of " + sLists + " for this " + ClassName(_workingTable)  + Debug("20070501.3"),true,false,false,null,null,null,null);
						if (!IsPrimaryKey(fk)){
							//vlnProperty(sLists+sAlias,MemberName(sLists)+sAlias,sLists + sAlias,
							//" = " + sLists+sAlias + ".New();","Related Field" + Debug("20070501.2"),true,false,true,fk,null,null,null);
							vlnProperty(sLists+sAlias,MemberName(sLists)+sAlias,sLists + sAlias,
							" = null;","Related Field" + Debug("20070501.2"),true,false,true,fk,null,null,null);
							//sExtDirty += " || " + MemberName(sLists+sAlias) + ".IsDirty";
							//sExtValid += " && " + MemberName(sLists+sAlias) + ".IsValid";
							sExtDirty += string.Format(" || ({0} == null ? false : {0}.IsDirtyList(list))",MemberName(sLists+sAlias));
							// Added List 20100924
							sExtValid += string.Format(" && ({0} == null ? true : {0}.IsValidList(list))",MemberName(sLists+sAlias));
						} else {
							string sItem = ClassName(fk.ForeignTable);
							//vlnProperty(sItem+sAlias, MemberName("My" + sItem)+sAlias,"My" + sItem + sAlias,
							//" = My" + sItem+sAlias + ".New();","Related Field",true,false,true,fk,null,null);
							string sCheck = string.Format("\r\n\t\t\t\tif ({0} == null) {0} = {1}.New({2});",
								MemberName("My" + sItem)+sAlias, sItem, OneToOne(fk) ? "this" : FormatColumns("{member}",fk.PrimaryColumns,", ",""));
							vlnProperty(sItem+sAlias, MemberName("My" + sItem)+sAlias,"My" + sItem + sAlias,
							" = null;","Related Field" + Debug("20070501.1"),true,false,true,fk,sCheck,null,null);
							bool bReq = !fk.ForeignColumns[0].IsNullable;
							sExtDirty += string.Format(" || ({0} == null ? false : {0}.IsDirtyList(list))",MemberName("My" + sItem+sAlias));
							sExtValid += string.Format(" && ({0} == null ? true : {0}.IsValidList(list))",MemberName("My" + sItem+sAlias));
						}
					}
					else // 
					{
						if (IsPrimaryKey1(fk) && !IsPrimaryKey(fk)){
							bool bReq = !fk.ForeignColumns[0].IsNullable;
							string sClass = ClassName(fk.PrimaryTable.Name) + GetNewAlias(fk,fk);
							//sExtDirty += string.Format(" || ({0} == null? " + bReq.ToString().ToLower() + " : {0}.IsDirty)",MemberName("My" + sClass));
							//sExtValid += string.Format(" && ({0} == null? " + (!bReq).ToString().ToLower() + " : {0}.IsValid)",MemberName("My" + sClass));
							sExtDirty += string.Format(" || ({0} == null ? false : {0}.IsDirtyList(list))",MemberName("My" + sClass));
							sExtValid += string.Format(" && ({0} == null ? true : {0}.IsValidList(list))",MemberName("My" + sClass));
						}
					}
				}
				//if (sExtDirty!="")
				vlnDirty(sExtDirty);
				//if (sExtValid!="")vlnOverride("Valid",sExtValid);
				vlnValid(sExtValid);
//			}
//		}
	}
	private void vlnDirty(string sExtension)
	{
		if(sExtension == "")
		{
	%>
		public override bool IsDirty
		{
			get { return base.IsDirty; }
		}
		public bool IsDirtyList(List<object> list)
		{
			return base.IsDirty;
		}<%
		}
		else
		{
	%>
		public override bool IsDirty
		{
			get 
			{
				if ( base.IsDirty ) 
					return true;
				return IsDirtyList(new List<object>());
			}
		}
		public bool IsDirtyList(List<object> list)
		{
			if (base.IsDirty || list.Contains(this))
				return base.IsDirty;
			list.Add(this);
			return base.IsDirty<%=sExtension%>;
		}<%
		}
	}
	private void vlnValid(string sExtension)
	{
		if(sExtension == "")
		{
	%>
		public override bool IsValid
		{
			get { return (IsNew && !IsDirty) ? true : base.IsValid; }
		}
		public bool IsValidList(List<object> list)
		{
			return (IsNew && !IsDirty) ? true : base.IsValid;
		}<%
		}
		else
		{
	%>
		public override bool IsValid
		{
			get { return IsValidList(new List<object>()); }
		}
		public bool IsValidList(List<object> list)
		{
			if(list.Contains(this))
				return (IsNew && !IsDirty) ? true : base.IsValid;
			list.Add(this);
			return ((IsNew && !IsDirty) ? true : base.IsValid)<%=sExtension%>;
		}<%
		}
	}
	private void vlnIdentity(IColumn column)
	{
		if (column.IsAutoKey)
		{
		string sProp=FormatColumn("{prop}",column);
%>
		private static int _next<%=sProp%> = -1;
		public static int Next<%=sProp%>
		{
			get { return _next<%=sProp%>--; }
		}<%
		}
	}
	private void vlnLazyLoad(string sType,string sMemberName,string sPropertyName,IForeignKey fk)
	{
		if (fk==null)return;
		//if (OneToOne(fk.ForeignTable))return;
		if (OneToOne(fk))return;
		string sBy = FormatColumns("{name}",fk.ForeignColumns,"_","");
		string sKeys=FormatColumns("{prop}",fk.PrimaryColumns,", ","");
		string sRelClass=FKClassesName(fk) + GetAlias(fk);
		string sClassName=MemberName(FKClassName(fk) + GetAlias(fk));//20070207
%>
				if (<%=sClassName%>Count < 0 || (<%=sClassName%>Count > 0 && <%=sMemberName%> == null))
					<%=sMemberName%> = <%=sType%>.GetBy<%=sBy%>(<%=sKeys%>);
				if (<%=sClassName%>Count < 0 )
					<%=sClassName%>Count = <%=sMemberName%> == null ? 0 : <%=sMemberName%>.Count;
				if (<%=sMemberName%> == null)
					<%=sMemberName%> = <%=sRelClass%>.New();<%
	}
	private void vlnResetLazyLoad(string sType,string sMemberName,string sPropertyName,IForeignKey fk)
	{
		if (fk==null)return;
		//if (OneToOne(fk.ForeignTable))return;
		if (OneToOne(fk))return;
		string sBy = FormatColumns("{name}",fk.ForeignColumns,"_","");
		string sKeys=FormatColumns("{prop}",fk.PrimaryColumns,", ","");
		string sRelClass=FKClassesName(fk) + GetAlias(fk);
		string sClassName=MemberName(FKClassName(fk) + GetAlias(fk));//20070207
%>
		public void Reset<%=sMemberName%>()
		{
			<%=sClassName%>Count = -1;
		}<%
	}
	private void vlnProperty(string sType,string sMemberName,string sPropertyName,string sDefault,string sDescription,bool bReadOnly,bool bPrimaryKey,bool bCompModel,IForeignKey fk,string sParentCheck,string sParentCheck2, string sParentCheck3)
	{
		string suffix = (sPropertyName==_className?"Fld":"");
%>
		private <%=ReturnType(sType)%> <%=sMemberName%><%=suffix%><%=sDefault%><%
		if (!sDefault.EndsWith("timestamp")){
		if (sDescription != ""){
%>
		/// <summary>
		/// <%=sDescription%>
		/// </summary><%
		}
		if (_chkPartCM && bCompModel)
		{
%>
		[TypeConverter(typeof(<%=sType%>Converter))]<%
		}
		if (bPrimaryKey){
%>
		[System.ComponentModel.DataObjectField(true, true)]<%
		}
%>
		public <%=ReturnType(sType)%> <%=sPropertyName%><%=suffix%>
		{
			[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
			get
			{
				CanReadProperty("<%=sPropertyName%><%=suffix%>", true);<%vlnLazyLoad(sType,sMemberName,sPropertyName,fk);%><%=sParentCheck%>
				return <%=sMemberName%><%=suffix%><%=ReturnMember(sType)%>;
			}<%
			if (!bReadOnly){  
			switch(sType)
				{
					case "SmartDate":
%>
			[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
			set
			{
				CanWriteProperty("<%=sPropertyName%><%=suffix%>", true);
				if (value == null) value = string.Empty;
				<%=sMemberName%><%=suffix%> = value;
				try
				{
					SmartDate tmp = new SmartDate(value);
					if (<%=sMemberName%><%=suffix%> != tmp.ToString())
					{
						<%=sMemberName%><%=suffix%> = tmp.ToString();
						// CSLATODO: Any Cross Property Validation
					}
				}
				catch
				{
				}
				PropertyHasChanged();
			}<%
						break;
					default:
%>
			[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
			set
			{
				CanWriteProperty("<%=sPropertyName%><%=suffix%>", true);<%
			if (sType=="string"){
%>
				if (value == null) value = string.Empty;<%
			}
			if(sParentCheck2 ==null) // 20080722RHM
			{
%>
				if (<%=sMemberName%><%=suffix%> != value)<%
			}
			else// 20080722RHM
			{
%>
				if (<%=sParentCheck3%>)<%
			}
%>
				{
					<%=sMemberName%><%=suffix%><%=ReturnMember(sType)%> = value;<%=sParentCheck2%>
					PropertyHasChanged();
				}
			}<%
						break;
				}
			}
%>
		}<%vlnResetLazyLoad(sType,sMemberName,sPropertyName,fk);%><%
		}	

	}
	private void vlnToString(IColumns Columns)
	{
%>
		// CSLATODO: Replace base <%=_className%>.ToString function as necessary
		/// <summary>
		/// Overrides Base ToString
		/// </summary>
		/// <returns>A string representation of current <%=_className%></returns>
		//public override string ToString()
		//{
		//  return base.ToString();
		//}<%
	}
	private void vlnGetIDValue(IColumns Columns)
	{
		string keyID="";
		string sep="(";
		if (Columns.Count==1){
			keyID=MemberName(Columns[0]);
		}
		else
		{
			foreach(IColumn field in Columns)
			{
				keyID+=sep+MemberName(field)+ ".ToString()";
				sep=" + \".\" + ";
			}
			keyID+=").GetHashCode()";
		}
%>
		// CSLATODO: Check <%=_className%>.GetIdValue to assure that the ID returned is unique
		/// <summary>
		/// Overrides Base GetIdValue - Used internally by CSLA to determine equality
		/// </summary>
		/// <returns>A Unique ID for the current <%=_className%></returns>
		protected override object GetIdValue()
		{
			return My<%=_className%>Unique; // Absolutely Unique ID
		}<%
	}
	private string extName
	{
		get {return _className + "Extension";}
	}
	private string extMName
	{
		get {return MemberName(_className + "Extension");}
	}
	private void vlnValidationRules(IColumns Columns )
	{
%>
		#region ValidationRules
		[NonSerialized]
		private bool _CheckingBrokenRules = false;
		public IVEHasBrokenRules HasBrokenRules
		{<%=Debug("20070509.vlnValidationRules")%>
			get
			{
				if (_CheckingBrokenRules) return null;
				if ((IsDirty || !IsNew) && BrokenRulesCollection.Count > 0) return this;
				try
				{
					_CheckingBrokenRules = true;
					IVEHasBrokenRules hasBrokenRules = null;<%
				vlnBrokenRuleObjects(Columns);
%>
					return hasBrokenRules;
				}
				finally
				{
					_CheckingBrokenRules = false;
				}
			}
		}
		public BrokenRulesCollection BrokenRules
		{
			get
			{
				IVEHasBrokenRules hasBrokenRules = HasBrokenRules;
				if (this.Equals(hasBrokenRules)) return BrokenRulesCollection;
				return (hasBrokenRules != null ? hasBrokenRules.BrokenRules : null);
			}
		}
		protected override void AddBusinessRules()
		{<%
		foreach(IColumn field in Columns)
		{
			if (field.LanguageType=="string")
			{
				vlnAddRequired(field);
				if (field.CharacterMaxLength < 2147483647)
				vlnAddMaxLength(PropertyName(field),field.CharacterMaxLength);
			}
			if (CSLAType( field )=="SmartDate")
			{
				vlnAddRequired(field);
				string sName = PropertyName(field);
%>
			ValidationRules.AddRule<<%=_className%>>(<%=sName%>Valid, "<%=sName%>");<%
			}
				string sObjectRequired = RequiredRelatedColumn(field);
				if (sObjectRequired != null)
				{
%>
			ValidationRules.AddRule<<%=_className%>>(<%=sObjectRequired%>Required, "<%=sObjectRequired%>");<%
				}
		}
%>
			//ValidationRules.AddDependantProperty("x", "y");
			<%=extMName%>.AddValidationRules(ValidationRules);
			// CSLATODO:  Add other validation rules
		}
		protected override void AddInstanceBusinessRules()
		{
			<%=extMName%>.AddInstanceValidationRules(ValidationRules);
			// CSLATODO:  Add other validation rules
		}<%
		foreach(IColumn field in Columns)
		{
			if (CSLAType( field )=="SmartDate")
			{
				string sName = PropertyName(field);
				string sMember = MemberName(field);
%>
		private static bool <%=sName%>Valid(<%=_className%> target, Csla.Validation.RuleArgs e)
		{
			try
			{
				DateTime tmp = SmartDate.StringToDate(target.<%=sMember%>);
			}
			catch
			{
				e.Description = "Invalid Date";
				return false;
			}
			return true;
		}<%
			}
		}
		foreach(IColumn col in Columns)
		{
			string sColumn = RequiredRelatedColumn(col);
			if (sColumn != null){ // Let the Validation Rules handle required fields
				string sMemberRaw = MemberName(col);
				string sMemberReq = MemberName(sColumn);
%>
		private static bool <%=sColumn%>Required(<%=_className%> target, Csla.Validation.RuleArgs e)
		{
			if (target.<%=sMemberRaw%> == 0 && target.<%=sMemberReq%> == null) // Required field missing
			{
				e.Description = "Required";
				return false;
			}
			return true;
		}<%
				
			}
		}
%>
		// Sample data comparison validation rule
		//private bool StartDateGTEndDate(object target, Csla.Validation.RuleArgs e)
		//{
		//	if (_started > _ended)
		//	{
		//		e.Description = "Start date can't be after end date";
		//		return false;
		//	}
		//	else
		//		return true;
		//}
		#endregion<%
	}
	private void vlnAddRequired(IColumn column)
	{
		string sName = PropertyName(column);
		if (!column.IsNullable)
		{
%>
			ValidationRules.AddRule(
				Csla.Validation.CommonRules.StringRequired, "<%=sName%>");<%	
		}
	}
	private void vlnAddMaxLength(string sName,int maxlen)
	{
%>
			ValidationRules.AddRule(
				Csla.Validation.CommonRules.StringMaxLength,
				new Csla.Validation.CommonRules.MaxLengthRuleArgs("<%=sName%>", <%=maxlen.ToString()%>));<%	}
	private void vlnAuthorizationRules(IColumns Columns )
	{
%>
		#region Authorization Rules
		protected override void AddAuthorizationRules()
		{
			//CSLATODO: Who can read/write which fields<%
		foreach(IColumn field in Columns)
		{
			if (field.DataTypeName != "timestamp"){
%>
			//AuthorizationRules.AllowRead(<%=PropertyName(field)%>, "<Role(s)>");<%			
			}
		}
		foreach(IColumn field in Columns)
		{
			if (!(field.IsInPrimaryKey || field.IsAutoKey || field.IsComputed))
			{
%>
			//AuthorizationRules.AllowWrite(<%=PropertyName(field)%>, "<Role(s)>");<%			
			}
		}
%>
			<%=extMName%>.AddAuthorizationRules(AuthorizationRules);
		}
		protected override void AddInstanceAuthorizationRules()
		{
			//CSLATODO: Who can read/write which fields
			<%=extMName%>.AddInstanceAuthorizationRules(AuthorizationRules);
		}
		public static bool CanAddObject()
		{
			// CSLATODO: Can Add Authorization
			//return Csla.ApplicationContext.User.IsInRole("ProjectManager");
			return true;
		}
		public static bool CanGetObject()
		{
			// CSLATODO: CanGet Authorization
			return true;
		}
		public static bool CanDeleteObject()
		{
			// CSLATODO: CanDelete Authorization
			//bool result = false;
			//if (Csla.ApplicationContext.User.IsInRole("ProjectManager"))result = true;
			//if (Csla.ApplicationContext.User.IsInRole("Administrator"))result = true;
			//return result;
			return true;
		}<%
		// Need logic to Add CanDelete if the items contains any related records
		// Get a list of related objects
		string sRelatedCounts = "";
		string sRelatedCounts1 = "";
		// Loop through Foreign Keys associated with the Primary Key
		foreach(IForeignKey fk in _workingTable.ForeignKeys)
		{
			if (fk.PrimaryTable == _workingTable)
			{
				bool isPrimary = true;
				foreach(IColumn c in fk.PrimaryColumns)
				{
					isPrimary &= c.IsInPrimaryKey;
				}
				if (isPrimary)
				{
					if (fk.PrimaryTable == fk.ForeignTable)
					{
						sRelatedCounts1 += "\r\n\t\t\t\tusedByCount += " + MemberName(FKClassName1(fk)) + "Count;";
					}
					else
					{
						sRelatedCounts += "\r\n\t\t\t\tusedByCount += " + MemberName(FKClassName1(fk)) + "Count;";
					}
				}
			}
		}
		sRelatedCounts += sRelatedCounts1;
		if (sRelatedCounts != "")
		{
%>
		/// <summary>
		/// determines if related records (Foreign Keys) will keep this Item from being deleted
		/// </summary>
		public bool CanDelete
		{
			get
			{
				// Check to make sure that there are not any related records
				int usedByCount = 0;<%=sRelatedCounts%>
				return (usedByCount == 0);
			}
		}<%
		}
%>
		public static bool CanEditObject()
		{
			// CSLATODO: CanEdit Authorization
			//return Csla.ApplicationContext.User.IsInRole("ProjectManager");
			return true;
		}
		#endregion<%
	}
	private bool MatchingColumns(IList cols1,IList cols2)
	{
		if (cols1.Count != cols2.Count)return false;
		ArrayList cols=new ArrayList();
		foreach(IColumn col in cols1)cols.Add(col.Name);
		foreach(IColumn col in cols2)cols.Remove(col.Name);
		return cols.Count==0;
	}
	private void vlnFactoryMethods(IColumns Columns )
	{
		string pKeys=FormatColumns("{prop}.ToString()",_workingTable.PrimaryKeys," + \"_\" + ");
		string sKeys=FormatColumns("{local}",_workingTable.PrimaryKeys,", ");
		string sKeysTypes=FormatColumns("{ctype} {local}",_workingTable.PrimaryKeys,", ");;
		ArrayList reqList = ReqList(Columns);
		ArrayList makeList = MakeList(Columns);
		ArrayList makeList2 = MakeList2(Columns);
		ArrayList makeList3 = MakeList3(Columns);
		ArrayList makeList4 = MakeList4(Columns);
		Hashtable dicCheck = new Hashtable();
		IForeignKey fkParent = FKParentFK(_workingTable);
		string sParent = ParentName(fkParent);
		dicCheck["DateTime"]=
			"if ({local} >= new DateTime(1753, 1, 1) && {local} <= new DateTime(9999, 12, 31)) tmp.{prop} = {local};";
		dicCheck["DateTime?"]=
			"if ({local} != null && ((DateTime){local}) >= new DateTime(1753, 1, 1) && ((DateTime){local}) <= new DateTime(9999, 12, 31)) tmp.{prop} = {local};";
		dicCheck["string"]=
			"if ({local} != null && {local} != string.Empty) tmp.{prop} = {local};";
%>
		#region Factory Methods
		public int CurrentEditLevel
		{ get { return EditLevel; } }
		private static int _<%=_className%>Unique = 0;
		protected static int <%=_className%>Unique
		{ get { return ++_<%=_className%>Unique; } }
		private int _My<%=_className%>Unique = <%=_className%>Unique;
		public int My<%=_className%>Unique // Absolutely Unique ID - Editable
		{ get { return _My<%=_className%>Unique; } }
		protected <%=_className%>()
		{/* require use of factory methods */
			AddToCache(this);
		}
		private bool _Disposed = false;
		private static int _CountCreated = 0;
		private static int _CountDisposed = 0;
		private static int _CountFinalized = 0;
		private static int IncrementCountCreated
		{ get { return ++_CountCreated; } }
		private int _CountWhenCreated = IncrementCountCreated;
		public static int CountCreated
		{ get { return _CountCreated; } }
		public static int CountNotDisposed
		{ get { return _CountCreated - _CountDisposed; } }
		public static int CountNotFinalized
		{ get { return _CountCreated - _CountFinalized; } }
		~<%=_className%>()
		{
			_CountFinalized++;
		}
		public void Dispose()
		{
			if (_Disposed) return;
			_CountDisposed++;
			_Disposed = true;
			RemoveFromDictionaries();
		}
		private void RemoveFromDictionaries()
		{
			RemoveFromCache(this);
			if (_CacheByPrimaryKey.ContainsKey(<%=pKeys%>))
			{
				List<<%=_className%>> list<%=_className%> = _CacheByPrimaryKey[<%=pKeys%>]; // Get the list of items
				while (list<%=_className%>.Contains(this)) list<%=_className%>.Remove(this); // Remove the item from the list
				if (list<%=_className%>.Count == 0) //If there are no items left in the list
					_CacheByPrimaryKey.Remove(<%=pKeys%>); // remove the list
			}<%
				
		ArrayList uniqueIndexes=UniqueIndexes(_workingTable);
		IIndex makeIndex=null;
		if(uniqueIndexes.Count > 0)
		{
%>
			string myKey;<%
		}
		foreach(IIndex ind in uniqueIndexes)
		{
			string sBy = FormatColumns("{name}",ind.Columns,"_","");
			string sKey = FormatColumns("{prop}.ToString()",ind.Columns," + \"_\" + ","");
			if (MatchingColumns(ind.Columns,makeList))makeIndex=ind;
%>
			myKey = null;
			foreach (string key in _CacheBy<%=sBy%>.Keys)
				if (_CacheBy<%=sBy%>[key].Contains(this))
					myKey = key;
			if (myKey != null)
			{
				List<<%=_className%>> list<%=_className%> = _CacheBy<%=sBy%>[myKey]; // Get the list of items
				list<%=_className%>.Remove(this); // Remove the item from the list
				if (list<%=_className%>.Count == 0) //If there are no items left in the list
					_CacheBy<%=sBy%>.Remove(myKey); // remove the list
			}<%
		}
		string sMakeListParamTypes = "";
		string sMakeListParams = "";
		string sSetTmp = "";
		string sParentCheck = "";
%>
		}
		public static <%=_className%> New()
		{
			if (!CanAddObject())
				throw new System.Security.SecurityException("User not authorized to add a <%=_className%>");
			try
			{
				return DataPortal.Create<<%=_className%>>();
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=_className%>.New", ex);
			}
		}<%
		// if makelist != reqlist create a new for reqlist
		if (!SameList(makeList,reqList) && reqList.Count > 0)
		{
			BuildLists(reqList,ref sMakeListParamTypes, ref sMakeListParams, ref sSetTmp, ref sParentCheck);
			BuildNew(sMakeListParamTypes,sMakeListParams,sSetTmp,sParentCheck);	
			if(SameList(reqList,makeList4))
				BuildMake(sMakeListParamTypes,sMakeListParams,sSetTmp,sParentCheck + Debug("20070427.4"),makeIndex);
		}
		BuildLists(makeList,ref sMakeListParamTypes, ref sMakeListParams, ref sSetTmp, ref sParentCheck);		
		BuildNew(sMakeListParamTypes,sMakeListParams,sSetTmp,sParentCheck );		
		BuildMake(sMakeListParamTypes,sMakeListParams,sSetTmp,sParentCheck + Debug("20070427.3"),makeIndex);
		if (!SameList(makeList,makeList4) && !SameList(reqList,makeList4) && makeList4.Count > 0)
		{
			BuildLists(makeList4,ref sMakeListParamTypes, ref sMakeListParams, ref sSetTmp, ref sParentCheck);		
			BuildNew(sMakeListParamTypes,sMakeListParams,sSetTmp,sParentCheck);		
			BuildMake(sMakeListParamTypes,sMakeListParams,sSetTmp,sParentCheck + Debug("20070427.4"),makeIndex);
		}
	if (makeList3.Count > 0)
		{
%>
		public static <%=_className%> Make<%=_className%>(<%=FormatColumns("{rtype} {local}",makeList2,", ","")%>)
		{<%=DebugLine("20070427.1")%>
			<%=_className%> tmp = <%=_className%>.New(<%=FormatColumns("{local}",makeList,", ","")%>);
<%=FormatColumns(dicCheck,makeList3,"\r\n","\t\t\t")%>
			return tmp.Save();
		}<%
		}
		string sExtra1= "";
		string sExtra2= "";
		if (FKParent(_workingTable)){
			sExtra1=", " + _className + " " + ParentName(fkParent).ToLower();
			sExtra2=", " + ParentName(fkParent).ToLower();
		}
		if (OneToOne(_workingTable) && !SameList(makeList,_workingTable.PrimaryKeys) && !SameList(reqList,_workingTable.PrimaryKeys) && !SameList(makeList4,_workingTable.PrimaryKeys))
		{
			BuildLists(_workingTable.PrimaryKeys,ref sMakeListParamTypes, ref sMakeListParams, ref sSetTmp, ref sParentCheck);		
			sSetTmp += "\r\n\t\t\ttmp.MarkClean();";
			sSetTmp += "\r\n\t\t\ttmp.MarkAsChild();";
			BuildNew(sMakeListParamTypes,sMakeListParams,sSetTmp,sParentCheck);		
		}
%>
		public static <%=_className%> Get(<%=sKeysTypes%>)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a <%=_className%>");
			try
			{
				<%=_className%> tmp = GetCachedByPrimaryKey(<%=sKeys%>);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<<%=_className%>>(new PKCriteria(<%=sKeys%>));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") 
				{
					tmp.Dispose(); // Clean-up <%=_className%>
					tmp = null;
				}
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=_className%>.Get", ex);
			}
		}<%
		//IForeignKey fkParent = FKParentFK(_workingTable);
		if (fkParent != null && _doOldParent)
		{
			string parKeys = FormatColumns("{member}",fkParent.ForeignColumns,", ");
%>
		public <%=_className%> Get<%=sParent%>()
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a <%=_className%>");
			try
			{
				<%=_className%> tmp = GetCachedByPrimaryKey(<%=parKeys%>);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<<%=_className%>>(new <%=sParent%>Criteria(<%=parKeys%>));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found")
				{
					tmp.Dispose(); // Clean-up <%=_className%>
					tmp = null;
				}
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=_className%>.Get", ex);
			}
		}<%
		}
//  GetByUniqueIndex() 
		foreach(IIndex ind in uniqueIndexes)
		{
			string sBy = FormatColumns("{name}",ind.Columns,"_","");
			string sKeyType = FormatColumns("{ctype} {local}",ind.Columns,", ","");
			string sKey = FormatColumns("{local}",ind.Columns,", ","");
%>
		public static <%=_className%> GetBy<%=sBy%>(<%=sKeyType%>)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a <%=_className%>");
			try
			{
				<%=_className%> tmp = GetCachedBy<%=sBy%>(<%=sKey%>);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<<%=_className%>>(new <%=sBy%>Criteria(<%=sKey%>));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") 
				{
					tmp.Dispose(); // Clean-up <%=_className%>
					tmp = null;
				}
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=_className%>.GetBy<%=sBy%>", ex);
			}
		}<%
		}
%>
		public static <%=_className%> Get(SafeDataReader dr<%=sExtra1%>)
		{
			if (dr.Read()) return new <%=_className%>(dr<%=sExtra2%>);
			return null;
		}
		internal <%=_className%>(SafeDataReader dr)
		{
			ReadData(dr);
		}<%
		if (FKParent(_workingTable)){
%>
		private <%=_className%>(SafeDataReader dr<%=sExtra1%>)
		{
			ReadData(dr);
			MarkAsChild();
		}
		internal <%=_className%>(SafeDataReader dr, int parentID)
		{
			ReadData(dr);
			MarkAsChild();
		}<%
		}
%>
		public static void Delete(<%=sKeysTypes%>)
		{
			if (!CanDeleteObject())
				throw new System.Security.SecurityException("User not authorized to remove a <%=_className%>");
			try
			{
				DataPortal.Delete(new PKCriteria(<%=sKeys%>));
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=_className%>.Delete", ex);
			}
		}
		public override <%=_className%> Save()
		{
			if (IsDeleted && !CanDeleteObject())
				throw new System.Security.SecurityException("User not authorized to remove a <%=_className%>");
			else if (IsNew && !CanAddObject())
				throw new System.Security.SecurityException("User not authorized to add a <%=_className%>");
			else if (!CanEditObject())
				throw new System.Security.SecurityException("User not authorized to update a <%=_className%>");
			try
			{
				BuildRefreshList();
				<%=_className%> <%=LocalName(_className)%> = base.Save();
				RemoveFromDictionaries(); // if save is successful remove the previous Folder from the cache
				AddToCache(<%=LocalName(_className)%>);//Refresh the item in AllList
				ProcessRefreshList();
				return <%=LocalName(_className)%>;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on CSLA Save", ex);
			}
		}
		#endregion<%
	}
	private void BuildNew(string sMakeListParamTypes, string sMakeListParams, string sSetTmp, string sParentCheck)
	{
	%>
		public static <%=_className%> New(<%=sMakeListParamTypes%>)
		{
			<%=_className%> tmp = <%=_className%>.New();
<%=sSetTmp%>
			return tmp;
		}<%
	}
	private void BuildMake(string sMakeListParamTypes, string sMakeListParams, string sSetTmp, string sParentCheck,IIndex makeIndex)
	{
	%>
		public static <%=_className%> Make<%=_className%>(<%=sMakeListParamTypes%>)
		{<%=DebugLine("20070427.2")%><%
		if (makeIndex != null)
		{
%>
			<%=_className%> tmp = null;
			<%=sParentCheck%>tmp = GetBy<%=FormatColumns("{prop}",makeIndex.Columns,"_","")%>(<%=FormatColumns("{!localcolumn}",makeIndex.Columns,", ","")%>);
			if (tmp != null) return tmp;// It does exist, return it.
			tmp = <%=_className%>.New(<%=sMakeListParams%>);<%
		}
		else
		{
%>
			<%=_className%> tmp = <%=_className%>.New(<%=sMakeListParams%>);<%
		}
%>
			if (tmp.IsSavable)
				tmp = tmp.Save();
			else
			{
				Csla.Validation.BrokenRulesCollection brc = tmp.ValidationRules.GetBrokenRules();
				tmp._ErrorMessage = "Failed Validation:";
				foreach (Csla.Validation.BrokenRule br in brc)
				{
					tmp._ErrorMessage += "\r\n\tFailure: " + br.RuleName;
				}
			}
			return tmp;
		}<%
	}
	private void vlnRefreshInfo()
	{
		string sClass = ClassName(_workingTable);
		string sClasses = ClassesName(_workingTable);
		string sDeclare = "\t\tprivate List<" + sClass + "> _Refresh" + sClasses + " = new List<" + sClass + ">();";
		string sReset = "\t\t\t_Refresh" + sClasses + " = new List<" + sClass + ">();";
		string sCheck = "\t\t\tif (IsDirty)\r\n\t\t\t\trefresh" + sClasses + ".Add(this);";
		string sRefreshDeclare = "List<" + sClass + "> refresh" + sClasses;
		string sRefreshRelated = "refresh" + sClasses;
		string sRefreshRelated1 = "_Refresh" + sClasses;
		string sProcess = "\t\t\tforeach (" + sClass + " tmp in _Refresh" + sClasses + ")\r\n\t\t\t{\r\n\t\t\t\t" +
			sClass + "Info.Refresh(tmp);";
		foreach(IForeignKey fk in _workingTable.ForeignKeys) // 20070220
		{
			if (_workingTable != fk.PrimaryTable && IsPrimaryKey1(fk) && !IsPrimaryKey(fk))
			{
				sProcess += string.Format("\r\n\t\t\t\tif (tmp._My{1} != null) {0}Info.Refresh(tmp._My{1});",ClassName(fk.PrimaryTable.Name),ClassName(fk.PrimaryTable.Name) + GetNewAlias(fk,fk));
			}
		}
		sProcess += "\r\n\t\t\t}";
		Hashtable dicAlias = new Hashtable();		
		foreach(IForeignKey fk in _workingTable.ForeignKeys) // 20070220
		{
			if (fk.PrimaryTable == fk.ForeignTable) // Parent Child
			{
				sCheck += "\r\n\t\t\tif (_" + ChildName(fk) + sClasses + " != null && _" + ChildName(fk) + sClasses + ".IsDirty)\r\n\t\t\t{\r\n\t\t\t\tforeach (" + sClass +
					" tmp in _" + ChildName(fk) + sClasses + ")\r\n\t\t\t\t{\r\n\t\t\t\t\ttmp.AddToRefreshList(" +
					"{{refreshRelated}});\r\n\t\t\t\t}\r\n\t\t\t}";
			}
			else
			{
				if (!IsPrimaryKey(fk) && _workingTable == fk.PrimaryTable){
					//string sAlias = GetAlias(dicAlias,fk.ForeignTable);
					string sAlias = GetAlias(fk);
					string sItem = ClassName(fk.ForeignTable);
					string sFItem = ClassName(_workingTable) + ClassName(fk.ForeignTable) + sAlias;
					string sFItems = ClassName(_workingTable) + ClassesName(fk.ForeignTable) + sAlias;
					sDeclare += "\r\n\t\tprivate List<" + sFItem + "> _Refresh" + sFItems + " = new List<" + sFItem + ">();";
					sReset += "\r\n\t\t\t_Refresh" + sFItems + " = new List<" + sFItem + ">();";
					sRefreshRelated += ", refresh" + sFItems;
					sRefreshRelated1 += ", _Refresh" + sFItems;
					sRefreshDeclare += ", List<" + sFItem + "> refresh" + sFItems;
					sCheck += "\r\n\t\t\tif (" + MemberName(sFItems) + " != null && " + MemberName(sFItems) + ".IsDirty)\r\n\t\t\t{\r\n\t\t\t\tforeach (" + sFItem +
						" tmp in " + MemberName(sFItems) + ")\r\n\t\t\t\t{\r\n\t\t\t\t\tif (tmp.IsDirty) refresh" + sFItems +
						".Add(tmp);\r\n\t\t\t\t}\r\n\t\t\t}";
					sProcess += "\r\n\t\t\tforeach (" + sFItem + " tmp in _Refresh" + sFItems + ")\r\n\t\t\t{\r\n\t\t\t\t" +
						sItem + "Info.Refresh(" + (ForeignPrimary(fk)?"this, ":"") + "tmp);\r\n\t\t\t}";
				}
			}
		}
		sCheck = sCheck.Replace("{{refreshRelated}}",sRefreshRelated);
%>
		#region Refresh
<%=sDeclare%>
		private void AddToRefreshList(<%=sRefreshDeclare%>)
		{
<%=sCheck%>
		}
		private void ClearRefreshList()
		{
<%=sReset%>
		}
		private void BuildRefreshList()
		{
			ClearRefreshList();
			AddToRefreshList(<%=sRefreshRelated1%>);
		}
		private void ProcessRefreshList()
		{
<%=sProcess%>
			ClearRefreshList();
		}
		#endregion<%
	}
	private void ReadOnlyProperties(IColumns columns)
	{
		output.write(FormatColumns("\t\t\tprivate {ctype} {member};\r\n" +
			"\t\t\tpublic {ctype} {prop}\r\n\t\t\t{ get { return {member}; } }"
			,columns,"\r\n"));
	}
	private void vlnPKCriteria()
	{
// PKCriteria
%>
		[Serializable()]
		protected class PKCriteria
		{
<%
// Loop through Primary Keys
//		string sep="";
		string sValues=FormatColumns("\t\t\t\t{member} = {local};",_workingTable.PrimaryKeys,"\r\n");
		string sKeysTypes=FormatColumns("{ctype} {local}",_workingTable.PrimaryKeys,", ");
//		foreach(IColumn field in _workingTable.PrimaryKeys)
//		{
//			sKeysTypes+=sep + FormatColumn("{ctype} {member}",field);
//			sValues+= FormatColumn("\t\t\t\t{member}={@};\r\n",field);
//			sep=", ";			
//		}
		ReadOnlyProperties(_workingTable.PrimaryKeys);
%>
			public PKCriteria(<%=sKeysTypes%>)
			{
<%=sValues%>
			}
		}<%
	}
	private void vlnReadData(IColumns cols,bool bEditable)
	{
		IList cols2=cols;
		if (!bEditable)cols2=NotTimestamp(cols);
%>
		private void ReadData(SafeDataReader dr)
		{
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.ReadData", GetHashCode());
			try
			{
<%=FormatColumns(dicRead,cols2,"\r\n","\t\t\t\t")%><%
			//Hashtable dicAlias = new Hashtable();
			foreach(IForeignKey FK in _workingTable.ForeignKeys)
			{
				//if (FK.PrimaryTable == _workingTable && !IsPrimaryKey(FK))
				if (FK.PrimaryTable == _workingTable) // 20071023
				{
					string sAlias = GetAlias(FK);
					string sClass = FKClassName(FK);
					string sField = FKFieldName(FK);
%>
				<%=MemberName(sClass)+ sAlias%>Count = dr.GetInt32("<%=sField + sAlias%>Count");<%			
				}
			}
			if (bEditable){
%>
				MarkOld();<%
			}
%>
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.ReadData", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("<%=_className%>.ReadData", ex);
			}
		}<%
	}
	private void vlnDataAccessPortal(IColumns Columns )
	{
%>
		#region Data Access Portal<%
		vlnPKCriteria();
// Parent Criteria 
		IForeignKey fkParent = FKParentFK(_workingTable);
		string sParent = ParentName(fkParent);
		if (fkParent != null && _doOldParent)
		{
			string parKeys = FormatColumns("{member}",fkParent.ForeignColumns,", ");
			string parValues=FormatColumns("\t\t\t\t{member} = {local};",fkParent.ForeignColumns,"\r\n");
			string parKeysTypes=FormatColumns("{ctype} {local}",fkParent.ForeignColumns,", ");
%>
		[Serializable()]
		private class <%=sParent%>Criteria
		{
<%ReadOnlyProperties(fkParent.ForeignColumns);%>
			public <%=sParent%>Criteria(<%=parKeysTypes%>)
			{
<%=parValues%>
			}
		}<%
		}
// Unique Criteria 
		ArrayList uniqueIndexes=UniqueIndexes(_workingTable);
		foreach(IIndex ind in uniqueIndexes)
		{
			string sBy = FormatColumns("{name}",ind.Columns,"_","");
			string indKeyTypes = FormatColumns("{ctype} {local}",ind.Columns,", ","");
			string indValues=FormatColumns("\t\t\t\t{member} = {local};",ind.Columns,"\r\n");
%>
		[Serializable()]
		private class <%=sBy%>Criteria
		{
<%ReadOnlyProperties(ind.Columns);%>
			public <%=sBy%>Criteria(<%=indKeyTypes%>)
			{
<%=indValues%>
			}
		}<%
		}
// DataPortal_Create
%>
		// CSLATODO: If Create needs to access DB - It should not be marked RunLocal
		[RunLocal()]
		private new void DataPortal_Create()
		{
<%=FormatColumns("{member} = new Guid();",Guid(Columns),"\r\n","\t\t\t")%><%=FormatColumns("{member} = Next{prop};",AutoKey(Columns),"\r\n","\t\t\t")%>
			// Database Defaults
<%=FormatColumns("{member} = " + extMName + ".Default{prop};",HasDefaults(Columns),"\r\n","\t\t\t")%>
			// CSLATODO: Add any defaults that are necessary
			ValidationRules.CheckRules();
		}<%
		vlnReadData(Columns,true);
		vlnDataPortalFetch("PK",_workingTable.PrimaryKeys,_className,true);
//		IForeignKey fkParent = FKParentFK(_workingTable);
		if (fkParent != null && _doOldParent)
		{
//		string sParent = ParentName(fkParent);
			vlnDataPortalFetch(sParent,fkParent.ForeignColumns,sParent + _className,false);
		}
		foreach(IIndex ind in uniqueIndexes)
		{
			string sBy = FormatColumns("{name}",ind.Columns,"_","");
			vlnDataPortalFetch(sBy,ind.Columns,_className + "By" + sBy,false);
		}
		string sUpdateMyList="";
		foreach(IForeignKey fk in _workingTable.ForeignKeys) // 20070220
		{
			if (_workingTable != fk.PrimaryTable && IsPrimaryKey1(fk) && !IsPrimaryKey(fk))
			{
				sUpdateMyList += string.Format("\r\n\t\t\t\tif (_My{0} != null) _My{0}.Update();",ClassName(fk.PrimaryTable.Name) + GetNewAlias(fk,fk));
			}
		}
// DataPortal_Insert
%>
		[Transactional(TransactionalTypes.TransactionScope)]
		protected override void DataPortal_Insert()
		{
			try
			{
				using (SqlConnection cn = Database.<%=_dbConnection%>_SqlConnection)
				{
					ApplicationContext.LocalContext["cn"] = cn;
					SQLInsert();
					// removing of item only needed for local data portal
					if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
						ApplicationContext.LocalContext.Remove("cn");
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.DataPortal_Insert", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("<%=_className%>.DataPortal_Insert", ex);
			}
			finally
			{
				<%=_databaseLogDebug%>("[{0}] <%=_className%>.DataPortal_Insert", GetHashCode());
			}
		}
		[Transactional(TransactionalTypes.TransactionScope)]
		internal void SQLInsert()
		{
			if (!this.IsDirty) return;
			try
			{<%=sUpdateMyList%>
				SqlConnection cn = (SqlConnection)ApplicationContext.LocalContext["cn"];
				using (SqlCommand cm = cn.CreateCommand())
				{
					cm.CommandType = CommandType.StoredProcedure;
					cm.CommandText = "add<%=_className%>";
					// Input All Fields - Except Calculated Columns<%
		foreach(IColumn column in Columns)
		{
			if ((!column.IsAutoKey) && (!column.IsComputed))
			{
				output.write(FormatColumn("\r\n\t\t\t\t\t{ifLogicP}cm.Parameters.AddWithValue(\"{@}\", {?dbprefix}{Parent}{?dbsuffix});",column));// 20070316
			}	
		}
%>
					// Output Calculated Columns<%
		foreach(IColumn column in Columns)
		{
			if ((column.IsAutoKey) || (column.IsComputed))
			{
				output.write(FormatColumn("\r\n\t\t\t\t\tSqlParameter param{member} = new SqlParameter(\"{@new}\", {sqltype});",column));
				output.write(FormatColumn("\r\n\t\t\t\t\tparam{member}.Direction = ParameterDirection.Output;",column));
				output.write(FormatColumn("\r\n\t\t\t\t\tcm.Parameters.Add(param{member});",column));
			}	
		}
%>
					// CSLATODO: Define any additional output parameters
					cm.ExecuteNonQuery();
					// Save all values being returned from the Procedure<%
		foreach(IColumn column in Columns)
		{
			if ((column.IsAutoKey) || (column.IsComputed))
			{
				output.write(FormatColumn("\r\n\t\t\t\t\t{member} = ({ctype})cm.Parameters[\"{@new}\"].Value;",column));
			}	
		}
%>
				}
				MarkOld();
				// update child objects<%
		foreach(IColumn field in Columns)
		{
			if (field.IsInForeignKey && field.IsInPrimaryKey)
			{
				//A column that's in a fk and in the pk represents a fk relationship
				//from another table, a one-to-many relationship.  (This might be 
				//a bad assumption for a table with a composite primary key.)
				//... and then we have to add collections for the foreign tables.
				foreach( IForeignKey fk in field.ForeignKeys )
				{
					if (fk.PrimaryTable == _workingTable){
						string sObjName;
						if (!IsPrimaryKey(fk)){
							sObjName = FKClassesName( fk ) + GetAlias(fk);
%>
				if (<%=MemberName(sObjName)%> != null) <%=MemberName(sObjName)%>.Update(this);<%
						} 
						else 
						{
							sObjName = ClassName( fk.ForeignTable );
%>
				if (<%=MemberName("My" + sObjName)%> != null) <%=MemberName("My" + sObjName)%>.Update(this);<%
						}
					}
				}
			}
		}
%>
				<%=_databaseLogDebug%>("[{0}] <%=_className%>.SQLInsert", GetHashCode());
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.SQLInsert", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("<%=_className%>.SQLInsert", ex);
			}
		}<%
// Add
		string sKeysTypesI="";
		string sKeysI="";
		string sValuesI="";
		string sepi="";
		foreach(IColumn column in Columns)
		{
			if ((!column.IsComputed))
			{
				if (!column.IsAutoKey){
					sValuesI+=FormatColumn("\r\n\t\t\t\t\t{ifLogicL}cm.Parameters.AddWithValue(\"{@}\", {parent}{?dbtype});",column);
				}
				if (IsParentCol(column)){
					sKeysTypesI+=sepi + _className + " my" + ParentName(column.ForeignKeys[0]);
					sKeysI+=sepi + "my" + ParentName(column.ForeignKeys[0]);
				}
				else
				{
					sKeysTypesI+=sepi + FormatColumn("{?ref}{!type} {!local}",column);
					sKeysI+=sepi + FormatColumn("{?ref}{member}",column);
				}
				sepi=", ";
			}	
		}
		string sRetval = (IsTimestamp(Columns).Count > 0 ? "byte[]" : "void");
%>
		[Transactional(TransactionalTypes.TransactionScope)]
		public static <%=sRetval%> Add(SqlConnection cn, <%=sKeysTypesI%>)
		{
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.Add", 0);
			try
			{
				using (SqlCommand cm = cn.CreateCommand())
				{
					cm.CommandType = CommandType.StoredProcedure;
					cm.CommandText = "add<%=_className%>";
					// Input All Fields - Except Calculated Columns<%=sValuesI%>
					// Output Calculated Columns<%
		foreach(IColumn column in Columns)
		{
			if ((column.IsAutoKey) || (column.IsComputed))
			{
				output.write(FormatColumn("\r\n\t\t\t\t\tSqlParameter param{member} = new SqlParameter(\"{@new}\", {sqltype});",column));
				output.write(FormatColumn("\r\n\t\t\t\t\tparam{member}.Direction = ParameterDirection.Output;",column));
				output.write(FormatColumn("\r\n\t\t\t\t\tcm.Parameters.Add(param{member});",column));
			}
		}
%>
					// CSLATODO: Define any additional output parameters
					cm.ExecuteNonQuery();
					// Save all values being returned from the Procedure<%
		IColumn tsCol=null;
		foreach(IColumn column in Columns)
		{
			if ((column.IsAutoKey) || (column.IsComputed))
			{
				if (column.DataTypeName=="timestamp")tsCol=column;
				else output.write(FormatColumn("\r\n\t\t\t\t\t{local} = ({ctype})cm.Parameters[\"{@new}\"].Value;",column));
			}	
		}
		if (tsCol != null)
			output.write(FormatColumn("\r\n\t\t\t\t\treturn ({ctype})cm.Parameters[\"{@new}\"].Value;",tsCol));
		else
			output.write("\r\n\t\t\t// No Timestamp value to return");
%>
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.Add", ex);
				throw new DbCslaException("<%=_className%>.Add", ex);
			}
		}<%
// DataPortal_Update
%>
		[Transactional(TransactionalTypes.TransactionScope)]
		protected override void DataPortal_Update()
		{
			if (!IsDirty) return;	// If not dirty - nothing to do
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.DataPortal_Update", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.<%=_dbConnection%>_SqlConnection)
				{
					ApplicationContext.LocalContext["cn"] = cn;
					SQLUpdate();
					// removing of item only needed for local data portal
					if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
						ApplicationContext.LocalContext.Remove("cn");
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.DataPortal_Update", ex);
				_ErrorMessage = ex.Message;
				if (!ex.Message.EndsWith("has been edited by another user.")) throw ex;
			}
		}
		[Transactional(TransactionalTypes.TransactionScope)]
		internal void SQLUpdate()
		{
			if (!IsDirty) return;	// If not dirty - nothing to do
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.SQLUpdate", GetHashCode());
			try
			{<%=sUpdateMyList%>
				SqlConnection cn = (SqlConnection)ApplicationContext.LocalContext["cn"];
				if (base.IsDirty)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "update<%=_className%>";
						// All Fields including Calculated Fields<%
		foreach(IColumn column in Columns)
		{
			output.write(FormatColumn("\r\n\t\t\t\t\t\t{ifLogicP}cm.Parameters.AddWithValue(\"{@}\", {?dbprefix}{Parent}{?dbsuffix});",column));
		}
%>
						// Output Calculated Columns<%
		foreach(IColumn column in Columns)
		{
			if (column.IsComputed)
			{
				output.write(FormatColumn("\r\n\t\t\t\t\t\tSqlParameter param{member} = new SqlParameter(\"{@new}\", {sqltype});",column));
				output.write(FormatColumn("\r\n\t\t\t\t\t\tparam{member}.Direction = ParameterDirection.Output;",column));
				output.write(FormatColumn("\r\n\t\t\t\t\t\tcm.Parameters.Add(param{member});",column));
			}	
		}
%>
						// CSLATODO: Define any additional output parameters
						cm.ExecuteNonQuery();
						// Save all values being returned from the Procedure<%
		foreach(IColumn column in Columns)
		{
			if (column.IsComputed)
			{
				output.write(FormatColumn("\r\n\t\t\t\t\t\t{member} = ({ctype})cm.Parameters[\"{@new}\"].Value;",column));
			}	
		}
%>
					}
				}
				MarkOld();
				// use the open connection to update child objects<%
		foreach(IColumn field in Columns)
		{
			if (field.IsInForeignKey && field.IsInPrimaryKey)
			{
				//A column that's in a fk and in the pk represents a fk relationship
				//from another table, a one-to-many relationship.  (This might be 
				//a bad assumption for a table with a composite primary key.)
				//... and then we have to add collections for the foreign tables.
				foreach( IForeignKey fk in field.ForeignKeys )
				{
					if (fk.PrimaryTable == _workingTable){
					string sObjName;
						if (!IsPrimaryKey(fk)){
							sObjName = FKClassesName( fk ) + GetAlias( fk );
%>
				if (<%=MemberName(sObjName)%> != null) <%=MemberName(sObjName)%>.Update(this);<%
						 } 
						else 
						{
							sObjName = ClassName( fk.ForeignTable );
%>
				if (<%=MemberName("My" + sObjName)%> != null) <%=MemberName("My" + sObjName)%>.Update(this);<%
						}
					}
				}
			}
		}
%>
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.SQLUpdate", ex);
				_ErrorMessage = ex.Message;
				if (!ex.Message.EndsWith("has been edited by another user.")) throw ex;
			}
		}<%
// Update
		string sKeysTypesU="";
		string sKeysU="";
		string sValuesU="";
		string sepu="";
		foreach(IColumn column in Columns)
		{
			//if ((!column.IsComputed))
			//{
			// Commentted out the following two lines for Permissions
			//	if (!column.IsAutoKey)
					//sValuesU+=FormatColumn("\r\n\t\t\t\t\t{ifLogicL}cm.Parameters.AddWithValue(\"{@}\", {parent}{?dbtype});",column);
					sValuesU+=FormatColumn("\r\n\t\t\t\t\t{ifLogicl}cm.Parameters.AddWithValue(\"{@}\", {local});",column);
				//if (IsParentCol(column)){
				//	sKeysTypesU+= sepi + "/*1*/ " +  _className + " my" + sParent;
				//	sKeysU+=sepi + "my" + sParent;
				//}
				//else
				//{
					sKeysTypesU+=sepu + FormatColumn("{?ref}{ctype} {local}",column);
					sKeysU+=sepu + FormatColumn("{?ref}{member}",column); 
				//}
				sepu=", ";
			//}	
		}
		if (OneToOne(_workingTable)) // 20070314
		{
			IForeignKey fk = _workingTable.PrimaryKeys[0].ForeignKeys[0];
			string sPrimaryTable = ClassName(fk.PrimaryTable);
			string sPrimaryLocal = LocalName(sPrimaryTable);
			string sInsert="";
			string sUpdate="";
	//		string sDelete="";
			string sTimestamp="";
			sepu="";
			sepi="";
			foreach(IColumn column in fk.ForeignTable.Columns)
			{
				if (column.DataTypeName=="timestamp")
					sTimestamp=FormatColumn("{member} = ",column);
				if (!IsIn(column,fk.ForeignColumns))
				{				
					string sRefI = ParentRef(column);
					string sRefU = ParentRefU(column);
					if (sRefI==null)
					{
						sRefI = FormatColumn("{?ref}{?dbprefix}{!propmember}{?dbsuff}",column);
						sRefU = FormatColumn("{?ref}{?dbprefix}{member}{?dbsuff}",column);
					}
						sUpdate+=sepu + sRefU;
						sepu=", ";
						if (!column.IsComputed)// && !column.IsAutoKey
						{
							sInsert+=sepi+sRefI;
							sepi=", ";
						}
					}
					else
					{
						//string sRef = FormatColumn("{?dbprefix}{rmember}{?dbsuff}",RelatedColumn(column,fk));
						string sRef = sPrimaryLocal;
						sInsert+=sepi + sPrimaryLocal;
						sUpdate+=sepu + sPrimaryLocal + "." + FormatColumn("{?ref}{?dbprefix}{prop}{?dbsuff}",column);
						sepi=", ";
						sepu=", ";
						//sepd=", ";
					}
				}
%>
		internal void Update(<%=sPrimaryTable%> <%=sPrimaryLocal%>)<%=Debug("// 20071023.2a Update")%>
		{
			if (!this.IsDirty) return;
			if (base.IsDirty)
			{
				SqlConnection cn = (SqlConnection)ApplicationContext.LocalContext["cn"];
				if (IsNew)
					<%=sTimestamp%><%=_className%>.Add(cn, <%=sInsert%>);
				else
					<%=sTimestamp%><%=_className%>.Update(cn, <%=sUpdate%>);
				MarkOld();
			}
		}<%
		}
		else // 20070314
		{
//			IForeignKey fk = _workingTable.PrimaryKeys[0].ForeignKeys[0];
//			string sPrimaryTable = ClassName(fk.PrimaryTable);
//			string sPrimaryLocal = LocalName(sPrimaryTable);
			string sInsert="";
			string sUpdate="";
			string sTimestamp="";
			sepu="";
			sepi="";
			foreach(IColumn column in Columns)
			{
				if (column.DataTypeName=="timestamp")
					sTimestamp=FormatColumn("{member} = ",column);
				//string sRef = FormatColumn("{?ref}{?dbprefix}{!member}{?dbsuff}",column);
				string sRefI = FormatColumn("{?ref}{?dbprefix}{!member}{?dbsuff}",column);
				string sRefU = FormatColumn("{?ref}{?dbprefix}{member}{?dbsuff}",column);
				if (!column.IsComputed)// && !column.IsAutoKey
				{
					sInsert+=sepi+sRefI;
					sepi=", ";
				}
				sUpdate+=sepu + sRefU;
				sepi=", ";
				sepu=", ";
			}
			string sDelete ="";
			string sepdd = "";
			foreach(IColumn column in _workingTable.PrimaryKeys)
			{
				//if (IsIn(column,fk.ForeignColumns))
					//sDelete+=sepdd+FormatColumn("{!localcolumn}",column);
					//sDelete+=sepdd+FormatColumn("{rmember}",RelatedColumn(column,fk));
				//else
					sDelete+=sepdd+FormatColumn("{member}",column);
				sepdd=", ";
			}
%>
		internal void Update()<%=Debug("// 20071023.2b Update")%>
		{
			if (!this.IsDirty) return;
			if (base.IsDirty)
			{
				SqlConnection cn = (SqlConnection)ApplicationContext.LocalContext["cn"];
				if (IsNew)
					<%=sTimestamp%><%=_className%>.Add(cn, <%=sInsert%>);
				else
					<%=sTimestamp%><%=_className%>.Update(cn, <%=sUpdate%>);
				MarkOld();
			}<%
			if (vlnChildObjects(Columns))
			{
%>
		}
		internal void DeleteSelf(<%=_className%> <%=_className.ToLower()%>)
		{
			// if we're not dirty then don't update the database
			if (!this.IsDirty) return;
			// if we're new then don't update the database
			if (this.IsNew) return;
			SqlConnection cn = (SqlConnection)ApplicationContext.LocalContext["cn"];
			<%=_className%>.Remove(cn, <%=sDelete%>);
			MarkNew();<%
			}
%>
		}<%
		}
%>
		[Transactional(TransactionalTypes.TransactionScope)]
		public static <%=sRetval%> Update(SqlConnection cn, <%=sKeysTypesU%>)
		{
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.Update", 0);
			try
			{
				using (SqlCommand cm = cn.CreateCommand())
				{
					cm.CommandType = CommandType.StoredProcedure;
					cm.CommandText = "update<%=_className%>";
					// Input All Fields - Except Calculated Columns<%=sValuesU%>
					// Output Calculated Columns<%
		foreach(IColumn column in Columns)
		{
			if (column.IsComputed)
			{
				output.write(FormatColumn("\r\n\t\t\t\t\tSqlParameter param{member} = new SqlParameter(\"{@new}\", {sqltype});",column));
				output.write(FormatColumn("\r\n\t\t\t\t\tparam{member}.Direction = ParameterDirection.Output;",column));
				output.write(FormatColumn("\r\n\t\t\t\t\tcm.Parameters.Add(param{member});",column));
			}	
		}
%>
					// CSLATODO: Define any additional output parameters
					cm.ExecuteNonQuery();
					// Save all values being returned from the Procedure<%
		tsCol=null;
		foreach(IColumn column in Columns)
		{
			if (column.IsComputed)
			{
				if (column.DataTypeName=="timestamp")tsCol=column;
				else output.write(FormatColumn("\r\n\t\t\t\t\t{local} = ({ctype})cm.Parameters[\"{@new}\"].Value;",column));
			}	
		}
		if (tsCol != null)
			output.write(FormatColumn("\r\n\t\t\t\t\treturn ({ctype})cm.Parameters[\"{@new}\"].Value;",tsCol));
		else
			output.write("\r\n\t\t\t\t// No Timestamp value to return");
%>
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.Update", ex);
				throw new DbCslaException("<%=_className%>.Update", ex);
			}
		}<%
// DataPortal_DeleteSelf
%>
		[Transactional(TransactionalTypes.TransactionScope)]
		protected override void DataPortal_DeleteSelf()
		{
			DataPortal_Delete(new PKCriteria(<%=FormatColumns("{member}",_workingTable.PrimaryKeys,", ")%>));
		}<%
// DataPortal_Delete
%>
		[Transactional(TransactionalTypes.TransactionScope)]
		private void DataPortal_Delete(PKCriteria criteria)
		{
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.DataPortal_Delete", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.<%=_dbConnection%>_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "delete<%=_className%>";<%
			output.write(FormatColumns("\r\n\t\t\t\t\t\t{ifLogic@}cm.Parameters.AddWithValue(\"{@}\", criteria.{prop}{?dbtype});"
			,_workingTable.PrimaryKeys,""));
%>
						cm.ExecuteNonQuery();
					}
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.DataPortal_Delete", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("<%=_className%>.DataPortal_Delete", ex);
			}
		}<%
// Delete
		string sKeysTypesD="";
		string sValuesD="";
		string sepd="";
		foreach(IColumn column in _workingTable.PrimaryKeys)
		{
			sValuesD+=FormatColumn("\r\n\t\t\t\t\t{ifLogicL}cm.Parameters.AddWithValue(\"{@}\", {local}{?dbtype});",column);
			sKeysTypesD+=sepd + FormatColumn("{ctype} {local}",column);
			sepd=", ";
		}
%>
		[Transactional(TransactionalTypes.TransactionScope)]
		public static void Remove(SqlConnection cn, <%=sKeysTypesD%>)
		{
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.Remove", 0);
			try
			{
				using (SqlCommand cm = cn.CreateCommand())
				{
					cm.CommandType = CommandType.StoredProcedure;
					cm.CommandText = "delete<%=_className%>";
					// Input PK Fields<%=sValuesD%>
					// CSLATODO: Define any additional output parameters
					cm.ExecuteNonQuery();
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.Remove", ex);
				throw new DbCslaException("<%=_className%>.Remove", ex);
			}
		}
		#endregion<%
	}
private bool vlnChildObjects(IColumns Columns)
{
	bool retval = false;
	foreach(IColumn field in Columns)
	{
		if (field.IsInForeignKey && field.IsInPrimaryKey)
		{
			//A column that's in a fk and in the pk represents a fk relationship
			//from another table, a one-to-many relationship.  (This might be 
			//a bad assumption for a table with a composite primary key.)
			//... and then we have to add collections for the foreign tables.
			foreach( IForeignKey fk in field.ForeignKeys )
			{
				if (fk.PrimaryTable == _workingTable)
				{
					string sObjName;
					if (!IsPrimaryKey(fk)){ // Items that use this table's Primary Key
						sObjName = FKClassesName( fk ) + GetAlias( fk );
						if (fk.PrimaryTable == fk.ForeignTable)retval = true;
%>
			if (<%=MemberName(sObjName)%> != null) <%=MemberName(sObjName)%>.Update(this);<%
					}
					else
					{
						sObjName = ClassName( fk.ForeignTable );
%>
			if (<%=MemberName("My" + sObjName)%> != null) <%=MemberName("My" + sObjName)%>.Update(this);<%
					}
				}
			}
		}
	}
	return retval;
}
private void vlnBrokenRuleObjects(IColumns Columns)
{
	foreach(IColumn field in Columns)
	{
		if (field.IsInForeignKey && field.IsInPrimaryKey)
		{
			//A column that's in a fk and in the pk represents a fk relationship
			//from another table, a one-to-many relationship.  (This might be 
			//a bad assumption for a table with a composite primary key.)
			//... and then we have to add collections for the foreign tables.
			foreach( IForeignKey fk in field.ForeignKeys )
			{
				if (fk.PrimaryTable == _workingTable)
				{
					string sObjName;
					if (!IsPrimaryKey(fk))
					{ // Items that use this table's Primary Key
						sObjName = FKClassesName( fk ) + GetAlias(fk);
%>
					if (<%=MemberName(sObjName)%> != null && (hasBrokenRules = <%=MemberName(sObjName)%>.HasBrokenRules) != null) return hasBrokenRules;<%
					}
					else
					{
						string sMemberName = MemberName("My" + ClassName( fk.ForeignTable )+ GetNewAlias(fk,fk));
%>
					if (<%=sMemberName%> != null && (hasBrokenRules = <%=sMemberName%>.HasBrokenRules) != null) return hasBrokenRules;<%
					}
				}
			}
		}
		else
		{
			foreach( IForeignKey fk in field.ForeignKeys )
			{
				if (fk.PrimaryTable != _workingTable && IsPrimaryKey1(fk) && !IsPrimaryKey(fk))
				{
					string sMemberName  = MemberName("My" + ClassName(fk.PrimaryTable.Name) + GetNewAlias(fk,fk));
%>
					if (<%=sMemberName%> != null && (hasBrokenRules = <%=sMemberName%>.HasBrokenRules) != null) return hasBrokenRules;<%
				}
			}
		}
	}
}
private void vlnBrokenRuleObjects(IForeignKey myFk)
{
	IColumns Columns=myFk.ForeignTable.Columns;
	// Exclude one to one & ForeignKey Relationship
	foreach(IColumn field in Columns)
	{
		if (!field.IsInForeignKey || !field.IsInPrimaryKey)
		{
			foreach( IForeignKey fk in field.ForeignKeys )
			{
				if (fk.PrimaryTable != _workingTable && IsPrimaryKey1(fk) && !IsPrimaryKey(fk))
				{
					string sMemberName  = MemberName("My" + ClassName(fk.PrimaryTable.Name) + GetNewAlias(fk,fk));
%>
					if (<%=sMemberName%> != null && (hasBrokenRules = <%=sMemberName%>.HasBrokenRules) != null) return hasBrokenRules;<%
				}
			}
		}
	}
}
private void vlnTest(IForeignKey myFk) // 20070517
{
	IColumns Columns=myFk.ForeignTable.Columns;
	// Exclude one to one & ForeignKey Relationship
	foreach(IColumn field in Columns)
	{
		if (!field.IsInForeignKey || !field.IsInPrimaryKey)
		{
			foreach( IForeignKey fk in field.ForeignKeys )
			{
				if (fk.PrimaryTable != _workingTable && IsPrimaryKey1(fk) && !IsPrimaryKey(fk))
				{
					string sMemberName  = MemberName("My" + ClassName(fk.PrimaryTable.Name) + GetNewAlias(fk,fk));
%>
					if (<%=sMemberName%> != null && (hasBrokenRules = <%=sMemberName%>.HasBrokenRules) != null) return hasBrokenRules;<%
				}
			}
		}
	}
}
private string RequiredRelatedColumn(IColumn field)
{
	if (!field.IsInPrimaryKey && !field.IsNullable)
	{
		foreach( IForeignKey fk in field.ForeignKeys )
		{
			if (fk.PrimaryTable != _workingTable && IsPrimaryKey1(fk) && !IsPrimaryKey(fk))
			{
				return  "My" + ClassName(fk.PrimaryTable.Name) + GetNewAlias(fk,fk);
			}
		}
	}
	return null;
}
private void vlnDataPortalFetch(string sPrefix,IColumns cols,string sql,bool getChildren)
	{
// DataPortal_Fetch
%>
		private void DataPortal_Fetch(<%=sPrefix%>Criteria criteria)
		{
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.DataPortal_Fetch", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.<%=_dbConnection%>_SqlConnection)
				{
					ApplicationContext.LocalContext["cn"] = cn;
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "get<%=sql%>";<%
		output.write(FormatColumns("\r\n\t\t\t\t\t\t{ifLogic@}cm.Parameters.AddWithValue(\"{@}\", criteria.{prop}{?dbtype});"
			,cols,""));
%>
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							if (!dr.Read())
							{
								_ErrorMessage = "No Record Found";
								return;
							}
							ReadData(dr);<%
		// Read members 
		//output.write(FormatColumns(dicRead,Columns,"","\r\n\t\t\t\t\t\t\t"));
		//dicRead1 = new Hashtable();
		//dicRead1["timestamp"]="\r\n\t\t\t\t\t\tdr.GetBytes(\"{name}\", 0, {member}, 0, 8);";// CSLATODO: Need to handle TimeStamp
		//output.write(FormatColumns(dicRead1,Columns,""));
//			if (_workingTable != fk.ForeignTable)
//				FKSelect(fk,tbl);
		// CSLATODO: Fix This  See Below
//		foreach(IColumn field in Columns)
//		{
//			if (field.IsInForeignKey && field.IsInPrimaryKey)
//			{
				//A column that's in a fk and in the pk represents a fk relationship
				//from another table, a one-to-many relationship.  (This might be 
				//a bad assumption for a table with a composite primary key.)
				//... and then we have to add collections for the foreign tables.
//				foreach( IForeignKey fk in field.ForeignKeys )
		if (getChildren)
		{
			Hashtable dicAlias = new Hashtable();
			foreach(IForeignKey fk in _workingTable.ForeignKeys)
					{
						if (fk.PrimaryTable == _workingTable){
							//string sAlias = GetAlias(dicAlias,fk.ForeignTable);
							string sAlias = GetAlias(fk);
							string sObjName="";
							if (!IsPrimaryKey(fk)){
								sObjName = FKClassesName( fk ) + GetAlias(fk);
								string sExtra = FKAndString(_className, fk, ", this" );
//							else
//								sObjName = ClassName( fk.ForeignTable );
							if (fk.PrimaryTable != fk.ForeignTable){
%>
							// load child objects
							dr.NextResult();
							<%=MemberName(sObjName)%> = <%=sObjName%>.Get(dr<%=sExtra%>);<%
								}
							}
							else
							{
								sObjName = ClassName( fk.ForeignTable );
%>
							// load child objects
							dr.NextResult();
							<%=MemberName("My" + sObjName)%> = <%=sObjName%>.Get(dr);<%
//							if (<%=MemberName("My" + sObjName) + sAlias == null)
//								=MemberName("My" + sObjName) + sAlias = <%=sObjName.New(=FormatColumns("criteria.{prop}",fk.ForeignTable.PrimaryKeys,", ","")
							}
						}
					}
				}
//			}
//		}
%>
						}
					}
					// removing of item only needed for local data portal
					if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
						ApplicationContext.LocalContext.Remove("cn");
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.DataPortal_Fetch", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("<%=_className%>.DataPortal_Fetch", ex);
			}
		}<%
	}
	private void vlnExists(IColumns Columns )
	{
		string sValues=FormatColumns("\t\t\t\t{member} = {local};",_workingTable.PrimaryKeys,"\r\n");
		string sKeysTypes=FormatColumns("{ctype} {local}",_workingTable.PrimaryKeys,", ");
		string sKeys=FormatColumns("{local}",_workingTable.PrimaryKeys,", ");
		string sDeclare=FormatColumns("\r\n\t\t\tprivate {ctype} {member};",_workingTable.PrimaryKeys,"");
		string sParams=FormatColumns("\r\n\t\t\t\t\t\t\t{ifLogicP}cm.Parameters.AddWithValue(\"{@}\", {?dbprefix}{member}{?dbsuffix});",_workingTable.PrimaryKeys,"");;
%>
		#region Exists
		public static bool Exists(<%=sKeysTypes%>)
		{
			ExistsCommand result;
			try
			{
				result = DataPortal.Execute<ExistsCommand>(new ExistsCommand(<%=sKeys%>));
				return result.Exists;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=_className%>.Exists", ex);
			}
		}
		[Serializable()]
		private class ExistsCommand : CommandBase
		{<%=sDeclare%>
			private bool _exists;
			public bool Exists
			{
				get { return _exists; }
			}
			public ExistsCommand(<%=sKeysTypes%>)
			{
<%=sValues%>
			}
			protected override void DataPortal_Execute()
			{
				<%=_databaseLogDebug%>("[{0}] <%=_className%>.DataPortal_Execute", GetHashCode());
				try
				{
					using (SqlConnection cn = Database.<%=_dbConnection%>_SqlConnection)
					{
						cn.Open();
						using (SqlCommand cm = cn.CreateCommand())
						{
							cm.CommandType = CommandType.StoredProcedure;
							cm.CommandText = "exists<%=_className%>";<%=sParams%>
							int count = (int)cm.ExecuteScalar();
							_exists = (count > 0);
						}
					}
				}
				catch (Exception ex)
				{
					<%=_databaseLogError%>("<%=_className%>.DataPortal_Execute", ex);
					throw new DbCslaException("<%=_className%>.DataPortal_Execute", ex);
				}
			}
		}
		#endregion<%
	}
	private void vlnInfoExtension(IColumns columns)
	{
%>
		// Standard Refresh
		#region extension
		<%=_className%>Extension <%=MemberName(_className)%>Extension = new <%=_className%>Extension();
		[Serializable()]
		partial class <%=_className%>Extension : extensionBase { }
		[Serializable()]
		class extensionBase
		{
			// Default Refresh
			public virtual void Refresh(<%=_className%> tmp) { }
		}
		#endregion<%
	}
	private void vlnDefaults(IColumns columns)
	{
%>
		// Standard Default Code
		#region extension
		<%=extName%> <%=extMName%> = new <%=extName%>();
		[Serializable()]
		partial class <%=extName%> : extensionBase
		{
		}
		[Serializable()]
		class extensionBase
		{
			// Default Values<%
		foreach(IColumn column in HasDefaults(columns))
		{
			string sConvert ="{default}";
			if (FormatColumn("{rtype}",column).StartsWith("bool"))sConvert="Convert.ToBoolean({default})";
%>
			public virtual <%=FormatColumn("{rtype} Default{prop}",column)%>
			{
				get { return <%=FormatColumn(sConvert,column)%>; }
			}<%
		}
%>
			// Authorization Rules
			public virtual void AddAuthorizationRules(Csla.Security.AuthorizationRules rules)
			{
				// Needs to be overriden to add new authorization rules
			}
			// Instance Authorization Rules
			public virtual void AddInstanceAuthorizationRules(Csla.Security.AuthorizationRules rules)
			{
				// Needs to be overriden to add new authorization rules
			}
			// Validation Rules
			public virtual void AddValidationRules(Csla.Validation.ValidationRules rules)
			{
				// Needs to be overriden to add new validation rules
			}
			// InstanceValidation Rules
			public virtual void AddInstanceValidationRules(Csla.Validation.ValidationRules rules)
			{
				// Needs to be overriden to add new validation rules
			}
		}
		#endregion<%
		}
		private void vlnExtension(IColumns columns)
		{
%>

//// The following is a sample Extension File.  You can use it to create <%=_className%>Ext.cs
//using System;
//using System.Collections.Generic;
//using System.Text;
//using Csla;

//namespace <%=_nameSpace%>
//{
//  public partial class <%=_className%>
//  {
//    partial class <%=_className%>Extension : extensionBase
//    {
//      // CSLATODO: Override automatic defaults<%
			foreach(IColumn column in HasDefaults(columns))
			{
%>
//      public virtual <%=FormatColumn("{ctype} Default{prop}",column)%>
//      {
//        get { return <%=FormatColumn("{default}",column)%>; }
//      }<%
		}
%>
//      public new void AddAuthorizationRules(Csla.Security.AuthorizationRules rules)
//      {
//        //rules.AllowRead(Dbid, "<Role(s)>");
//      }
//      public new void AddInstanceAuthorizationRules(Csla.Security.AuthorizationRules rules)
//      {
//        //rules.AllowInstanceRead(Dbid, "<Role(s)>");
//      }
//      public new void AddValidationRules(Csla.Validation.ValidationRules rules)
//      {
//        rules.AddRule(
//          Csla.Validation.CommonRules.StringMaxLength,
//          new Csla.Validation.CommonRules.MaxLengthRuleArgs("Name", 100));
//      }
//      public new void AddInstanceValidationRules(Csla.Validation.ValidationRules rules)
//      {
//        rules.AddInstanceRule(/* Instance Validation Rule */);
//      }
//    }
//  }
//}
<%
	}
	//private bool IsValueType( string type )
	//{
	//	switch( type )
	//	{
	//		case "sbyte":
	//		case "byte":
	//		case "short":
	//		case "ushort":
	//		case "int":
	//		case "uint":
	//		case "long":
	//		case "ulong":
	//		case "char":
	//		case "float":
	//		case "double":
	//		case "bool":
	//		case "decimal":
	//		case "DateTime":
	//			return true;
	//			break;
	//			
	//		default:
	//			return false;
	//			break;
	//	}
	//}
	
	
	private void vlnBusinessMethodsFKList(IForeignKey fk,string sAlias)
	{
%>
		#region Business Methods
		private string _ErrorMessage = string.Empty;
		public string ErrorMessage
		{
			get { return _ErrorMessage; }
		}<%
		//string sFkClassListName =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable ) + sAlias;
		//string sFkClassName =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		string sFkClassListName =  _className;
		string sFkClassName =  _subclassName;
		string slName=LocalName(ClassName(fk.ForeignTable));
		ArrayList fkCols = new ArrayList();
		//output.write("\r\n// FK.P " + fk.PrimaryTable.Name + " FK.F " +fk.ForeignTable.Name); 
		bool bManyToMany = false;
//		if (fk.ForeignTable != fk.PrimaryTable)
//		{
//			foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys)
//			{
//				//output.write("\r\n// PK.P " + pk.PrimaryTable.Name + " PK.F " +pk.ForeignTable.Name);
//				if (pk.ForeignTable == fk.ForeignTable && pk.PrimaryTable != fk.PrimaryTable && pk.PrimaryTable != pk.ForeignTable && ForeignRequired(pk))
//				{
//					foreach(IColumn col in pk.ForeignColumns){
//						//output.write("\r\n// col " + col.Name + " IsInPrimaryKey " + col.IsInPrimaryKey.ToString()); 
//						//if (col.IsInPrimaryKey)
//						if (!col.IsNullable){
//							fkCols.Add(col);
//						}
//					}
//				}
//			}
//		}
		foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys)
		{
			if (!bManyToMany && ManyToMany(_workingTable,fk,pk))
			{
				bManyToMany = true;
				foreach(IColumn col in pk.ForeignColumns)
					if (!col.IsNullable) fkCols.Add(col);
			}
		}
//		fkCols = new ArrayList();
		if (fkCols.Count == 0){
//			bManyToMany = false;
%>
		// One To Many<%
			foreach(IColumn col in fk.ForeignTable.PrimaryKeys)
			{
				if (!IsIn(col,fk.ForeignColumns))
					fkCols.Add(col);
			}
		}
		else
		{
%>
		// Many To Many<%
		}
			string sTestTypes = FormatColumns("{!type}",fkCols,", ");
			string sFkKeysTypes = FormatColumns("{!type} {!local}",fkCols,", ");
			string sFkKeys = FormatColumns("{!local}",fkCols,", ");
			string sFkCheck = FormatColumns(slName +".{prop} == {!localcolumn}",fkCols," && ");
			string sReqKeysCheck= "";
			string sKeysTypes="";
			string sKeys="";
			//string sValues="";
			//string sValues2="";
			//string sep="";
			string sep2="";
			string sep3="";
			string reqKeys="";
			string reqKeysTypes="";
			ArrayList reqCols = new ArrayList();
			ArrayList uniqueChildren = FindUniqueChildren(fk);
			bool bParentRef=false;
			foreach(IColumn column in fk.ForeignTable.Columns)
			{
				if (IsRequired(column) && !column.IsComputed && !column.IsAutoKey)
				{
					// 20070220
					// sKeysTypes+=sep+FormatColumn("{ctype} {local}",column);
					// sKeys+=sep+FormatColumn("{local}",column);
					if (!IsIn(column,fk.ForeignColumns))
					{
						sKeysTypes+=sep2+FormatColumn("{!type} {!local}",column);
						sKeys+=sep2+FormatColumn("{!local}",column);
						sReqKeysCheck+=sep3+FormatColumn(slName +".{prop} == {local}",column);
						reqKeys+=sep2+FormatColumn("{!local}",column);
						reqKeysTypes+=sep2+FormatColumn("{!type} {!local}",column);
						reqCols.Add(column);
						sep2=", ";
						sep3=" && ";
					} else {
						if (!bParentRef && FKParentFK(_workingTable) == fk){
//							WriteLine("\r\n\r\n// 20070305 Column {0}\r\n",column.Name);
							reqKeys="my"+ParentName(fk)+sep2+reqKeys;
							reqKeysTypes=FormatColumn("{ParentType}",column)+sep2+reqKeysTypes;
							sep2=", ";
							bParentRef=true;
						}
					}
					//sValues+=sep+RelatedObject(column);
					//sValues2+=sep+RelatedObjectType(column);
					//sep=", ";
				}
			}
			string reqKeysContain = (SameList(reqCols,fkCols)?sFkKeys:reqKeys);
			IList uniqueMatch = FindUnique(uniqueChildren,reqCols);
			//if (uniqueMatch != null)WriteLine("\r\n//20090108 - \r\n\tuniqueMatch {0}\r\n\treqCols {1}", ColumnListToString(uniqueMatch),ColumnListToString(reqCols) );
			string newString = (fkCols.Count==1 && sTestTypes == "int" ? "new " : "");
%>
		public <%=newString%><%=sFkClassName%> this[<%=sFkKeysTypes%>]
		{
			get
			{
				foreach (<%=sFkClassName%> <%=slName%> in this)
					if (<%=sFkCheck%>)
						return <%=slName%>;
				return null;
			}
		}
		public new System.Collections.Generic.IList<<%=sFkClassName%>> Items
		{
			get { return base.Items; }
		}
		public <%=sFkClassName%> GetItem(<%=sFkKeysTypes%>)
		{
			foreach (<%=sFkClassName%> <%=slName%> in this)
				if (<%=sFkCheck%>)
					return <%=slName%>;
			return null;
		}<%
		if (bManyToMany)
		{
			if (reqKeys!=""){ // Has Required Fields
%>
		public <%=sFkClassName%> Add(<%=reqKeysTypes%>)// Many to Many with required fields
		{
			if (!Contains(<%=sFkKeys%>))
			{
				<%=sFkClassName%> <%=slName%> =	<%=sFkClassName%>.New(<%=reqKeys%>);
				this.Add(<%=slName%>);
				return <%=slName%>;
			}
			else
				throw new InvalidOperationException("<%=slName%> already exists");
		}<%
			}
			else
			{
				if (uniqueMatch != null && uniqueMatch.Count > 1)
				{
%>
		public <%=sFkClassName%> Add(<%=reqKeysTypes%>)// Many to Many with unique fields
		{
			if (!Contains(<%=FormatColumns("{local}",uniqueMatch,", ","")%>))
			{
				<%=sFkClassName%> <%=slName%> = <%=sFkClassName%>.New(<%=reqKeys%>);
				this.Add(<%=slName%>);
				return <%=slName%>;
			}
			else
				throw new InvalidOperationException("<%=slName%> already exists");
		}<%
				}
				else
				{
%>
		public <%=sFkClassName%> Add(<%=reqKeysTypes%>)// Many to Many with no required fields
		{
			<%=sFkClassName%> <%=slName%> =	<%=sFkClassName%>.New(<%=reqKeys%>);
			this.Add(<%=slName%>);
			return <%=slName%>;
		}<%
				}
			}
		}
		else // One to Many
		{
			// If Child add parent 20070221
			
			string sParent = "";
			string sParentUse = "";
			//if ("Child" + ClassesName(sFkClassName) == _className)
			//{
			//	sParent = sFkClassName + " parent, ";
			//	sParentUse = "parent, ";
			//}
				if (uniqueMatch != null)
				{
%>
		public <%=sFkClassName%> Add(<%=reqKeysTypes%>) // One to Many with unique fields
		{
			if (!Contains(<%=FormatColumns("{!local}",uniqueMatch,", ","")%>))
			{
				<%=sFkClassName%> <%=slName%> = <%=sFkClassName%>.New(<%=reqKeys%>);
				this.Add(<%=slName%>);
				return <%=slName%>;
			}
			else
				throw new InvalidOperationException("<%=slName%> already exists");
		}<%
				}
				else
				{
%>
		public <%=sFkClassName%> Add(<%=sParent%><%=sKeysTypes%>) // One to Many 
		{
			<%=sFkClassName%> <%=slName%> = <%=sFkClassName%>.New(<%=sParentUse%><%=sKeys%>);
			this.Add(<%=slName%>);
			return <%=slName%>;
		}<%
			}
		}
		if(fkCols.Count == 1 && uniqueMatch != null && uniqueMatch.Count == 1 && fkCols[0]==uniqueMatch[0])
					uniqueMatch=null;
%>
		public void Remove(<%=sFkKeysTypes%>)
		{
			foreach (<%=sFkClassName%> <%=slName%> in this)
			{
				if (<%=sFkCheck%>)
				{
					Remove(<%=slName%>);
					break;
				}
			}
		}
		public bool Contains(<%=sFkKeysTypes%>)
		{
			foreach (<%=sFkClassName%> <%=slName%> in this)
				if (<%=sFkCheck%>)
					return true;
			return false;
		}
		public bool ContainsDeleted(<%=sFkKeysTypes%>)
		{
			foreach (<%=sFkClassName%> <%=slName%> in DeletedList)
				if (<%=sFkCheck%>)
					return true;
			return false;
		}
		public bool IsDirtyList(List<object> list)
		{
			// any non-new deletions make us dirty
			foreach (<%=sFkClassName%> item in DeletedList)
				if (!item.IsNew)
					return true;
			// run through all the child objects
			// and if any are dirty then then
			// collection is dirty
			foreach (<%=sFkClassName%> child in this)
				if (child.IsDirtyList(list))
					return true;
			return false;
		}
		public override bool IsValid
		{
			get { return IsValidList(new List<object>()); }
		}
		public bool IsValidList(List<object> list)
    {
      // run through all the child objects
      // and if any are invalid then the
      // collection is invalid
      foreach (<%=sFkClassName%> child in this)
				if (!child.IsValidList(list))
				{
					//Console.WriteLine("Valid {0} Child {1} - {2}", child.IsValid, child.GetType().Name,child.ToString());
					return false;
				}
       return true;
     }<%
		foreach(IList lst in uniqueChildren){
			if (!SameTypes(lst,fkCols)){ // Has Required Fields 20070302
				if(lst.Count == 1 && uniqueMatch != null && uniqueMatch.Count == 1 && lst[0]==uniqueMatch[0])
					uniqueMatch=null;
				string sLstKeysTypes = FormatColumns("{ctype} {local}",lst,", ");
//				string sKeys = FormatColumns("{local}",lst,", ");
				string sLstCheck = FormatColumns(slName +".{prop} == {local}",lst," && ");
%>
		public bool Contains(<%=sLstKeysTypes%>)
		{
			foreach (<%=sFkClassName%> <%=slName%> in this)
				if (<%=sLstCheck%>)
					return true;
			return false;
		}
		public bool ContainsDeleted(<%=sLstKeysTypes%>)
		{
			foreach (<%=sFkClassName%> <%=slName%> in DeletedList)
				if (<%=sLstCheck%>)
					return true;
			return false;
		}<%
			}
		}
		if(uniqueMatch != null && uniqueMatch.Count == 1)
		{
			IColumn col =(IColumn)uniqueMatch[0];
				string sLstKeysTypes = FormatColumn("{!type} {!local}",col);
				string sLstCheck = FormatColumn(slName +".{prop} == {!local}.{!column}",col);
%>
		public bool Contains(<%=sLstKeysTypes%>)
		{
			foreach (<%=sFkClassName%> <%=slName%> in this)
				if (<%=sLstCheck%>)
					return true;
			return false;
		}
		public bool ContainsDeleted(<%=sLstKeysTypes%>)
		{
			foreach (<%=sFkClassName%> <%=slName%> in DeletedList)
				if (<%=sLstCheck%>)
					return true;
			return false;
		}<%
		}
%>
		#endregion<%
	}
	private void vlnFactoryMethodsFKList(IForeignKey fk,string sAlias)
	{
		//string sFkClassListName =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable ) + sAlias;
		//string sFkClassName =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		string sFkClassListName =  _className;
		string sFkClassName =  _subclassName;
		string sExtra1="";
		string sExtra2="";
		if (fk.PrimaryTable == fk.ForeignTable){
			sExtra1=", " + _subclassName + " parent";
			sExtra2=", parent";
		}

%>
		#region Factory Methods
		internal static <%=sFkClassListName%> New()
		{
			return new <%=sFkClassListName%>();
		}
		internal static <%=sFkClassListName%> Get(SafeDataReader dr<%=sExtra1%>)
		{
			return new <%=sFkClassListName%>(dr<%=sExtra2%>);
		}<%
//		if (fk.PrimaryTable==fk.ForeignTable)
//		{
			// Get Children 20070205
			string sBy = FormatColumns("{name}",fk.ForeignColumns,"_","");
			string sKeyTypes = FormatColumns("{ctype1} {local}",fk.ForeignColumns,",","");
			string sKeys = FormatColumns("{local}",fk.ForeignColumns,",","");
%>
		public static <%=sFkClassListName%> GetBy<%=sBy%>(<%=sKeyTypes%>)
		{
			try
			{
				return DataPortal.Fetch<<%=sFkClassListName%>>(new <%=sBy%>Criteria(<%=sKeys%>));
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=sFkClassListName%>.GetBy<%=sBy%>", ex);
			}
		}<%
//		}
%>
		private <%=sFkClassListName%>()
		{
			MarkAsChild();
		}
		internal <%=sFkClassListName%>(SafeDataReader dr<%=sExtra1%>)
		{
			MarkAsChild();
			Fetch(dr<%=sExtra2%>);
		}
		private bool _Disposed = false;
		private static int _CountCreated = 0;
		private static int _CountDisposed = 0;
		private static int _CountFinalized = 0;
		private static int IncrementCountCreated
		{ get { return ++_CountCreated; } }
		private int _CountWhenCreated = IncrementCountCreated;
		public static int CountCreated
		{ get { return _CountCreated; } }
		public static int CountNotDisposed
		{ get { return _CountCreated - _CountDisposed; } }
		public static int CountNotFinalized
		{ get { return _CountCreated - _CountFinalized; } }
		~<%=sFkClassListName%>()
		{
			_CountFinalized++;
		}
		public void Dispose()
		{
			if (_Disposed) return;
			_CountDisposed++;
			_Disposed = true;
		}
		#endregion<%
	}
	private void vlnDataAccessPortalFKList(IForeignKey fk,string sAlias)
	{
		//string sFkClassListName =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable ) + sAlias;
		//string sFkClassName =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		string sFkClassListName =  _className;
		string sFkClassName =  _subclassName;
		string sPrimaryTable = ClassName( fk.PrimaryTable );
		string sPrimaryLocal = LocalName(sPrimaryTable);
		string sExtra1="";
		string sExtra2="";
		if (fk.PrimaryTable == fk.ForeignTable){
			sExtra1=", " + _subclassName + " parent";
			sExtra2=", parent";
		}
%>
		#region Data Access Portal
		// called to load data from the database
		private void Fetch(SafeDataReader dr<%=sExtra1%>)
		{
			this.RaiseListChangedEvents = false;
			while (dr.Read())
				this.Add(<%=sFkClassName%>.Get(dr<%=sExtra2%>));
			this.RaiseListChangedEvents = true;
		}<%
		string sClassF = ClassName(fk.ForeignTable);
		string sClassP = FormatColumns("{name}",fk.ForeignColumns,"_","");
		string sBy = ClassesName(fk.ForeignTable) + "By" + FormatColumns("{name}",fk.ForeignColumns,"_","");
		string sSelfParam = "";
		if (fk.ForeignTable == fk.PrimaryTable)
		{
			sBy = ChildName(fk) + ClassesName(_workingTable);
			sSelfParam = ", " + FormatColumns("criteria.{prop}",fk.ForeignColumns,"","");
		}
		string sKeyTypes = FormatColumns("{ctype1} {local}",fk.ForeignColumns,",","");
%>
		[Serializable()]
		private class <%=sClassP%>Criteria
		{
			public <%=sClassP%>Criteria(<%=sKeyTypes%>)
			{
<%=FormatColumns("{member} = {local};",fk.ForeignColumns,"\r\n","\t\t\t\t")%>
			}<%
		foreach(IColumn c in fk.ForeignColumns)
		{
			string sMember=FormatColumn("{member}",c);
			string sProp=FormatColumn("{prop}",c);
			string sType=FormatColumn("{ctype1}",c);
%>
			private <%=sType%> <%=sMember%>;
			public <%=sType%> <%=sProp%>
			{
				get { return <%=sMember%>; }
				set { <%=sMember%> = value; }
			}<%
		}
%>
		}
		private void DataPortal_Fetch(<%=sClassP%>Criteria criteria)
		{
			this.RaiseListChangedEvents = false;
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.DataPortal_Fetch<%=sClassP%>", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.<%=_dbConnection%>_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "get<%=sBy%>";
						<%=FormatColumns("{ifLogic@}cm.Parameters.AddWithValue(\"{@}\", " + "criteria.{prop});",fk.ForeignColumns,"\r\n\t\t\t","")%>
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							while (dr.Read()) this.Add(new <%=_subclassName%>(dr<%=sSelfParam%>));
						}
					}
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.DataPortal_Fetch<%=sClassP%>", ex);
				throw new DbCslaException("<%=_className%>.DataPortal_Fetch", ex);
			}
			this.RaiseListChangedEvents = true;
		}<%
		
		// Insert 20070205a
%>
		internal void Update(<%=sPrimaryTable%> <%=sPrimaryLocal%>)<%=Debug("// 20071023.3 Update")%>
		{
			this.RaiseListChangedEvents = false;
			try
			{
				// update (thus deleting) any deleted child objects
				foreach (<%=sFkClassName%> obj in DeletedList)
					obj.DeleteSelf(<%=sPrimaryLocal%>);// Deletes related record
				// now that they are deleted, remove them from memory too
				DeletedList.Clear();
				// add/update any current child objects
				foreach (<%=sFkClassName%> obj in this)
				{<%
// Logic changes for children
		if (fk.PrimaryTable == fk.ForeignTable)
		{
%>
					if (obj.IsNew)
						obj.SQLInsert();
					else
						obj.SQLUpdate();<%
		} else {
%>
					if (obj.IsNew)
						obj.Insert(<%=sPrimaryLocal%>);
					else
						obj.Update(<%=sPrimaryLocal%>);<%
		}
%>
				}
			}
			finally
			{
				this.RaiseListChangedEvents = true;
			}
		}
		#endregion<%
	}
	private void vlnComponentModelFKList()
	{
%>
		#region ICustomTypeDescriptor impl
		public String GetClassName()
		{ return TypeDescriptor.GetClassName(this, true); }
		public AttributeCollection GetAttributes()
		{ return TypeDescriptor.GetAttributes(this, true); }
		public String GetComponentName()
		{ return TypeDescriptor.GetComponentName(this, true); }
		public TypeConverter GetConverter()
		{ return TypeDescriptor.GetConverter(this, true); }
		public EventDescriptor GetDefaultEvent()
		{ return TypeDescriptor.GetDefaultEvent(this, true); }
		public PropertyDescriptor GetDefaultProperty()
		{ return TypeDescriptor.GetDefaultProperty(this, true); }
		public object GetEditor(Type editorBaseType)
		{ return TypeDescriptor.GetEditor(this, editorBaseType, true); }
		public EventDescriptorCollection GetEvents(Attribute[] attributes)
		{ return TypeDescriptor.GetEvents(this, attributes, true); }
		public EventDescriptorCollection GetEvents()
		{ return TypeDescriptor.GetEvents(this, true); }
		public object GetPropertyOwner(PropertyDescriptor pd)
		{ return this; }
		/// <summary>
		/// Called to get the properties of this type. Returns properties with certain
		/// attributes. this restriction is not implemented here.
		/// </summary>
		/// <param name="attributes"></param>
		/// <returns></returns>
		public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
		{ return GetProperties(); }
		/// <summary>
		/// Called to get the properties of this type.
		/// </summary>
		/// <returns></returns>
		public PropertyDescriptorCollection GetProperties()
		{
			// Create a collection object to hold property descriptors
			PropertyDescriptorCollection pds = new PropertyDescriptorCollection(null);
			// Iterate the list 
			for (int i = 0; i < this.Items.Count; i++)
			{
				// Create a property descriptor for the item and add to the property descriptor collection
				<%=_className%>PropertyDescriptor pd = new <%=_className%>PropertyDescriptor(this, i);
				pds.Add(pd);
			}
			// return the property descriptor collection
			return pds;
		}
		#endregion<%
	}
	private void vlnPropertyDescriptorFKList1()
	{
%>
	#region Property Descriptor
	/// <summary>
	/// Summary description for CollectionPropertyDescriptor.
	/// </summary>
	public partial class <%=_className%>PropertyDescriptor : PropertyDescriptor
	{
		private <%=_subclassName%> _Item = null;
		public <%=_className%>PropertyDescriptor(<%=_className%> collection, int index):base("#" + index.ToString(), null)
		{
			_Item = collection.Items[index];
		}
		public override bool CanResetValue(object component)
		{ return true; }
		public override Type ComponentType
		{
			get { return _Item.GetType(); }
		}
		public override object GetValue(object component)
		{ return _Item; }
		public override bool IsReadOnly
		{
			get { return false; }
		}
		public override Type PropertyType
		{
			get { return _Item.GetType(); }
		}
		public override void ResetValue(object component)
		{ ;}
		public override bool ShouldSerializeValue(object component)
		{ return true; }
		public override void SetValue(object component, object value)
		{ /*_Item = value*/;}

		//public override AttributeCollection Attributes
		//{
		//  get
		//  {
		//    return new AttributeCollection(null);
		//  }
		//}
		//public override string DisplayName
		//{
		//  get { return this.collection.Items[index].ToString(); }
		//}
		//public override string Description
		//{
		//  get
		//  { return this.collection.Items[index].ToString(); }
		//}
		//public override string Name
		//{
		//  get { return "#" + index.ToString(); }
		//}
	}
	#endregion<%
	}
	private void vlnPropertyDescriptorFKList()
	{
%>
	#region Property Descriptor
	/// <summary>
	/// Summary description for CollectionPropertyDescriptor.
	/// </summary>
	public partial class <%=_className%>PropertyDescriptor : vlnListPropertyDescriptor
	{
		private <%=_subclassName%> Item { get { return (<%=_subclassName%>)_Item; } }
		public <%=_className%>PropertyDescriptor(<%=_className%> collection, int index) : base(collection, index) { ;}
	}
	#endregion<%
	}
	private void vlnListPropertyDescriptor()
	{
	%>
	public partial class vlnListPropertyDescriptor : PropertyDescriptor
	{
		protected object _Item = null;
		public vlnListPropertyDescriptor(System.Collections.IList collection, int index)
			: base("#" + index.ToString(), null)
		{ _Item = collection[index]; }
		public override bool CanResetValue(object component)
		{ return true; }
		public override Type ComponentType
		{ get { return _Item.GetType(); } }
		public override object GetValue(object component)
		{ return _Item; }
		public override bool IsReadOnly
		{ get { return false; } }
		public override Type PropertyType
		{ get { return _Item.GetType(); } }
		public override void ResetValue(object component)
		{ ;}
		public override bool ShouldSerializeValue(object component)
		{ return true; }
		public override void SetValue(object component, object value)
		{ /*_Item = value*/;}
		//public override AttributeCollection Attributes
		//{ get { return new AttributeCollection(null); } }
		public override string DisplayName
		{ get { return _Item.ToString(); } }
		public override string Description
		{ get { return _Item.ToString(); } }
		public override string Name
		{ get { return _Item.ToString(); } }
	} // Class<%
	}
	private void vlnConvertorFKList(string sDisplayName)
	{
%>
	#region Converter
	internal class <%=_className%>Converter : ExpandableObjectConverter
	{
		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destType)
		{
			if (destType == typeof(string) && value is <%=_className%>)
			{
				// Return department and department role separated by comma.
				return ((<%=_className%>)value).Items.Count.ToString() + " <%=sDisplayName%>";
			}
			return base.ConvertTo(context, culture, value, destType);
		}
	}
	#endregion<%
	}
	private void vlnBusinessMethodsFKItem(IForeignKey fk,string sAlias)
	{
		string sFkClassListName =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable ) + sAlias;
		string sFkClassName =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		string sPrimaryTable = ClassName( fk.PrimaryTable );
		string sPrimaryLocal = LocalName(sPrimaryTable);
%>
		#region Business Methods
		private string _ErrorMessage = string.Empty;
		public string ErrorMessage
		{
			get { return _ErrorMessage; }
		}<%
	// Foreign Key Table Fields
	string sKey="";
	string sep="";
	foreach(IColumn column in fk.ForeignTable.Columns)
	{
		if (!IsIn(column,fk.ForeignColumns))
		{				
			bool bReadOnly = column.IsInPrimaryKey || column.IsAutoKey || column.IsComputed;
			string sCheck=(IsRelObj(column)?FormatColumn("\r\n\t\t\t\tif ({!member} != null) {member} = {!member}.{!column};",column):null);
			vlnProperty(CSLAType( column ),MemberName(column)
				,PropertyName(column),InitializeValue( column ),GetDescription(column),bReadOnly || IsRelObj(column),column.IsInPrimaryKey,false,null,sCheck,null,null);
			vlnRelObjProperty(column,bReadOnly,false);
			if (column.IsInPrimaryKey){
				sKey+=sep+MemberName(column);
				sep=".ToString() + ";
			}
		}
		if ((sep != "") && (sKey.IndexOf(sep) > 0))
			sKey="(" + sKey + ".ToString()).GetHashCode()";
	}
	// Foreign Key Related Table Fields  // 20070220
	Hashtable dicAlias = new Hashtable();
	foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys)
	{
		if (pk.ForeignTable == fk.ForeignTable && pk.PrimaryTable != fk.PrimaryTable  && pk.PrimaryTable.Name != pk.ForeignTable.Name && ForeignRequired(pk))
		{
			//sAlias = GetAlias(dicAlias,pk.PrimaryTable);
			sAlias = GetAlias(pk);
			foreach(IColumn column in pk.PrimaryTable.Columns)
			{
				if ((!IsIn(column,pk.PrimaryColumns)) && (column.DataTypeName != "timestamp"))
				{		
					string sProp = ClassName(pk.PrimaryTable) + sAlias + "_" + PropertyName(column);
					vlnProperty(CSLAType( column ),MemberName(sProp)
						,sProp,InitializeValue( column ),GetDescription(column),true,column.IsInPrimaryKey,false,null,null,null,null);
				} 
			}
		}
	}
//	if (sKey == "")sKey="base.GetIdValue()";
%>
		// CSLATODO: Check <%=sFkClassName%>.GetIdValue to assure that the ID returned is unique
		/// <summary>
		/// Overrides Base GetIdValue - Used internally by CSLA to determine equality
		/// </summary>
		/// <returns>A Unique ID for the current <%=sFkClassName%></returns>
		protected override object GetIdValue()
		{
			return My<%=_className%>Unique; // Absolutely Unique ID
		}
		// CSLATODO: Replace base <%=sFkClassName%>.ToString function as necessary
		/// <summary>
		/// Overrides Base ToString
		/// </summary>
		/// <returns>A string representation of current <%=sFkClassName%></returns>
		//public override string ToString()
		//{
		//  return base.ToString();
		//}<%
		// IsValid and IsDirty
		string sExtDirty = "";
		string sExtValid = "";
		foreach(IColumn col in fk.ForeignTable.Columns)
		{
			string sColumn = RequiredRelatedColumn(col);
			if (sColumn != null){ // Let the Validation Rules handle IsDirty and IsValid - LazyLoad should be ignored.
				sExtDirty += string.Format(" || ({0} == null ? false : {0}.IsDirtyList(list))",MemberName(sColumn));
				sExtValid += string.Format(" && ({0} == null ? true : {0}.IsValidList(list))",MemberName(sColumn));
			}
		}
		//if (sExtDirty!="")
		vlnDirty(sExtDirty);
		vlnValid(sExtValid);
%>
		#endregion<%
	}
	private void vlnValidationRulesFKList(IForeignKey fk,string sAlias)
	{
		string sFkClassListName =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable ) + sAlias;
		string sFkClassName;
		if (fk.PrimaryTable == fk.ForeignTable)
			sFkClassName =  ClassName( fk.ForeignTable ) + sAlias;
		else
			sFkClassName =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		string sPrimaryTable = ClassName( fk.PrimaryTable );
		//string sPrimaryLocal = LocalName(sPrimaryTable);
		string sPrimaryLocal = LocalName(sFkClassName);
%>
		#region ValidationRules
		public IVEHasBrokenRules HasBrokenRules
		{<%=Debug("20070509.vlnValidationRulesFKList")%>
			get
			{
				IVEHasBrokenRules hasBrokenRules = null;
				foreach (<%=sFkClassName%> <%=sPrimaryLocal%> in this)
					if ((hasBrokenRules = <%=sPrimaryLocal%>.HasBrokenRules) != null) return hasBrokenRules;
				return hasBrokenRules;
			}
		}
		public BrokenRulesCollection BrokenRules
		{
			get
			{
				IVEHasBrokenRules hasBrokenRules = HasBrokenRules;
				return (hasBrokenRules != null ? hasBrokenRules.BrokenRules : null);
			}
		}
		#endregion<%
	}
	private void vlnValidationRulesFKItem(IForeignKey fk,string sAlias)
	{
		string sFkClassListName =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable ) + sAlias;
		string sFkClassName =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		string sPrimaryTable = ClassName( fk.PrimaryTable );
		string sPrimaryLocal = LocalName(sPrimaryTable);
%>
		#region ValidationRules
		[NonSerialized]
		private bool _CheckingBrokenRules = false;
		public IVEHasBrokenRules HasBrokenRules
		{<%=Debug("20070509.vlnValidationRulesFKItem")%>
			get
			{
				if (_CheckingBrokenRules) return null;
				if (BrokenRulesCollection.Count > 0) return this;
				try
				{
					_CheckingBrokenRules = true;
					IVEHasBrokenRules hasBrokenRules = null;<%
				vlnBrokenRuleObjects(fk);
%>
					return hasBrokenRules;
				}
				finally
				{
					_CheckingBrokenRules = false;
				}
			}
		}
		public BrokenRulesCollection BrokenRules
		{
			get
			{
				IVEHasBrokenRules hasBrokenRules = HasBrokenRules;
				if (this.Equals(hasBrokenRules)) return BrokenRulesCollection;
				return (hasBrokenRules != null ? hasBrokenRules.BrokenRules : null);
			}
		}
		protected override void AddBusinessRules()
		{<%
		foreach(IColumn column in fk.ForeignTable.Columns)
		{
			if (!(IsIn(column,fk.ForeignColumns) || column.IsInPrimaryKey || column.IsAutoKey || column.IsComputed))
			{				
				if (column.LanguageType=="string")
				{
					vlnAddRequired(column);
					if (column.CharacterMaxLength < 2147483647)
					vlnAddMaxLength(PropertyName(column),column.CharacterMaxLength);
				}
				if (CSLAType( column )=="SmartDate")
				{
					vlnAddRequired(column);
					string sName = PropertyName(column);
%>
			ValidationRules.AddRule<<%=_className%>>(<%=sName%>Valid, "<%=sName%>");<%
				}
				string sObjectRequired = RequiredRelatedColumn(column);
				if (sObjectRequired != null)
				{
%>
			ValidationRules.AddRule<<%=_className%>>(<%=sObjectRequired%>Required, "<%=sObjectRequired%>");<%
				}
			}
		}
%>
			// CSLATODO:  Add other validation rules
		}<%
		foreach(IColumn column in fk.ForeignTable.Columns)
		{
			if (!(IsIn(column,fk.ForeignColumns) || column.IsInPrimaryKey || column.IsAutoKey || column.IsComputed))
			{				
				if (CSLAType( column )=="SmartDate")
				{
					string sName = PropertyName(column);
					string sMember = MemberName(column);
%>
		private static bool <%=sName%>Valid(<%=_className%> target, Csla.Validation.RuleArgs e)
		{
			try
			{
				DateTime tmp = SmartDate.StringToDate(target.<%=sMember%>);
			}
			catch
			{
				e.Description = "Invalid Date";
				return false;
			}
			return true;
		}<%
				}
			}
		}
		foreach(IColumn col in fk.ForeignTable.Columns)
		{
			string sColumn = RequiredRelatedColumn(col);
			if (sColumn != null){ // Let the Validation Rules handle required fields
				string sMemberRaw = MemberName(col);
				string sMemberReq = MemberName(sColumn);
%>
		private static bool <%=sColumn%>Required(<%=_className%> target, Csla.Validation.RuleArgs e)
		{
			if (target.<%=sMemberRaw%> == 0 && target.<%=sMemberReq%> == null) // Required field missing
			{
				e.Description = "Required";
				return false;
			}
			return true;
		}<%
				
			}
		}

%>
		// Sample data comparison validation rule
		//private bool StartDateGTEndDate(object target, Csla.Validation.RuleArgs e)
		//{
		//	if (_started > _ended)
		//	{
		//		e.Description = "Start date can't be after end date";
		//		return false;
		//	}
		//	else
		//		return true;
		//}
		#endregion<%
	}
	private void vlnAuthorizationRulesFKItem(IForeignKey fk,string sAlias)
	{
		string sFkClassListName =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable ) + sAlias;
		string sFkClassName =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		string sPrimaryTable = ClassName( fk.PrimaryTable );
		string sPrimaryLocal = LocalName(sPrimaryTable);
%>
		#region Authorization Rules
		protected override void AddAuthorizationRules()
		{
			//CSLATODO: Who can read/write which fields<%
		foreach(IColumn column in fk.ForeignTable.Columns)
		{
			if (!(IsIn(column,fk.ForeignColumns)) && column.DataTypeName != "timestamp")
			{				
%>
			//AuthorizationRules.AllowRead(<%=PropertyName(column)%>, "<Role(s)>");<%			
				if (!(column.IsInPrimaryKey || column.IsAutoKey || column.IsComputed))
				{
%>
			//AuthorizationRules.AllowWrite(<%=PropertyName(column)%>, "<Role(s)>");<%			
				}
			}
		}
%>
		}
		public static bool CanAddObject()
		{
			// CSLATODO: Can Add Authorization
			//return Csla.ApplicationContext.User.IsInRole("ProjectManager");
			return true;
		}
		public static bool CanGetObject()
		{
			// CSLATODO: CanGet Authorization
			return true;
		}
		public static bool CanDeleteObject()
		{
			// CSLATODO: CanDelete Authorization
			//bool result = false;
			//if (Csla.ApplicationContext.User.IsInRole("ProjectManager"))result = true;
			//if (Csla.ApplicationContext.User.IsInRole("Administrator"))result = true;
			//return result;
			return true;
		}
		public static bool CanEditObject()
		{
			// CSLATODO: CanEdit Authorization
			//return Csla.ApplicationContext.User.IsInRole("ProjectManager");
			return true;
		}
		#endregion<%
	}
	private void vlnFactoryMethodsFKItem(IForeignKey fk,string sAlias)
	{
		string sFkClassListName =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable ) + sAlias;
		string sFkClassName =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		string sPrimaryTable = ClassName( fk.PrimaryTable );
		string sPrimaryLocal = LocalName(sPrimaryTable);
		string sKeysTypes="";
		string sKeys="";
		string sValues="";
		string sValues2="";
		string sep="";
		string sInit="";
		string sep2="";
		Hashtable dicAlias = new Hashtable();
		ArrayList pks = new ArrayList();
		foreach(IColumn column in fk.ForeignTable.Columns)
		{
			if (!IsIn(column,fk.ForeignColumns))
			{				
				if (IsRequired(column) && !column.IsComputed && !column.IsAutoKey)
				{
					sKeysTypes+=sep+FormatColumn("{!type} {!local}",column);
					sKeys+=sep+FormatColumn("{!local}",column);
					if (IsRelObj(column))
						sValues+=sep + FormatColumn("{!local}",column); // 20070301						
					else
						sValues+=sep+RelatedObject(fk,column);
					if (IsRelObj(column))
						sValues2+=sep + FormatColumn("{!type} {!local}",column); // 20070301						
					else
						sValues2+=sep + RelatedObjectType2(fk,column); // 20070301
					foreach(IForeignKey pk in column.ForeignKeys)
						if (!pks.Contains(pk))
						{
							pks.Add(pk.Name);
							//sValues2+=" /* " + pk.Name + " */ ";
						}
					sep=", ";
					if (!column.IsInForeignKey || IsRelObj(column)){
						//if (CSLAType(column)=="SmartDate")
						//	sInit+=sep2 + FormatColumn("\t\t{member} = new SmartDate({local});",column);
						//else
						if (IsRelObj(column))
							sInit+=sep2 + FormatColumn("\t\t\t{!member} = {!local};",column);							
						else
							sInit+=sep2 + FormatColumn("\t\t\t{member} = {local};",column);
						sep2="\r\n";
					}
					else
					{
						IForeignKey pk = column.ForeignKeys[0];
						if (pk == FKParentFK(column.Table))
						{
							IColumn colf = RelatedColumnF(column,pk);
							if (colf != null){
								sInit+=sep2 + FormatColumn("\t\t\t{member} = ",column) + FormatColumn("{rmember};",colf);
								sep2="\r\n";
							}
						}
					}
				}
			}
		}
		// Foreign Key Related Table Fields
		//Hashtable dicAlias = new Hashtable();
		foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys)
		{
			if (pks.Contains(pk.Name) && pk.ForeignTable == fk.ForeignTable && pk.PrimaryTable.Name != pk.ForeignTable.Name && pk.Name != fk.Name && ForeignRequired(pk))
			{
				//sAlias = GetAlias(dicAlias,pk.PrimaryTable);
				sAlias = GetNewAlias(fk,pk);
				foreach(IColumn column in pk.PrimaryTable.Columns)
				{
					IColumn col = RelatedColumn(column,pk);
					col =col.Table.Columns[col.Name];
					if (!IsRelObj(col))
					{
						string sProp = ClassName(pk.PrimaryTable) + sAlias + "_" + PropertyName(column);
						string sLocal = LocalName(ClassName(pk.PrimaryTable))+ sAlias;
						string sMember = MemberName(sProp);
						if (IsIn(column,pk.PrimaryColumns))
						{
							sInit+=sep2 + "\t\t\t" + MemberName(RelatedColumn(column,pk)) + " = " + sLocal + "." + PropertyName(column) + ";";
							sep2="\r\n";
						}
						else
						{
							if (pk.PrimaryTable != fk.PrimaryTable)
							{
								if (column.DataTypeName != "timestamp"){
									if (CSLAType(column)=="SmartDate")
										sInit+=sep2 + "\t\t\t" + sMember + " = new SmartDate(" + sLocal + "." + PropertyName(column) + ");";
									else
										sInit+=sep2 + "\t\t\t" + sMember + " = " + sLocal + "." + PropertyName(column) + ";";
									sep2="\r\n";
								}
							} 
						}
					}
				}
			}
			else
			{
				// WriteLine("pk={0} f={1} p={2}",pk.Name,pk.ForeignTable.Name,pk.PrimaryTable.Name);
			}
		}
%>
		#region Factory Methods
		public int CurrentEditLevel
		{ get { return EditLevel; } }
		private static int _<%=_className%>Unique = 0;
		private static int <%=_className%>Unique
		{ get { return ++_<%=_className%>Unique; } }
		private int _My<%=_className%>Unique = <%=_className%>Unique;
		public int My<%=_className%>Unique // Absolutely Unique ID - Editable FK
		{ get { return _My<%=_className%>Unique; } }
		internal static <%=sFkClassName%> New(<%=sKeysTypes%>)
		{
			return new <%=sFkClassName%>(<%=sValues%>);
		}
		internal static <%=sFkClassName%> Get(SafeDataReader dr)
		{
			return new <%=sFkClassName%>(dr);
		}
		public <%=sFkClassName%>()
		{
			MarkAsChild();
<%=FormatColumns("{member} = {class}.Next{prop};",AutoKey(fk),"\r\n","\t\t\t")%>
<%=FormatColumns("{member} = " + extMName + ".Default{prop};",HasDefaults(fk),"\r\n","\t\t\t")%>
			ValidationRules.CheckRules();
		}<%
	if (sValues2 != "") {
		//if (sInit=="")sInit = "// No Initialization";
		//else sInit = "// Initialization\r\n" + sInit;
%>
		private <%=sFkClassName%>(<%=sValues2%>)
		{
			MarkAsChild();
			// CSLATODO: Add any initialization & defaults
<%=FormatColumns("\t\t\t{member} = {class}.Next{prop};\r\n",AutoKey(fk),"","")%><%=FormatColumns("{member} = " + extMName + ".Default{prop};",HasDefaults(fk),"\r\n","\t\t\t")%>
<%=sInit%>
			ValidationRules.CheckRules();
		}<%
		}
%>
		internal <%=sFkClassName%>(SafeDataReader dr)
		{
			MarkAsChild();
			Fetch(dr);
		}
		private bool _Disposed = false;
		private static int _CountCreated = 0;
		private static int _CountDisposed = 0;
		private static int _CountFinalized = 0;
		private static int IncrementCountCreated
		{ get { return ++_CountCreated; } }
		private int _CountWhenCreated = IncrementCountCreated;
		public static int CountCreated
		{ get { return _CountCreated; } }
		public static int CountNotDisposed
		{ get { return _CountCreated - _CountDisposed; } }
		public static int CountNotFinalized
		{ get { return _CountCreated - _CountFinalized; } }
		~<%=sFkClassName%>()
		{
			_CountFinalized++;
		}
		public void Dispose()
		{
			if (_Disposed) return;
			_CountDisposed++;
			_Disposed = true;
		}
		#endregion<%
	}
	private void vlnDataAccessPortalFKItem(IForeignKey fk,string sAlias)
	{
		string sFkClassListName =  ClassName( fk.PrimaryTable ) + ClassesName( fk.ForeignTable ) + sAlias;
		string sFkClassName =  ClassName( fk.PrimaryTable ) + ClassName( fk.ForeignTable ) + sAlias;
		string sPrimaryTable = ClassName( fk.PrimaryTable );
		string sPrimaryLocal = LocalName(sPrimaryTable);
		IColumn colf1 = fk.ForeignColumns[0];
		colf1=colf1.Table.Columns[colf1.Name];
		sPrimaryLocal = FormatColumn("{!local}",colf1);
		string sClassName = ClassName( fk.ForeignTable );
		//string sKeysTypes="";
		//string sKeys="";
		//string sValues="";
		//string sValues2="";
		string sepi="";
		string sepu="";
		string sepd="";
		string sepr="";
		string sRead="";
		string sInsert="";
		string sUpdate="";
		string sDelete="";
		string sTimestamp="";
				try
				{
					foreach(IColumn column in fk.ForeignTable.Columns)
					{
						if (column.DataTypeName=="timestamp")
							sTimestamp=FormatColumn("{member} = ",column);
						if (!IsIn(column,fk.ForeignColumns))
						{				
							sRead+=sepr+FormatColumn(dicRead,column,"\t\t\t\t","");
							sepr="\r\n";
							string sRefI = ParentRef(column);
							string sRefU = ParentRefU2(column);
							if (sRefI==null)
							{
								if (column.IsComputed || column.IsAutoKey)
									sRefU = sRefI = FormatColumn("ref {?dbprefix}{member}{?dbsuff}",column);
								else
									//if (column.IsInPrimaryKey) // 20070326
									//	sRef=FormatColumn("{?dbprefix}{!membercolumn}{?dbsuff}",column);// 20070323
									//else
									if (FormatColumn("{!type}",column)==ClassName(fk.ForeignTable))
									{
										sRefI = FormatColumn("{?dbprefix}{!membercolumn}{?dbsuff}",column);// 20070326
										sRefU = FormatColumn("{?dbprefix}{member}{?dbsuff}",column);// 20070326
									}
									else
									{
										sRefI=FormatColumn("{?dbprefix}{!member}{?dbsuff}",column);// 20070326
										sRefU=FormatColumn("{?dbprefix}{member}{?dbsuff}",column);// 20070326
								}
							}
							sUpdate+=sepu + sRefU;
							sepu=", ";
							if (!column.IsComputed)// && !column.IsAutoKey
							{
								sInsert+=sepi+sRefI;
								sepi=", ";
							}
						}
						else
						{
							string sRefI;
							string sRefU;
							if (IsRelObj(column))
							{
								sRefI = FormatColumn("{?dbprefix}{!local}{?dbsuff}",column);
								string sType = FormatColumn("{ctype}",column);
								if(sType.Contains("?"))
									sRefU = FormatColumn("{?dbprefix}{!local}{?dbsuff} != null ? ({ctype}) {?dbprefix}{!local}{?dbsuff}.{?dbprefix}{prop}{?dbsuff} : ({ctype}) null",column);
								else
									sRefU = FormatColumn("{?dbprefix}{!localcolumn}{?dbsuff}",column);
							}
							else
								sRefI = sRefU = FormatColumn("{?dbprefix}{rmember}{?dbsuff}",RelatedColumn(column,fk));
							sInsert+=sepi + sRefI;
							sUpdate+=sepu + sRefU;
							sepi=", ";
							sepu=", ";
							//sepd=", ";
						}
					}
					foreach(IColumn column in fk.ForeignTable.PrimaryKeys)
					{
						if (IsIn(column,fk.ForeignColumns))
							sDelete+=sepd+FormatColumn("{!localcolumn}",column);
							//sDelete+=sepd+FormatColumn("{rmember}",RelatedColumn(column,fk));
						else
							sDelete+=sepd+FormatColumn("{member}",column);
						sepd=", ";
					}
				}
				catch(Exception ex)
				{
					output.write("\r\n>>>ERROR>>>> " + ex.Message);
				}
		// Foreign Key Related Table Fields
		Hashtable dicAlias = new Hashtable();
		foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys)
		{
			if (pk.ForeignTable == fk.ForeignTable && pk.PrimaryTable != fk.PrimaryTable  && pk.PrimaryTable != pk.ForeignTable && ForeignRequired(pk))
			{
				//sAlias = GetAlias(dicAlias,pk.PrimaryTable);
				sAlias = GetAlias(pk);
				//foreach(IColumn col in pk.PrimaryColumns)
				//{
				//}
				foreach(IColumn column in pk.PrimaryTable.Columns)
				{
					if (!IsIn(column,pk.PrimaryColumns) && column.DataTypeName != "timestamp" && !column.IsInPrimaryKey)
					{				
						sRead+=sepr+FormatColumn(dicRead,column,"\t\t\t\t",sAlias);
						sepr="\r\n";
					}
				}
			}
		}
%>
		#region Data Access Portal
		private void Fetch(SafeDataReader dr)
		{
			<%=_databaseLogDebug%>("[{0}] <%=_subclassName%>.FetchDR", GetHashCode());
			try
			{
<%=sRead%>
			}
			catch (Exception ex) // FKItem Fetch
			{
				<%=_databaseLogError%>("<%=_subclassName%>.FetchDR", ex);
				throw new DbCslaException("<%=_subclassName%>.Fetch", ex);
			}
			MarkOld();
		}
		internal void Insert(<%=sPrimaryTable%> <%=sPrimaryLocal%>)
		{
			// if we're not dirty then don't update the database
			if (!this.IsDirty) return;
			SqlConnection cn = (SqlConnection)ApplicationContext.LocalContext["cn"];
			<%=sTimestamp%><%=sClassName%>.Add(cn, <%=sInsert%>);
			MarkOld();
		}
		internal void Update(<%=sPrimaryTable%> <%=sPrimaryLocal%>)<%=Debug("// 20071023.4 Update")%>
		{
			// if we're not dirty then don't update the database
			if (!this.IsDirty) return;
			SqlConnection cn = (SqlConnection)ApplicationContext.LocalContext["cn"];
			<%=sTimestamp%><%=sClassName%>.Update(cn, <%=sUpdate%>);
			MarkOld();
		}
		internal void DeleteSelf(<%=sPrimaryTable%> <%=sPrimaryLocal%>)
		{
			// if we're not dirty then don't update the database
			if (!this.IsDirty) return;
			// if we're new then don't update the database
			if (this.IsNew) return;
			SqlConnection cn = (SqlConnection)ApplicationContext.LocalContext["cn"];
			<%=sClassName%>.Remove(cn, <%=sDelete%>);
			MarkNew();
		}
		#endregion<%
	}
	private void vlnConvertorFKItem()
	{
%>
	#region Converter
	internal class <%=_className%>Converter : ExpandableObjectConverter
	{
		public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destType)
		{
			if (destType == typeof(string) && value is <%=_className%>)
			{
				// Return the ToString value
				return ((<%=_className%>)value).ToString();
			}
			return base.ConvertTo(context, culture, value, destType);
		}
	}
	#endregion<%
	}
	private void vlnFactoryMethodsInfoList(IColumns columns)
	{
		string sMember = MemberName(_className);
%>
		#region Factory Methods
		public static <%=_className%> <%=sMember%> = null;
		/// <summary>
		/// Return a list of all <%=_subclassName%>.
		/// </summary>
		public static <%=_className%> Get()
		{
			try
			{
				if (<%=sMember%> != null)
					return <%=sMember%>;
				<%=_className%> tmp = DataPortal.Fetch<<%=_className%>>();
				<%=_subclassName%>.AddList(tmp);
				tmp.AddEvents();
				<%=sMember%> = tmp;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=_className%>.Get", ex);
			}
		}
		/// <summary>
		/// Reset the list of all <%=_subclassName%>.
		/// </summary>
		public static void Reset()
		{
			<%=sMember%> = null;
		}<%
// ForeignKeys - List Foreign Keys - May want to create stored procedures
%>
		// CSLATODO: Add alternative gets - 
		//public static <%=_className%> Get(<criteria>)
		//{
		//	try
		//	{
		//  	return DataPortal.Fetch<<%=_className%>>(new FilteredCriteria(<criteria>));
		//	}
		//	catch (Exception ex)
		//	{
		//		throw new DbCslaException("Error on <%=_className%>.Get", ex);
		//	}
		//}<%
		ProcessFKAlias(_workingTable,new ProcessFK(FKGet));
//		ArrayList lstByNames = new ArrayList();
//		foreach(IForeignKey FK in _workingTable.ForeignKeys)
//		{
//			if (FK.ForeignTable == _workingTable)
//			{
//				if (!lstByNames.Contains(FK.PrimaryTable.Name))
//				{
//					FKGet(FK);
//					lstByNames.Add(FK.PrimaryTable.Name);
//				}
//			}
//		}	
%>
		private <%=_className%>()
		{ /* require use of factory methods */ }
		#endregion<%
	}
	private void FKGet(IForeignKey FK,string sAlias)
	{
		//string sBy = ClassName(FK.PrimaryTable) + sAlias;
		//string sKeyTypes = FormatColumns("{ctype} {local}",FK.PrimaryTable.PrimaryKeys,",","");
		//string sKeys = FormatColumns("{local}",FK.PrimaryTable.PrimaryKeys,",","");
		string sBy = FormatColumns("{name}",FK.ForeignColumns,"_","");
		string sBy2 = "By" + sBy;
		if (FK.PrimaryTable == FK.ForeignTable)sBy2=ChildrenName(FK);
		string sKeyTypes = FormatColumns("{ctype} {local}",FK.ForeignColumns,",","");
		string sKeys = FormatColumns("{local}",FK.ForeignColumns,",","");
%>
		public static <%=_className%> Get<%=sBy2%>(<%=sKeyTypes%>)
		{
			try
			{
				<%=_className%> tmp = DataPortal.Fetch<<%=_className%>>(new <%=sBy%>Criteria(<%=sKeys%>));
				<%=_subclassName%>.AddList(tmp);
				tmp.AddEvents();
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=_className%>.Get<%=sBy2%>", ex);
			}
		}<%
	}
	private void vlnDataAccessPortalInfoList(IColumns columns)
	{ 
%>
		#region Data Access Portal
		private void DataPortal_Fetch()
		{
			this.RaiseListChangedEvents = false;
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.DataPortal_Fetch", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.<%=_dbConnection%>_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "get<%=ClassesName(_workingTable)%>";
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							IsReadOnly = false;
							while (dr.Read()) this.Add(new <%=_subclassName%>(dr));
							IsReadOnly = true;
						}
					}
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.DataPortal_Fetch", ex);
				throw new DbCslaException("<%=_className%>.DataPortal_Fetch", ex);
			}
			this.RaiseListChangedEvents = true;
		}<%
		ProcessFKAlias(_workingTable,new ProcessFK(FKFetch));
//		ArrayList lstTableNames = new ArrayList();
//		foreach(IForeignKey FK in _workingTable.ForeignKeys)
//		{
//			if (FK.ForeignTable == _workingTable)
//			{
//				if (!lstTableNames.Contains(FK.PrimaryTable.Name))
//				{
//					FKFetch(FK);
//					lstTableNames.Add(FK.PrimaryTable.Name);
//				}
//			}
//		}
%>
		#endregion<%
	}
	private void FKFetch(IForeignKey FK,string sAlias)
	{
		string sClassF = ClassName(FK.ForeignTable);
		//string sClassP = ClassName(FK.PrimaryTable)+sAlias;
		//string sBy = ForeignKeyName(FK);
		//string sKeyTypes = FormatColumns("{ctype} {local}",FK.PrimaryTable.PrimaryKeys,",","");
		string sClassP = FormatColumns("{name}",FK.ForeignColumns,"_","");
		string sBy = ClassesName(_workingTable) + "By" + FormatColumns("{name}",FK.ForeignColumns,"_","");
		if (FK.ForeignTable == FK.PrimaryTable)sBy = ChildName(FK) + ClassesName(_workingTable);
		string sKeyTypes = FormatColumns("{ctype} {local}",FK.ForeignColumns,",","");
		//string sKeys = FormatColumns("{local}",FK.ForeignColumns,",","");
%>
		[Serializable()]
		private class <%=sClassP%>Criteria
		{
			public <%=sClassP%>Criteria(<%=sKeyTypes%>)
			{
<%=FormatColumns("{member} = {local};",FK.ForeignColumns,"\r\n","\t\t\t\t")%>
			}<%
		foreach(IColumn c in FK.ForeignColumns)
		{
			string sMember=FormatColumn("{member}",c);
			string sProp=FormatColumn("{prop}",c);
			string sType=FormatColumn("{ctype}",c);
%>
			private <%=sType%> <%=sMember%>;
			public <%=sType%> <%=sProp%>
			{
				get { return <%=sMember%>; }
				set { <%=sMember%> = value; }
			}<%
		}
%>
		}
		private void DataPortal_Fetch(<%=sClassP%>Criteria criteria)
		{
			this.RaiseListChangedEvents = false;
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.DataPortal_Fetch<%=sClassP%>", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.<%=_dbConnection%>_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "get<%=sBy%>";
						<%=FormatColumns("{ifLogic@}cm.Parameters.AddWithValue(\"{@}\", " + "criteria.{prop});",FK.ForeignColumns,"\r\n\t\t\t","")%>
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							IsReadOnly = false;
							while (dr.Read()) this.Add(new <%=_subclassName%>(dr));
							IsReadOnly = true;
						}
					}
				}
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.DataPortal_Fetch<%=sClassP%>", ex);
				throw new DbCslaException("<%=_className%>.DataPortal_Fetch", ex);
			}
			this.RaiseListChangedEvents = true;
		}<%
	}
	private void vlnRelObjProperty(IColumn column,bool bReadOnly,bool bInfo)
	{
		if (IsRelObj(column))
		{
			string sProp=RelObjProp(column);
			string sMember=MemberName(sProp);
			string sCheck=FormatColumn("\r\n\t\t\t\tif ({!member} == null && {member} != {!empty}) {!member} = {!type}" + (bInfo?"Info":"") + ".Get({!typecast}{member});",column);
			string sCheck2=null;
			string sCheck3=null;
			if (column.IsNullable)
			{
				sCheck2=FormatColumn("\r\n\t\t\t\t\t{member} = (value == null ? null : ({ctype})value.{!column});",column);
				sCheck3=FormatColumn("({!member} == null ? {member} : ({ctype}){!member}.{!column}) != (value == null ? null : ({ctype})value.{!column})",column);
			}
			else
			{
				sCheck2=FormatColumn("\r\n\t\t\t\t\t{member} = value.{!column};// Update underlying data field",column);
				sCheck3=FormatColumn("{!member} != value",column);
			}
			vlnProperty(RelObjType( column ) + (bInfo?"Info":"") ,sMember
				,sProp,";"+DebugLine("20070501.4"),"",bReadOnly,column.IsInPrimaryKey,false,null,sCheck,sCheck2,sCheck3);
			//if (sProp.StartsWith("My"))_refreshMine += string.Format("\t\t\t{0} = null;\r\n",sMember);
			//if (sProp.StartsWith("My"))AddRefreshMine(sMember);
		}
	}
	private void AddRefreshMine(string sMember)
	{
		_refreshMine += string.Format("//RHM Removed 20090724 - Duplicates function of code above.\r\n",sMember);
		_refreshMine += string.Format("//                     - Dispose caused error when a new step was added.\r\n",sMember);
		_refreshMine += string.Format("//                     - Resequence of transitions did not work properly.\r\n",sMember);
		_refreshMine += string.Format("//\t\t\tif({0} != null)\r\n",sMember);
		_refreshMine += string.Format("//\t\t\t{{\r\n");
		_refreshMine += string.Format("//\t\t\t\t{0}.Dispose();// Dispose related value\r\n",sMember);
		_refreshMine += string.Format("//\t\t\t\t{0} = null;// Reset related value\r\n",sMember);
		_refreshMine += string.Format("//\t\t\t}}\r\n");
	}
	private void vlnBusinessMethodsInfo(IColumns columns)
	{
		_refreshMine="";
//		string sMember = MemberName(sEditable);
//		string sLocal = LocalName(sEditable);
//		string sPKeys = FormatColumns(sLocal + ".{prop}",_workingTable.PrimaryKeys,", ","");
%>
		#region Business Methods
		private string _ErrorMessage = string.Empty;
		public string ErrorMessage
		{
			get { return _ErrorMessage; }
		}
		protected <%=ClassName( _workingTable )%> _Editable;
		private IVEHasBrokenRules HasBrokenRules
		{
			get
			{
				IVEHasBrokenRules hasBrokenRules = null;
				if (_Editable != null)
					hasBrokenRules = _Editable.HasBrokenRules;
				return hasBrokenRules;
			}
		}<%
		//vlnInfoParent(_workingTable);//20070208
		foreach(IColumn column in ExcludedColumns(columns,new Filter(Computed)))
		{
			string sCheck=(IsRelObj(column)?FormatColumn("\r\n\t\t\t\tif ({!member} != null) {member} = {!member}.{!column};",column):null);
			vlnProperty(CSLAType( column ),MemberName(column)
				,PropertyName(column),InitializeValue( column ),GetDescription(column),true,column.IsInPrimaryKey,false,null,sCheck,null,null);
			vlnRelObjProperty(column,true,true);
		}
		Hashtable dicAlias = new Hashtable();
		foreach(IForeignKey FK in _workingTable.ForeignKeys)
		{
			if (FK.PrimaryTable == _workingTable)
			{
				//string sAlias = GetAlias(dicAlias,FK.ForeignTable);
				string sAlias = GetAlias(FK);
				string sClass = FKClassName(FK);
				string sClasses = FKClassesName(FK);
				if (!OneToOne(FK))
					FKPropertyList(ClassName(FK.ForeignTable),sClasses,FK,sAlias);
				else
				{
					vlnProperty("int",MemberName(sClass) + sAlias + "Count" ,sClass + sAlias + "Count", " = 0;",
						"Count of " + sClasses + " for this " + ClassName(_workingTable),true,false,false,null,null,null,null);
					FKPropertyInfo(ClassName(FK.ForeignTable),sClasses,FK,sAlias);
					// This line was added to reset the count if the Content object was changed
					_refreshMine += string.Format("\t\t\t{0} = -1;// Reset Count\r\n",MemberName(sClass) + sAlias + "Count");
				}
			}
		}

		vlnToString(columns);
		vlnGetIDValue(_workingTable.PrimaryKeys);		
%>
		#endregion<%
	}
	private void FKPropertyList(string sClass,string sClasses,IForeignKey FK,string sAlias)
	{
		string sKeys = FormatColumns("{member}",FK.PrimaryColumns,",","");
		string sMember = MemberName(sClasses) + sAlias;
		string sCountMember = MemberName(SingularName(sClasses)) + sAlias + "Count";
		string sBy = FKBy(FK);
		string sProp = sClasses + sAlias;
		string sParent = SingularName(FK.PrimaryTable.Name);
		string sChild = SingularName(FK.ForeignTable.Name);
		//_refreshMine += string.Format("\t\t\t{0} = null;\r\n",sMember);
%>
		private int <%=sCountMember%> = 0;
		/// <summary>
		/// Count of <%=sMember.Substring(1)%> for this <%=sParent%>
		/// </summary>
		public int <%=sCountMember.Substring(1)%>
		{
			[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
			get
			{
				CanReadProperty("<%=sCountMember.Substring(1)%>", true);
				if (<%=sCountMember%> < 0)
					<%=sCountMember%> = <%=sProp%>.Count;
				return <%=sCountMember%>;
			}
		}
		private <%=sClass%>InfoList <%=sMember%> = null;
		[TypeConverter(typeof(<%=sClass%>InfoListConverter))]
		public <%=sClass%>InfoList <%=sProp%>
		{<%=DebugLine("20070427.5")%>
			[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
			get
			{
				CanReadProperty("<%=sProp%>", true);
				if (<%=sCountMember%> < 0 || (<%=sCountMember%> > 0 && <%=sMember%> == null))
					<%=sMember%> = <%=sClass%>InfoList.Get<%=sBy%>(<%=sKeys%>);
				if (<%=sCountMember%> < 0)
					<%=sCountMember%> = <%=sMember%>.Count;
				return <%=sMember%>;
			}
		}
		public void Refresh<%=sProp%>()
		{<%=DebugLine("20080430.3")%>
			<%=sCountMember%> = -1;
			ConvertListToDictionary();
			if (_CacheByPrimaryKey.ContainsKey(<%=sKeys%>.ToString()))
				foreach (<%=_className%> tmp in _CacheByPrimaryKey[<%=sKeys%>.ToString()])
					tmp.<%=sCountMember%> = -1; // This will cause the data to be requeried
		}<%
	}
	private void FKPropertyInfo(string sClass,string sClasses,IForeignKey FK,string sAlias)
	{
		string sKeys = FormatColumns("{member}",FK.PrimaryColumns,",","");
		string sMember = MemberName("My" + sClass) + sAlias;
		string sCountMember = MemberName(SingularName(sClasses)) + sAlias + "Count";
		string sBy = FKBy(FK);
		string sProp = "My" + sClass + sAlias;
		//_refreshMine += string.Format("\t\t\t{0} = null;// Reset related value\r\n",sMember);
		//AddRefreshMine(sMember);
%>
		private <%=sClass%>Info <%=sMember%> = null;
		[TypeConverter(typeof(<%=sClass%>InfoConverter))]
		public <%=sClass%>Info <%=sProp%>
		{<%=DebugLine("20070427.6")%>
			[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
			get
			{
				CanReadProperty("<%=sProp%>", true);
				if (<%=sCountMember%> != 0 && <%=sMember%> == null)
				{
					<%=sMember%> = <%=sClass%>Info.Get(<%=sKeys%>);
					<%=sCountMember%> = <%=sMember%> == null ? 0 : 1;
				}
				return <%=sMember%>;
			}
		}<%
	}
	private void vlnFactoryMethodsInfo(IColumns columns)
	{
		string sKeys = FormatColumns("{local}",_workingTable.PrimaryKeys,", ","");
		string sKeyTypes = FormatColumns("{ctype} {local}",_workingTable.PrimaryKeys,", ","");
		string sEditable = ClassName(_workingTable.Name);
		string sEdMember = MemberName(sEditable);
		string sEdLocal = LocalName(sEditable);
		string sPKeys = FormatColumns("{member}",_workingTable.PrimaryKeys,", ","");
		string sRefKeys = FormatColumns("{prop}.ToString()",_workingTable.PrimaryKeys," + \"_\" + ","");;//20070215
		string sTmpKeys = FormatColumns("tmp.{prop}",_workingTable.PrimaryKeys,", ","");
		string sTRefKeys = FormatColumns("tmp.{prop}.ToString()",_workingTable.PrimaryKeys," + \"_\" + ","");;//20070215
%>
		#region Factory Methods
		private static int _<%=_className%>Unique = 0;
		private static int <%=_className%>Unique
		{ get { return ++_<%=_className%>Unique; } }
		private int _My<%=_className%>Unique = <%=_className%>Unique;
		public int My<%=_className%>Unique // Absolutely Unique ID - Info
		{ get { return _My<%=_className%>Unique; } }
		protected <%=_className%>()
		{/* require use of factory methods */
			AddToCache(this);
		}
		private bool _Disposed = false;
		private static int _CountCreated = 0;
		private static int _CountDisposed = 0;
		private static int _CountFinalized = 0;
		private static int IncrementCountCreated
		{ get { return ++_CountCreated; } }
		private int _CountWhenCreated = IncrementCountCreated;
		public static int CountCreated
		{ get { return _CountCreated; } }
		public static int CountNotDisposed
		{ get { return _CountCreated - _CountDisposed; } }
		public static int CountNotFinalized
		{ get { return _CountCreated - _CountFinalized; } }
		~<%=_className%>()
		{
			_CountFinalized++;
		}
		public void Dispose()
		{
			if (_Disposed) return;
			_CountDisposed++;
			_Disposed = true;
			RemoveFromCache(this);
			if (!_CacheByPrimaryKey.ContainsKey(<%=sRefKeys%>)) return;
			List<<%=_className%>> list<%=_className%> = _CacheByPrimaryKey[<%=sRefKeys%>]; // Get the list of items
			while (list<%=_className%>.Contains(this)) list<%=_className%>.Remove(this); // Remove the item from the list
			if (list<%=_className%>.Count == 0) // If there are no items left in the list
				_CacheByPrimaryKey.Remove(<%=sRefKeys%>); // remove the list
		}
		public virtual <%=ClassName( _workingTable )%> Get()
		{<%=DebugLine("20070502.1")%>
			return _Editable = <%=sEditable%>.Get(<%=sPKeys%>);
		}
		public static void Refresh(<%=ClassName( _workingTable )%> tmp)
		{
			string key = <%=sTRefKeys%>;
			ConvertListToDictionary();
			if (_CacheByPrimaryKey.ContainsKey(key))
				foreach (<%=_className%> tmpInfo in _CacheByPrimaryKey[key])
					tmpInfo.RefreshFields(tmp);
		}
		protected virtual void RefreshFields(<%=ClassName( _workingTable )%> tmp)
		{<%=DebugLine("20080430.1")%><%
			foreach(IColumn col in Updatable(_workingTable))
				UpdateInfoFromEdit(col);
%>
			<%=MemberName(_className)%>Extension.Refresh(this);
<%=_refreshMine%>			OnChange();// raise an event
		}<%
		Hashtable dicAlias = new Hashtable();		// 20070216
		foreach(IForeignKey fk in _workingTable.ForeignKeys)
		{
			if (_workingTable != fk.PrimaryTable  && !IsPrimaryKey(fk)) //20070220
			{
				//string sClass=ClassName(fk.PrimaryTable)+ClassName(fk.ForeignTable)+GetAlias(dicAlias,fk.PrimaryTable);
				string sClass=ClassName(fk.PrimaryTable)+ClassName(fk.ForeignTable)+GetAlias(fk);
				// 20070326 - Need to add an object reference
				string sPrefix = "";
				string sTmpKeys2 = sTmpKeys;
				string sTmpKeyString = sTRefKeys;
				if (ForeignPrimary(fk))
				{
					string sOther = ClassName(fk.PrimaryTable);
					sPrefix = ClassName(fk.PrimaryTable) + " my" + ClassName(fk.PrimaryTable) + ", ";
					string ssep="";
					string ssepstr="";
					sTmpKeys2="";
					sTmpKeyString = "";				
					foreach(IColumn col in _workingTable.PrimaryKeys)
					{
						//WriteLine("\r\n//!type = '{0}', sOther = '{1}', Col.Name = '{2}'", FormatColumn("{!type}",col), sOther, col.Name);
						if (FormatColumn("{!type}",col)==sOther)
						{
							sTmpKeys2 += ssep + FormatColumn("{!localcolumn}",col);
							sTmpKeyString += ssepstr + FormatColumn("{!localcolumn}",col) + ".ToString()";
						}
						else
						{
							sTmpKeys2 += ssep + FormatColumn("tmp.{prop}",col);
							sTmpKeyString += ssepstr + FormatColumn("tmp.{prop}",col) + ".ToString()";
						}
						ssep=", ";
						ssepstr=" + \"_\" + ";
					}
				}
%>
		public static void Refresh(<%=sPrefix%><%=sClass%> tmp)
		{
			string key = <%=sTmpKeyString%>;
			ConvertListToDictionary();
			if (_CacheByPrimaryKey.ContainsKey(key))
				foreach (<%=_className%> tmpInfo in _CacheByPrimaryKey[key])
					tmpInfo.RefreshFields(tmp);
		}
		protected virtual void RefreshFields(<%=sClass%> tmp)
		{<%=DebugLine("20080430.2")%><%
				foreach(IColumn col in Updatable(_workingTable))
				{
					if (!IsIn(col,fk.ForeignColumns))
						UpdateInfoFromEdit(col);
				}
%>
			<%=MemberName(_className)%>Extension.Refresh(this);
<%=_refreshMine%>			OnChange();// raise an event
		}<%
			}
		}
%>
		public static <%=_className%> Get(<%=sKeyTypes%>)
		{
			//if (!CanGetObject())
			//  throw new System.Security.SecurityException("User not authorized to view a <%=ClassName(_workingTable)%>");
			try
			{
				<%=_className%> tmp = GetCachedByPrimaryKey(<%=sKeys%>);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<<%=_className%>>(new PKCriteria(<%=sKeys%>));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found")<%
		if (!OneToOne(_workingTable) || true){ // RHM 20080710 - Not sure why it should not return null
%>
				{
					tmp.Dispose(); // Clean-up <%=_className%>
					tmp = null;
				}<%
		} else {
%>
				{
<%=FormatColumns("tmp.{member} = {local};",_workingTable.PrimaryKeys,"\r\n","\t\t\t\t\t")%>
				}<%
		}
%>
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on <%=_className%>.Get", ex);
			}
		}
		#endregion<%
	}
	private void UpdateInfoFromEdit(IColumn col) //20080430.4
	{
		if (col.ForeignKeys.Count > 0)
		{
			string sProp=RelObjProp(col);
			string sMember=MemberName(sProp);
			IForeignKey FK = col.ForeignKeys[0];
			//string sClass = FKClassName(FK);
			string sClasses = FKClassesName(FK);
			string sAlias = GetAlias(FK);
			output.write(FormatColumn("\r\n\t\t\tif ({member} != tmp.{prop})",col));
			output.write("\r\n\t\t\t{");
			output.write("\r\n\t\t\t\tif (" + sProp + " != null) " + sProp + ".Refresh" + sClasses + sAlias + "(); // Update List for old value");
			output.write(FormatColumn("\r\n\t\t\t\t{member} = tmp.{prop}; // Update the value",col));
			output.write("\r\n\t\t\t}");
			output.write("\r\n\t\t\t" + sMember + " = null; // Reset list so that the next line gets a new list" );
			output.write("\r\n\t\t\tif (" + sProp + " != null) " + sProp + ".Refresh" + sClasses + sAlias + "(); // Update List for new value");
		}
		else
			output.write(FormatColumn("\r\n\t\t\t{member} = tmp.{prop};",col));
	}
	private void vlnDataAccessPortalInfo(IColumns columns)
	{
%>
		#region Data Access Portal
		internal <%=_className%>(SafeDataReader dr)
		{
			<%=_databaseLogDebug%>("[{0}] <%=_className%>.Constructor", GetHashCode());
			try
			{
				ReadData(dr);
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("<%=_className%>.Constructor", ex);
				throw new DbCslaException("<%=_className%>.Constructor", ex);
			}
		}<%
		vlnPKCriteria();
		vlnReadData(columns,false);
		vlnDataPortalFetch("PK",_workingTable.PrimaryKeys,ClassName(_workingTable),false);
%>
		#endregion<%
	}
	public void GeneratePropertyDescriptor()
	{
		_className="PropertyDescriptor";
		vlnHeader("\r\nusing Csla.Validation;");
		vlnListPropertyDescriptor();
		vlnIVEHasBrokenRules();
%>
} // Namespace
// The following are samples of ToString overrides<%
		foreach(string sClass in _PropDescList)
		{
%>
//	public partial class <%=sClass%>
//	{ public override string ToString() { return string.Format("{0}", _Name); } }<%
		}
		SaveFile();
	}
	public void GenerateCommonRules()
	{
		_className="CommonRules";
		vlnHeader("\r\nusing Csla.Validation;\r\nusing System.Reflection;",false);
%>
	public static class CommonRules
	{
		public static bool Required(object target, Csla.Validation.RuleArgs e)
		{
			PropertyInfo propertyInfoObj = target.GetType().GetProperty(e.PropertyName);
			if (propertyInfoObj == null) return true;
			if (propertyInfoObj.GetValue(target, null) == null)
			{
				e.Description = e.PropertyName + " is a required field";
				return false;
			}
			return true;
		}
	}
}<%
		SaveFile();
	}
	public void vlnIVEHasBrokenRules()
	{
%>
	public interface IVEHasBrokenRules
	{
		IVEHasBrokenRules HasBrokenRules { get; }
		BrokenRulesCollection BrokenRules { get; }
	}<%
	}
	public void Log4Net()
	{
		if (_chkPartL4N)
		{
%>
		#region Log4Net
		private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
		#endregion<%
		}
	}
	public void GenerateDatabase()
	{
		_className="Database";
		vlnHeader("\r\nusing System.Diagnostics;");
%>
	public static partial class Database
	{<%
		if (_chkPartL4N)
		{
%>
		#region Log4Net
		private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
		#endregion<%
		}
%>
		public static void LogException(string s, Exception ex)
		{
			int i = 0;
			Console.WriteLine("Error - {0}", s);
			for (; ex != null; ex = ex.InnerException)
			{
				Console.WriteLine("{0}{1} - {2}", "".PadLeft(++i * 2), ex.GetType().ToString(), ex.Message);
			}
		}
		private static bool _LoggingInfo = false; // By default don't log info 
		public static bool LoggingInfo
		{
			get { return _LoggingInfo; }
			set { _LoggingInfo = value; }
		}
		static System.Diagnostics.Process _CurrentProcess = System.Diagnostics.Process.GetCurrentProcess();
		public static void LogInfo(string s, int hashCode)
		{
			if (_LoggingInfo)
				Console.WriteLine("{0} MB {1}", _CurrentProcess.WorkingSet64 / 1000000, string.Format(s, hashCode));
		}
		public static void LogDebug(string s, int hashCode)
		{
			if (_LoggingInfo)
				Console.WriteLine("{0} MB {1}", _CurrentProcess.WorkingSet64 / 1000000, string.Format(s, hashCode));
		}
		private static string _ConnectionName = "<%=_dbConnection%>";
		public static string ConnectionName
		{
			get { return Database._ConnectionName; }
			set { Database._ConnectionName = value; }
		}
		public static string <%=_dbConnection%>_Connection
		{
			get
			{
				DateTime.Today.ToLongDateString();
				ConnectionStringSettings cs = ConfigurationManager.ConnectionStrings[ConnectionName];
				if (cs == null)
				{
					throw new ApplicationException("Database.cs Could not find connection " + ConnectionName);
				}
				return cs.ConnectionString;
			}
		}
		public static SqlConnection <%=_dbConnection%>_SqlConnection
		{
			get
			{
				string strConn = <%=_dbConnection%>_Connection; // If failure - Fail (Don't try to catch)
				// Attempt to make a connection 
				try
				{
					SqlConnection cn = new SqlConnection(strConn);
					cn.Open();
					return cn;
				}
				catch (SqlException exsql)
				{
					const string strAttachError = "An attempt to attach an auto-named database for file ";
					if (exsql.Message.StartsWith(strAttachError))
					{// Check to see if the file is missing
						string sFile = exsql.Message.Substring(strAttachError.Length);
						sFile = sFile.Substring(0, sFile.IndexOf(" failed"));
						//	"An attempt to attach an auto-named database for file <mdf file> failed"
						if (strConn.ToLower().IndexOf("user instance=true") < 0)
						{
							throw new ApplicationException("Connection String missing attribute: User Instance=True");
						}
						if (System.IO.File.Exists(sFile))
						{
							throw new ApplicationException("Database file " + sFile + " Cannot be opened\r\n", exsql);
						}
						else
						{
							throw new FileNotFoundException("Database file " + sFile + " Not Found", exsql);
						}
					}
					else
					{
						throw new ApplicationException("Failure on Connect", exsql);
					}
				}
				catch (Exception ex)// Throw Application Exception on Failure
				{
					<%=_databaseLogError%>("Connection Error", ex);
					throw new ApplicationException("Failure on Connect", ex);
				}
			}
		}
		public static void PurgeData()
		{
			try
			{
				SqlConnection cn = <%=_dbConnection%>_SqlConnection;
				SqlCommand cmd = new SqlCommand("purgedata", cn);
				cmd.CommandType = CommandType.StoredProcedure;
				cmd.CommandTimeout = 0;
				cmd.ExecuteNonQuery();
			}
			catch (Exception ex)
			{
				<%=_databaseLogError%>("Purge Error", ex);
				throw new ApplicationException("Failure on Purge", ex);
			}
		}
	}
	public class DbCslaException : Exception
	{
		internal DbCslaException(string message, Exception innerException) : base(message, innerException) { ;}
		internal DbCslaException(string message) : base(message) { ;}
		internal DbCslaException() : base() { ;}
	} // Class
} // Namespace
<%
	SaveFile();
	}
%><%#FILE NamingConvention.cs%><%
%><%#FILE ForeignKeyProcessing.cs%><%
%><%#FILE WriteLine.cs%><%
%><%#FILE FilteredColumns.cs%><%
%><%#FILE FormatColumns.cs%><%
}// Bottom of Namespace
%>
##|BODY_END