diff --git a/PROMS/MYGENERATION/csla_21/CSLA_Objects.csgen b/PROMS/MYGENERATION/csla_21/CSLA_Objects.csgen
new file mode 100644
index 00000000..04f43b20
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/CSLA_Objects.csgen
@@ -0,0 +1,4645 @@
+##|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", "Volian.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()
+ {
+ 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);
+ }
+ }
+ //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["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 = "//TODO: No Table Name";
+ vlnHeader("\r\nusing Csla.Validation;");
+ string sInterface = "";
+ if(_chkPartCM)
+ {
+ sInterface = ", ICustomTypeDescriptor";
+%>
+ [TypeConverter(typeof(<%=_className%>Converter))]<%
+ }
+%>
+ public partial class <%=_className%> : BusinessListBase<<%=_className%>, <%=_subclassName%>><%=sInterface%>, IVEHasBrokenRules
+ {<%
+ 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 Csla.Validation;");
+ string sInterface="";
+ if(_chkPartCM)
+ {
+ //sInterface = ", ICustomTypeDescriptor";
+%>
+ [TypeConverter(typeof(<%=_className%>Converter))]<%
+ }
+%>
+ public partial class <%=_className%> : BusinessBase<<%=_className%>><%=sInterface%>, IVEHasBrokenRules
+ {<%
+ 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));
+ }
+ }
+ public void Dispose()
+ {
+ 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%>
+ ///
+ /// <%=_className%> Generated by MyGeneration using the CSLA Object Mapping template
+ /// <%
+ 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
+ #region Collection
+ protected static List<<%=_className%>> _AllList = new List<<%=_className%>>();
+ private static Dictionary> _AllByPrimaryKey = new Dictionary>();<%
+ //ArrayList uniqueIndexes=UniqueIndexes(tbl);
+ foreach(IIndex ind in uniqueIndexes)
+ {
+ string sBy = FormatColumns("{name}",ind.Columns,"_","");
+%>
+ private static Dictionary> _AllBy<%=sBy%> = new Dictionary>();<%
+ }
+%>
+ private static void ConvertListToDictionary()
+ {
+ List<<%=_className%>> remove = new List<<%=_className%>>();
+ foreach (<%=_className%> tmp in _AllList)
+ {
+ _AllByPrimaryKey[<%=pKey%>]=tmp; // Primary Key<%
+ foreach(IIndex ind in uniqueIndexes)
+ {
+ string sBy = FormatColumns("{name}",ind.Columns,"_","");
+ string sKey = FormatColumns("tmp.{prop}.ToString()",ind.Columns," + \"_\" + ","");
+%>
+ _AllBy<%=sBy%>[<%=sKey%>] = tmp; // Unique Index<%
+ }
+%>
+ remove.Add(tmp);
+ }
+ foreach (<%=_className%> tmp in remove)
+ _AllList.Remove(tmp);
+ }<%
+ 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) _AllList.Add(item);
+ }<%
+ }
+%>
+ public static <%=_className%> GetExistingByPrimaryKey(<%=pKeysType%>)
+ {
+ ConvertListToDictionary();
+ string key = <%=pKey2%>;
+ if (_AllByPrimaryKey.ContainsKey(key)) return _AllByPrimaryKey[key];
+ 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,", ","");
+%>
+ public static <%=_className%> GetExistingBy<%=sBy%>(<%=sKeysType%>)
+ {
+ ConvertListToDictionary();
+ string key = <%=sKey%>;
+ if (_AllBy<%=sBy%>.ContainsKey(key)) return _AllBy<%=sBy%>[key];
+ 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);
+// 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);
+ 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);
+ vlnProperty(sLists+sAlias,MemberName(sLists)+sAlias,sLists + sAlias,
+ " = null;","Related Field" + Debug("20070501.2"),true,false,true,fk,null,null);
+ //sExtDirty += " || " + MemberName(sLists+sAlias) + ".IsDirty";
+ //sExtValid += " && " + MemberName(sLists+sAlias) + ".IsValid";
+ sExtDirty += string.Format(" || ({0} == null? false : {0}.IsDirty)",MemberName(sLists+sAlias));
+ sExtValid += string.Format(" && ({0} == null? true : {0}.IsValid)",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);
+ 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);
+ bool bReq = !fk.ForeignColumns[0].IsNullable;
+ sExtDirty += string.Format(" || ({0} == null? false : {0}.IsDirty)",MemberName("My" + sItem+sAlias));
+ sExtValid += string.Format(" && ({0} == null? true : {0}.IsValid)",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}.IsDirty)",MemberName("My" + sClass));
+ sExtValid += string.Format(" && ({0} == null? true : {0}.IsValid)",MemberName("My" + sClass));
+ }
+ }
+ }
+ if(sExtDirty!="")vlnDirty(sExtDirty);
+ //if(sExtValid!="")vlnOverride("Valid",sExtValid);
+ vlnValid(sExtValid);
+// }
+// }
+ }
+ private void vlnDirty(string sExtension)
+ {
+ %>
+ public override bool IsDirty
+ {
+ get { return base.IsDirty<%=sExtension%>; }
+ }<%
+ }
+ private void vlnValid(string sExtension)
+ {
+ %>
+ public override bool IsValid
+ {
+ get { 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 && <%=sMemberName%> == null)
+ <%=sMemberName%> = <%=sType%>.GetBy<%=sBy%>(<%=sKeys%>);
+ else if(<%=sMemberName%> == null)
+ <%=sMemberName%> = <%=sRelClass%>.New();<%
+ }
+ 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 suffix = (sPropertyName==_className?"Fld":"");
+%>
+ private <%=ReturnType(sType)%> <%=sMemberName%><%=suffix%><%=sDefault%><%
+ if(!sDefault.EndsWith("timestamp")){
+ if(sDescription != ""){
+%>
+ ///
+ /// <%=sDescription%>
+ /// <%
+ }
+ 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();
+ // TODO: 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 (<%=sMemberName%><%=suffix%> != value)
+ {
+ <%=sMemberName%><%=suffix%><%=ReturnMember(sType)%> = value;<%=sParentCheck2%>
+ PropertyHasChanged();
+ }
+ }<%
+ break;
+ }
+ }
+%>
+ }<%
+ }
+
+ }
+ private void vlnToString(IColumns Columns)
+ {
+%>
+ // TODO: Replace base <%=_className%>.ToString function as necessary
+ ///
+ /// Overrides Base ToString
+ ///
+ /// A string representation of current <%=_className%>
+ //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()";
+ }
+%>
+ // TODO: Check <%=_className%>.GetIdValue to assure that the ID returned is unique
+ ///
+ /// Overrides Base GetIdValue - Used internally by CSLA to determine equality
+ ///
+ /// A Unique ID for the current <%=_className%>
+ protected override object GetIdValue()
+ {
+ return <%=keyID%>;
+ }<%
+ }
+ 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);
+ // TODO: Add other validation rules
+ }
+ protected override void AddInstanceBusinessRules()
+ {
+ <%=extMName%>.AddInstanceValidationRules(ValidationRules);
+ // TODO: 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()
+ {
+ //TODO: Who can read/write which fields<%
+ foreach(IColumn field in Columns)
+ {
+ if(field.DataTypeName != "timestamp"){
+%>
+ //AuthorizationRules.AllowRead(<%=PropertyName(field)%>, "");<%
+ }
+ }
+ foreach(IColumn field in Columns)
+ {
+ if(!(field.IsInPrimaryKey || field.IsAutoKey || field.IsComputed))
+ {
+%>
+ //AuthorizationRules.AllowWrite(<%=PropertyName(field)%>, "");<%
+ }
+ }
+%>
+ <%=extMName%>.AddAuthorizationRules(AuthorizationRules);
+ }
+ protected override void AddInstanceAuthorizationRules()
+ {
+ //TODO: Who can read/write which fields
+ <%=extMName%>.AddInstanceAuthorizationRules(AuthorizationRules);
+ }
+ public static bool CanAddObject()
+ {
+ // TODO: Can Add Authorization
+ //return Csla.ApplicationContext.User.IsInRole("ProjectManager");
+ return true;
+ }
+ public static bool CanGetObject()
+ {
+ // TODO: CanGet Authorization
+ return true;
+ }
+ public static bool CanDeleteObject()
+ {
+ // TODO: 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 != "")
+ {
+%>
+ ///
+ /// determines if related records (Foreign Keys) will keep this Item from being deleted
+ ///
+ 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()
+ {
+ // TODO: 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; } }
+ protected <%=_className%>()
+ {/* require use of factory methods */
+ _AllList.Add(this);
+ }
+ public void Dispose()
+ {
+ _AllList.Remove(this);
+ _AllByPrimaryKey.Remove(<%=pKeys%>);<%
+ ArrayList uniqueIndexes=UniqueIndexes(_workingTable);
+ IIndex makeIndex=null;
+ 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;
+%>
+ _AllBy<%=sBy%>.Remove(<%=sKey%>);<%
+ }
+ 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);
+ }
+ 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")%>
+ tmp = tmp.Save();
+ return tmp;
+ }<%
+ }
+ 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 = GetExistingByPrimaryKey(<%=sKeys%>);
+ if (tmp == null)
+ {
+ tmp = DataPortal.Fetch<<%=_className%>>(new PKCriteria(<%=sKeys%>));
+ _AllList.Add(tmp);
+ }
+ if (tmp.ErrorMessage == "No Record Found") 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 = GetExistingByPrimaryKey(<%=parKeys%>);
+ if (tmp == null)
+ {
+ tmp = DataPortal.Fetch<<%=_className%>>(new <%=sParent%>Criteria(<%=parKeys%>));
+ _AllList.Add(tmp);
+ }
+ if (tmp.ErrorMessage == "No Record Found") 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,", ","");
+%>
+ private static <%=_className%> GetBy<%=sBy%>(<%=sKeyType%>)
+ {
+ if (!CanGetObject())
+ throw new System.Security.SecurityException("User not authorized to view a <%=_className%>");
+ try
+ {
+ <%=_className%> tmp = GetExistingBy<%=sBy%>(<%=sKey%>);
+ if (tmp == null)
+ {
+ tmp=DataPortal.Fetch<<%=_className%>>(new <%=sBy%>Criteria(<%=sKey%>));
+ _AllList.Add(tmp);
+ }
+ if (tmp.ErrorMessage == "No Record Found") 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();
+ _AllList.Add(<%=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 BuildRefreshList()
+ {
+<%=sReset%>
+ AddToRefreshList(<%=sRefreshRelated1%>);
+ }
+ private void ProcessRefreshList()
+ {
+<%=sProcess%>
+ }
+ #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
+%>
+ // TODO: 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")%>
+ // TODO: 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));
+ }
+ }
+%>
+ // TODO: 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));
+ }
+ }
+%>
+ // TODO: 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));
+ }
+ }
+%>
+ // TODO: 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);
+ if(IsParentCol(column)){
+ sKeysTypesU+=sepi + _className + " my" + sParent;
+ sKeysU+=sepi + "my" + sParent;
+ }
+ else
+ {
+ sKeysTypesU+=sepu + FormatColumn("{?ref}{!type} {!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 sRef = ParentRef(column);
+ if(sRef==null)sRef=FormatColumn("{?ref}{?dbprefix}{!propmember}{?dbsuff}",column);
+ sUpdate+=sepu+sRef;
+ sepu=", ";
+ if(!column.IsComputed)// && !column.IsAutoKey
+ {
+ sInsert+=sepi+sRef;
+ sepi=", ";
+ }
+ }
+ else
+ {
+ //string sRef = FormatColumn("{?dbprefix}{rmember}{?dbsuff}",RelatedColumn(column,fk));
+ string sRef = sPrimaryLocal;
+ sInsert+=sepi + sRef;
+ sUpdate+=sepu + sRef;
+ 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);
+ if(!column.IsComputed)// && !column.IsAutoKey
+ {
+ sInsert+=sepi+sRef;
+ sepi=", ";
+ }
+ sUpdate+=sepu + sRef;
+ 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("/*1*/{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));
+ }
+ }
+%>
+ // TODO: 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%>
+ // TODO: 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);";// TODO: Need to handle TimeStamp
+ //output.write(FormatColumns(dicRead1,Columns,""));
+// if(_workingTable != fk.ForeignTable)
+// FKSelect(fk,tbl);
+ // TODO: 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(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
+// {
+// // TODO: 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, "");
+// }
+// public new void AddInstanceAuthorizationRules(Csla.Security.AuthorizationRules rules)
+// {
+// //rules.AllowInstanceRead(Dbid, "");
+// }
+// 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);
+// WriteLine("\r\n//20070302 - {0}", uniqueMatch);
+// if(uniqueMatch != null)WriteLine("\r\n//20070302 - {0}", uniqueMatch[0]);
+ 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)
+ {
+%>
+ 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%>;
+ }<%
+ }
+ }
+%>
+ 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;
+ }<%
+ foreach(IList lst in uniqueChildren){
+ if(!SameTypes(lst,fkCols)){ // Has Required Fields 20070302
+ 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;
+ }<%
+ }
+ }
+%>
+ #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%>);
+ }
+ #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; }
+ ///
+ /// Called to get the properties of this type. Returns properties with certain
+ /// attributes. this restriction is not implemented here.
+ ///
+ ///
+ ///
+ public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
+ { return GetProperties(); }
+ ///
+ /// Called to get the properties of this type.
+ ///
+ ///
+ 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 description for CollectionPropertyDescriptor.
+ ///
+ 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 description for CollectionPropertyDescriptor.
+ ///
+ 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);
+ 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);
+ }
+ }
+ }
+ }
+// if (sKey == "")sKey="base.GetIdValue()";
+%>
+ // TODO: Check <%=sFkClassName%>.GetIdValue to assure that the ID returned is unique
+ ///
+ /// Overrides Base GetIdValue - Used internally by CSLA to determine equality
+ ///
+ /// A Unique ID for the current <%=sFkClassName%>
+ protected override object GetIdValue()
+ {
+ return <%=sKey%>;
+ }
+ // TODO: Replace base <%=sFkClassName%>.ToString function as necessary
+ ///
+ /// Overrides Base ToString
+ ///
+ /// A string representation of current <%=sFkClassName%>
+ //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}.IsDirty)",MemberName(sColumn));
+ sExtValid += string.Format(" && ({0} == null ? true : {0}.IsValid)",MemberName(sColumn));
+ }
+ }
+ if(sExtDirty!="")vlnDirty(sExtDirty);
+ if(sExtValid!="")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%>");<%
+ }
+ }
+ }
+%>
+ // TODO: 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()
+ {
+ //TODO: 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)%>, "");<%
+ if(!(column.IsInPrimaryKey || column.IsAutoKey || column.IsComputed))
+ {
+%>
+ //AuthorizationRules.AllowWrite(<%=PropertyName(column)%>, "");<%
+ }
+ }
+ }
+%>
+ }
+ public static bool CanAddObject()
+ {
+ // TODO: Can Add Authorization
+ //return Csla.ApplicationContext.User.IsInRole("ProjectManager");
+ return true;
+ }
+ public static bool CanGetObject()
+ {
+ // TODO: CanGet Authorization
+ return true;
+ }
+ public static bool CanDeleteObject()
+ {
+ // TODO: 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()
+ {
+ // TODO: 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; } }
+ 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();
+ // TODO: Add any initialization & defaults
+<%=FormatColumns("{member} = " + extMName + ".Default{prop};",HasDefaults(fk),"\r\n","\t\t\t")%>
+<%=sInit%>
+ ValidationRules.CheckRules();
+ }<%
+ }
+%>
+ internal <%=sFkClassName%>(SafeDataReader dr)
+ {
+ MarkAsChild();
+ Fetch(dr);
+ }
+ #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 sRef = ParentRef(column);
+ if(sRef==null)
+ {
+ if(column.IsComputed || column.IsAutoKey)
+ sRef=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))
+ sRef=FormatColumn("{?dbprefix}{!membercolumn}{?dbsuff}",column);// 20070326
+ else
+ sRef=FormatColumn("{?dbprefix}{!member}{?dbsuff}",column);// 20070326
+ }
+ sUpdate+=sepu + sRef;
+ sepu=", ";
+ if(!column.IsComputed)// && !column.IsAutoKey
+ {
+ sInsert+=sepi+sRef;
+ sepi=", ";
+ }
+ }
+ else
+ {
+ string sRef;
+ if(IsRelObj(column))
+ sRef = FormatColumn("{?dbprefix}{!local}{?dbsuff}",column);
+ else
+ sRef = FormatColumn("{?dbprefix}{rmember}{?dbsuff}",RelatedColumn(column,fk));
+ sInsert+=sepi + sRef;
+ sUpdate+=sepu + sRef;
+ sepi=", ";
+ sepu=", ";
+ //sepd=", ";
+ }
+ }
+ foreach(IColumn column in fk.ForeignTable.PrimaryKeys)
+ {
+ if(IsIn(column,fk.ForeignColumns))
+ sDelete+=sepd+FormatColumn("{!localcolumn}",column);
+ //sDelete+=sepd+FormatColumn("/*1*/{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;
+ ///
+ /// Return a list of all projects.
+ ///
+ 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);
+ }
+ }<%
+// ForeignKeys - List Foreign Keys - May want to create stored procedures
+%>
+ // TODO: Add alternative gets -
+ //public static <%=_className%> Get()
+ //{
+ // try
+ // {
+ // return DataPortal.Fetch<<%=_className%>>(new FilteredCriteria());
+ // }
+ // 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;
+ if(column.IsNullable)
+ sCheck2=FormatColumn("\r\n\t\t\t\t\t{member} = (value == null ? null : ({ctype}) value.{!column});",column);
+ vlnProperty(RelObjType( column ) + (bInfo?"Info":"") ,sMember
+ ,sProp,";"+DebugLine("20070501.4"),"",bReadOnly,column.IsInPrimaryKey,false,null,sCheck,sCheck2);
+ if(sProp.StartsWith("My"))_refreshMine += string.Format("\t\t\t{0} = null;\r\n",sMember);
+ }
+ }
+ 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);
+ 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);
+ vlnProperty("int",MemberName(sClass) + sAlias + "Count" ,sClass + sAlias + "Count", " = 0;",
+ "Count of " + sClasses + " for this " + ClassName(_workingTable),true,false,false,null,null,null);
+ if(!OneToOne(FK))
+ FKPropertyList(ClassName(FK.ForeignTable),sClasses,FK,sAlias);
+ else
+ FKPropertyInfo(ClassName(FK.ForeignTable),sClasses,FK,sAlias);
+ }
+ }
+
+ 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;
+ //_refreshMine += string.Format("\t\t\t{0} = null;\r\n",sMember);
+%>
+ 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 && <%=sMember%> == null)
+ <%=sMember%> = <%=sClass%>InfoList.Get<%=sBy%>(<%=sKeys%>);
+ return <%=sMember%>;
+ }
+ }<%
+ }
+ 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;\r\n",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%>);
+ 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,", ","");
+%>
+ #region Factory Methods
+ private <%=_className%>()
+ {/* require use of factory methods */
+ _AllList.Add(this);
+ }
+ public void Dispose()
+ {
+ _AllList.Remove(this);
+ _AllByPrimaryKey.Remove(<%=sRefKeys%>);
+ }
+ public virtual <%=ClassName( _workingTable )%> Get()
+ {<%=DebugLine("20070502.1")%>
+ return _Editable = <%=sEditable%>.Get(<%=sPKeys%>);
+ }
+ public static void Refresh(<%=ClassName( _workingTable )%> tmp)
+ {
+ <%=_className%> tmpInfo = GetExistingByPrimaryKey(<%=sTmpKeys%>);
+ if (tmpInfo == null) return;
+ tmpInfo.RefreshFields(tmp);
+ }
+ private void RefreshFields(<%=ClassName( _workingTable )%> tmp)
+ {<%
+ foreach(IColumn col in Updatable(_workingTable))
+ {
+ output.write(FormatColumn("\r\n\t\t\t{member} = tmp.{prop};",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;
+ if(ForeignPrimary(fk))
+ {
+ string sOther = ClassName(fk.PrimaryTable);
+ sPrefix = ClassName(fk.PrimaryTable) + " my" + ClassName(fk.PrimaryTable) + ", ";
+ string ssep="";
+ sTmpKeys2="";
+ 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);
+ else
+ sTmpKeys2 += ssep + FormatColumn("tmp.{prop}",col);
+ ssep=", ";
+ }
+ }
+%>
+ public static void Refresh(<%=sPrefix%><%=sClass%> tmp)
+ {
+ <%=_className%> tmpInfo = GetExistingByPrimaryKey(<%=sTmpKeys2%>);
+ if (tmpInfo == null) return;
+ tmpInfo.RefreshFields(tmp);
+ }
+ private void RefreshFields(<%=sClass%> tmp)
+ {<%
+ foreach(IColumn col in Updatable(_workingTable))
+ {
+ if(!IsIn(col,fk.ForeignColumns))
+ {
+%>
+ <%=FormatColumn("{member} = tmp.{prop};",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 = GetExistingByPrimaryKey(<%=sKeys%>);
+ if (tmp == null)
+ {
+ tmp = DataPortal.Fetch<<%=_className%>>(new PKCriteria(<%=sKeys%>));
+ _AllList.Add(tmp);
+ }
+ if (tmp.ErrorMessage == "No Record Found")<%
+ if(!OneToOne(_workingTable)){
+%> 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 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));
+ }
+ public static string <%=_dbConnection%>_Connection
+ {
+ get
+ {
+ DateTime.Today.ToLongDateString();
+ ConnectionStringSettings cs = ConfigurationManager.ConnectionStrings["<%=_dbConnection%>"];
+ if (cs == null)
+ {
+ throw new ApplicationException("Database.cs Could not find connection <%=_dbConnection%>");
+ }
+ 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 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
diff --git a/PROMS/MYGENERATION/csla_21/Debug/Debug.cs b/PROMS/MYGENERATION/csla_21/Debug/Debug.cs
new file mode 100644
index 00000000..6c690c35
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/Debug/Debug.cs
@@ -0,0 +1,219 @@
+ private void ColumnInfoHeader()
+ {
+ Write("Container, ");
+ Write("Name, ");
+ Write("Alias, ");
+ Write("AutoKeyIncrement, ");
+ Write("AutoKeySeed, ");
+ Write("CharacterMaxLength, ");
+ Write("CharacterOctetLength, ");
+ //Write("CharacterSetCatalog, ");
+ //Write("CharacterSetSchema, ");
+ Write("CompFlags, ");
+ Write("DataType, ");
+ Write("DataTypeName, ");
+ Write("DataTypeNameComplete, ");
+ Write("DateTimePrecision, ");
+ Write("DbTargetType, ");
+ Write("Default, ");
+ Write("Description, ");
+ //Write("Domain, ");
+ //Write("DomainCatalog, ");
+ //Write("DomainName, ");
+ //Write("DomainSchema, ");
+ Write("Flags, ");
+ Write("ForeignKeys, ");
+ //Write("GlobalProperties, ");
+ //Write("Guid, ");
+ Write("HasDefault, ");
+ Write("HasDomain, ");
+ Write("IsAutoKey, ");
+ Write("IsComputed, ");
+ Write("IsInForeignKey, ");
+ Write("IsInPrimaryKey, ");
+ Write("IsNullable, ");
+ Write("LanguageType, ");
+ Write("LCID, ");
+ Write("NumericPrecision, ");
+ Write("NumericScale, ");
+ Write("Ordinal, ");
+ //Write("Properties, ");
+ Write("PropID, ");
+ Write("SortID, ");
+ Write("Table, ");
+ //Write("TDSCollation, ");
+ //Write("TypeGuid, ");
+ //Write("UserDataXPath, ");
+ Write("View\r\n");
+ }
+ private void ColumnProps(IColumn column)
+ {
+ WriteProp("",(column.Table==null?"view: " + column.View.Name:column.Table.Name),"");
+ WriteProp(column.Name);
+ WriteProp(column.Alias);
+ WriteProp(column.AutoKeyIncrement);
+ WriteProp(column.AutoKeySeed);
+ WriteProp(column.CharacterMaxLength);
+ WriteProp(column.CharacterOctetLength);
+ //WriteProp(column.CharacterSetCatalog);
+ //WriteProp(column.CharacterSetSchema);
+ WriteProp(column.CompFlags);
+ WriteProp(column.DataType);
+ WriteProp(column.DataTypeName);
+ WriteProp(column.DataTypeNameComplete);
+ WriteProp(column.DateTimePrecision);
+ WriteProp(column.DbTargetType);
+ WriteProp(column.Default);
+ WriteProp(column.Description);
+ //WriteProp(column.Domain);
+ //WriteProp(column.DomainCatalog);
+ //WriteProp(column.DomainName);
+ //WriteProp(column.DomainSchema);
+ WriteProp(column.Flags);
+ WriteProp(column.ForeignKeys.Count);
+ //WriteProp(column.GlobalProperties);
+ //WriteProp(column.Guid);
+ WriteProp(column.HasDefault);
+ WriteProp(column.HasDomain);
+ WriteProp(column.IsAutoKey);
+ WriteProp(column.IsComputed);
+ WriteProp(column.IsInForeignKey);
+ WriteProp(column.IsInPrimaryKey);
+ WriteProp(column.IsNullable);
+ WriteProp(column.LanguageType);
+ WriteProp(column.LCID);
+ WriteProp(column.NumericPrecision);
+ WriteProp(column.NumericScale);
+ WriteProp(column.Ordinal);
+ //WriteProp(column.Properties);
+ WriteProp(column.PropID);
+ WriteProp(column.SortID);
+ WriteProp(column.Table);
+ //WriteProp(column.TDSCollation);
+ //WriteProp(column.TypeGuid);
+ //WriteProp(column.UserDataXPath);
+ WriteProp("",column.View,"\r\n");
+ }
+ private void ColumnInfo(IColumn column)
+ {
+ WriteLine("\t\tContainer {0}",(column.Table==null?"view: " + column.View.Name:column.Table.Name));
+ WriteLine("\t\tName {0}",column.Name);
+ WriteLine("\t\tAlias {0}",column.Alias);
+ WriteLine("\t\tAutoKeyIncrement {0}",column.AutoKeyIncrement);
+ WriteLine("\t\tAutoKeySeed {0}",column.AutoKeySeed);
+ WriteLine("\t\tCharacterMaxLength {0}",column.CharacterMaxLength);
+ WriteLine("\t\tCharacterOctetLength {0}",column.CharacterOctetLength);
+ //WriteLine("\t\tCharacterSetCatalog {0}",column.CharacterSetCatalog);
+ //WriteLine("\t\tCharacterSetSchema {0}",column.CharacterSetSchema);
+ WriteLine("\t\tCompFlags {0}",column.CompFlags);
+ WriteLine("\t\tDataType {0}",column.DataType);
+ WriteLine("\t\tDataTypeName {0}",column.DataTypeName);
+ WriteLine("\t\tDataTypeNameComplete {0}",column.DataTypeNameComplete);
+ WriteLine("\t\tDateTimePrecision {0}",column.DateTimePrecision);
+ WriteLine("\t\tDbTargetType {0}",column.DbTargetType);
+ WriteLine("\t\tDefault {0}",column.Default);
+ WriteLine("\t\tDescription {0}",column.Description);
+ //WriteLine("\t\tDomain {0}",column.Domain);
+ //WriteLine("\t\tDomainCatalog {0}",column.DomainCatalog);
+ //WriteLine("\t\tDomainName {0}",column.DomainName);
+ //WriteLine("\t\tDomainSchema {0}",column.DomainSchema);
+ WriteLine("\t\tFlags {0}",column.Flags);
+ WriteLine("\t\tForeignKeys {0}",column.ForeignKeys);
+ //WriteLine("\t\tGlobalProperties {0}",column.GlobalProperties);
+ //WriteLine("\t\tGuid {0}",column.Guid);
+ WriteLine("\t\tHasDefault {0}",column.HasDefault);
+ WriteLine("\t\tHasDomain {0}",column.HasDomain);
+ WriteLine("\t\tIsAutoKey {0}",column.IsAutoKey);
+ WriteLine("\t\tIsComputed {0}",column.IsComputed);
+ WriteLine("\t\tIsInForeignKey {0}",column.IsInForeignKey);
+ WriteLine("\t\tIsInPrimaryKey {0}",column.IsInPrimaryKey);
+ WriteLine("\t\tIsNullable {0}",column.IsNullable);
+ WriteLine("\t\tLanguageType {0}",column.LanguageType);
+ WriteLine("\t\tLCID {0}",column.LCID);
+ WriteLine("\t\tNumericPrecision {0}",column.NumericPrecision);
+ WriteLine("\t\tNumericScale {0}",column.NumericScale);
+ WriteLine("\t\tOrdinal {0}",column.Ordinal);
+ //WriteLine("\t\tProperties {0}",column.Properties);
+ WriteLine("\t\tPropID {0}",column.PropID);
+ WriteLine("\t\tSortID {0}",column.SortID);
+ WriteLine("\t\tTable {0}",column.Table);
+ //WriteLine("\t\tTDSCollation {0}",column.TDSCollation);
+ //WriteLine("\t\tTypeGuid {0}",column.TypeGuid);
+ //WriteLine("\t\tUserDataXPath {0}",column.UserDataXPath);
+ WriteLine("\t\tView {0}",column.View);
+ }
+ private void ColumnFormatHeader()
+ {
+ Write("member,");
+ Write("fmember,");
+ Write("pmember,");
+ Write("local,");
+ Write("prop,");
+ Write("memberprop,");
+ Write("@,");
+ Write("@new,");
+ Write("ctype,");
+ Write("rmember,");
+ Write("rtype,");
+// Write("dbtype,");
+ Write("name,");
+ Write("class,");
+ Write("fname,");
+ Write("sqltype,");
+ Write("?ref,");
+ Write("?dbtype,");
+ Write("?dbprefix,");
+ Write("?dbsuffix,");
+ Write("?dbsuff,");
+ Write("default\r\n");
+ }
+ private void ColumnFormat(IColumn column)
+ {
+ Write(FormatColumn("\"{member}\",",column));
+ Write(FormatColumn("\"{fmember}\",",column));
+ Write(FormatColumn("\"{pmember}\",",column));
+ Write(FormatColumn("\"{local}\",",column));
+ Write(FormatColumn("\"{prop}\",",column));
+ Write(FormatColumn("\"{memberprop}\",",column));
+ Write(FormatColumn("\"{@}\",",column));
+ Write(FormatColumn("\"{@new}\",",column));
+ Write(FormatColumn("\"{ctype}\",",column));
+ Write(FormatColumn("\"{rmember}\",",column));
+ Write(FormatColumn("\"{rtype}\",",column));
+// Write(FormatColumn("\"{dbtype}\",",column));
+ Write(FormatColumn("\"{name}\",",column));
+ Write(FormatColumn("\"{class}\",",column));
+ Write(FormatColumn("\"{fname}\",",column));
+ Write(FormatColumn("\"{sqltype}\",",column));
+ Write(FormatColumn("\"{?ref}\",",column));
+ Write(FormatColumn("\"{?dbtype}\",",column));
+ Write(FormatColumn("\"{?dbprefix}\",",column));
+ Write(FormatColumn("\"{?dbsuffix}\",",column));
+ Write(FormatColumn("\"{?dbsuff}\",",column));
+ Write(FormatColumn("\"{default}\"\r\n",column));
+ }
+private void ColumnFormatNew(IColumn column)
+ {
+ Write(FormatColumnNew("\"{member}\",",column));
+ Write(FormatColumnNew("\"{fmember}\",",column));
+ Write(FormatColumnNew("\"{pmember}\",",column));
+ Write(FormatColumnNew("\"{local}\",",column));
+ Write(FormatColumnNew("\"{prop}\",",column));
+ Write(FormatColumnNew("\"{memberprop}\",",column));
+ Write(FormatColumnNew("\"{@}\",",column));
+ Write(FormatColumnNew("\"{@new}\",",column));
+ Write(FormatColumnNew("\"{ctype}\",",column));
+ Write(FormatColumnNew("\"{rmember}\",",column));
+ Write(FormatColumnNew("\"{rtype}\",",column));
+// Write(FormatColumnNew("\"{dbtype}\",",column));
+ Write(FormatColumnNew("\"{name}\",",column));
+ Write(FormatColumnNew("\"{class}\",",column));
+ Write(FormatColumnNew("\"{fname}\",",column));
+ Write(FormatColumnNew("\"{sqltype}\",",column));
+ Write(FormatColumnNew("\"{?ref}\",",column));
+ Write(FormatColumnNew("\"{?dbtype}\",",column));
+ Write(FormatColumnNew("\"{?dbprefix}\",",column));
+ Write(FormatColumnNew("\"{?dbsuffix}\",",column));
+ Write(FormatColumnNew("\"{?dbsuff}\",",column));
+ Write(FormatColumnNew("\"{default}\"\r\n",column));
+ }
\ No newline at end of file
diff --git a/PROMS/MYGENERATION/csla_21/FilteredColumns.cs b/PROMS/MYGENERATION/csla_21/FilteredColumns.cs
new file mode 100644
index 00000000..f51cf19d
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/FilteredColumns.cs
@@ -0,0 +1,534 @@
+ #region FilteredColumns
+ // Used by CSLA Objects Guid
+ public bool IsGuid(IColumn column){
+ return(column.LanguageType=="timestamp");}
+ public ArrayList Guid(IColumns columns){
+ return FilteredColumns(columns,new Filter(IsGuid));}
+ // Used in CSLA Business Objects AutoKey
+ public bool AutoKey(IColumn column){
+ return(column.IsAutoKey);}
+ public ArrayList AutoKey(IColumns columns){
+ return FilteredColumns(columns,new Filter(AutoKey));}
+ public ArrayList AutoKey(IForeignKey fk){
+ ArrayList l = new ArrayList();
+ foreach(IColumn column in fk.ForeignTable.Columns){
+ if(column.IsAutoKey && !IsIn(column,fk.ForeignColumns))l.Add(column);}
+ return l;}
+ // Used in CSLA Stored Procedures
+ private ArrayList AutoKey(ITable tbl){
+ return FilteredColumns(tbl.Columns,new Filter(AutoKey));}
+ // Used in CSLA Stored Procedures Updatable
+ public bool Updatable(IColumn column){
+ return(!NotUpdatable(column));}
+ private ArrayList Updatable(ITable tbl){
+ return FilteredColumns(tbl.Columns,new Filter(Updatable));}
+ // Used in CSLA Stored Procedures Not Updatable
+ public bool NotUpdatable(IColumn column){
+ return(column.IsInPrimaryKey || column.IsAutoKey || column.IsComputed);}
+ private ArrayList NotUpdatable(ITable tbl){
+ return FilteredColumns(tbl.Columns,new Filter(NotUpdatable));}
+ // Used in CSLA Stored Procedures PrimaryKey
+ public bool PrimaryKey(IColumn column){
+ return(column.IsInPrimaryKey);}
+ private ArrayList PrimaryKey(ITable tbl){
+ return FilteredColumns(tbl.Columns,new Filter(PrimaryKey));}
+ // Used in CSLA Stored Procedures Insertable
+ public bool Insertable(IColumn column){
+ return(!NotInsertable(column));}
+ private ArrayList Insertable(ITable tbl){
+ return FilteredColumns(tbl.Columns,new Filter(Insertable));}
+ // Used in CSLA Stored Procedures Not Insertable
+ public bool NotInsertable(IColumn column){
+ return(column.IsAutoKey || column.IsComputed);}
+ private ArrayList NotInsertable(ITable tbl){
+ return FilteredColumns(tbl.Columns,new Filter(NotInsertable));}
+ // Used in CSLA Stored Procedures & CSLA Business Objects Computed
+ public bool Computed(IColumn column){
+ return(column.IsComputed);}
+ private ArrayList Computed(ITable tbl){
+ return FilteredColumns(tbl.Columns,new Filter(Computed)); }
+ // Used in CSLA Stored Procedures Not TimeStamp
+ public bool NotTimestamp(IColumn column){
+ return(!Timestamp(column));}
+ private ArrayList NotTimestamp(ITable tbl){
+ return FilteredColumns(tbl.Columns,new Filter(NotTimestamp));}
+ private ArrayList NotTimestamp(IColumns cols){
+ return FilteredColumns(cols,new Filter(NotTimestamp));}
+ // Used in CSLA Business Objects
+ public bool IsRequired(IColumn column)
+ {
+ if(column.IsNullable) return false;
+ if(!column.HasDefault) return true;
+ // If it is the parent column it is required
+ return IsParentColumn(column);
+// return false;
+ }
+// public bool ForeignKey(IColumn column)
+// {
+// return(column.IsInForeignKey);
+// }
+ // Used in CSLA Business Objects Automatic
+ public bool IsAutomatic(IColumn column)
+ {
+ bool retval=column.Description.IndexOf("{auto}") >= 0;
+ return retval;
+ }
+ // Used in CSLA Business Objects TimeStamp
+ public bool Timestamp(IColumn column){
+ return(column.DataTypeName=="timestamp");}
+ public ArrayList IsTimestamp(IColumns columns){
+ return FilteredColumns(columns,new Filter(Timestamp));}
+ // Used in CSLA Stored Procedures and Business Objects
+ public ArrayList FilteredColumns(IColumns columns,Filter f){
+ ArrayList l = new ArrayList();
+ foreach(IColumn column in columns)
+ {
+ if(f(column))l.Add(column);
+ }
+ return l;
+ }
+ // Used in CSLA Business Objects
+ public ArrayList ExcludedColumns(IColumns columns,Filter f){
+ ArrayList l = new ArrayList();
+ foreach(IColumn column in columns)
+ {
+ if(!f(column))l.Add(column);
+ }
+ return l;
+ }
+ private int CountRequiredFields( IColumns Columns ){
+ return Columns.Count - CountNullableFields( Columns );}
+ private int CountNullableFields( IColumns Columns )
+ {
+ int i = 0;
+ foreach( IColumn c in Columns )
+ {
+ if( c.IsNullable )
+ {
+ i++;
+ }
+ }
+ return i;
+ }
+
+ private int CountUniqueFields( IColumns Columns )
+ {
+ int i = 0;
+ foreach( IColumn c in Columns )
+ {
+ if( !c.IsNullable && c.IsInPrimaryKey )
+ {
+ i++;
+ }
+ }
+ return i;
+ }
+ public ArrayList MakeList(IColumns columns)
+ {
+ ArrayList l = new ArrayList();
+ foreach(IColumn column in columns)
+ if(!column.IsAutoKey && !IsAutomatic(column) && !column.IsComputed)
+ l.Add(column);
+ return l;
+ }
+ public ArrayList MakeList4(IColumns columns)
+ {
+ ArrayList l = new ArrayList();
+ foreach(IColumn column in columns)
+ if((!column.IsAutoKey && !IsAutomatic(column) && !column.IsComputed ) &&
+ (column.HasDefault==false || column.ForeignKeys.Count != 0))
+ l.Add(column);
+ return l;
+ }
+ public ArrayList ReqList(IColumns columns)
+ {
+ ArrayList l = new ArrayList();
+ foreach(IColumn column in columns)
+ if(IsRequired(column) && !column.IsComputed && !column.IsAutoKey)
+ l.Add(column);
+ return l;
+ }
+ public ArrayList ReqListNoDefault(IColumns columns)
+ {
+ ArrayList l = new ArrayList();
+ foreach(IColumn column in columns)
+ if(IsRequired(column) && !column.IsComputed && !column.IsAutoKey && column.HasDefault)
+ l.Add(column);
+ return l;
+ }
+ public ArrayList MakeList2(IColumns columns)
+ {
+ ArrayList l = new ArrayList();
+ foreach(IColumn column in columns)
+ if(!column.IsAutoKey && !column.IsComputed)
+ l.Add(column);
+ return l;
+ }
+ public ArrayList MakeList3(IColumns columns)
+ {
+ ArrayList l = new ArrayList();
+ foreach(IColumn column in columns)
+ if(IsAutomatic(column))
+ l.Add(column);
+ return l;
+ }
+ public void BuildLists(IList cols,ref string sMakeListParamTypes, ref string sMakeListParams,
+ ref string sSetTmp, ref string sParentCheck)
+ {
+ string sep = "";
+ string sepSet = "";
+ string sPrefixType="";
+ string sPrefix="";
+ string sPrefixSet="";
+ string sCheckSep = "if( ";
+ sMakeListParamTypes = "";
+ sMakeListParams = "";
+ sSetTmp = "";
+ sParentCheck="";
+// ArrayList parentCols = new ArrayList();
+ foreach(IColumn col in cols)
+ {
+ sMakeListParamTypes += sep + FormatColumn("{!rtype} {!local}",col);
+ sMakeListParams += sep + FormatColumn("{!local}",col);
+ sSetTmp += sepSet + FormatColumn("\t\t\ttmp.{!memberprop} = {!local};",col);
+ sep=", ";
+ sepSet="\r\n";
+ if(IsRelObj(col)) // If item is null, don't look it up
+ {
+ sParentCheck += sCheckSep + LocalName(RelObjProp(col)) + " != null ";
+ sCheckSep = "|| ";
+ }
+ }
+ if(sParentCheck != "")sParentCheck += ") ";
+ sMakeListParamTypes = sPrefixType + sMakeListParamTypes;
+ sMakeListParams = sPrefix + sMakeListParams;
+ sSetTmp = sPrefixSet + sSetTmp;
+ //sParentCheck=FormatColumns("{!rtype} {!local} = {autoseed};\r\n\t\t\tif (parent != null)\r\n\t\t\t{\r\n\t\t\t\t{!local} = parent;\r\n\t\t\t}\r\n\t\t\t",parentCols,"\r\n","");
+ //sParentCheck="";
+ }
+ public bool SameList(IList lst1, IList lst2)
+ {
+ ArrayList l = new ArrayList();
+ foreach(IColumn col in lst1)l.Add(col.Name);
+ foreach(IColumn col in lst2)
+ if(l.Contains(col.Name))l.Remove(col.Name);
+ else return false;
+ return l.Count ==0;
+ }
+ public string SameList2(IList lst1, IList lst2)
+ {
+ ArrayList l = new ArrayList();
+ foreach(IColumn col in lst1)l.Add(col.Name);
+ foreach(IColumn col in lst2)l.Remove(col.Name);
+ string sList="";
+ string sep="Difference: ";
+ foreach(string ss in l){
+ sList+=sep+ss;
+ sep=", ";
+ }
+ return sList;
+ }
+ public bool SameTypes(IList lst1, IList lst2)
+ {
+ if(lst1.Count != lst2.Count) return false;
+ for(int i=0;i 0)
+ {
+ _workingTable=(ITable) _TableStack[_TableStack.Count-1];
+ _TableStack.RemoveAt(_TableStack.Count-1);
+ }
+ }
+ private bool ForeignRequired(IForeignKey pk)
+ {
+ bool bRequired=true;
+ foreach(IColumn col in pk.ForeignColumns)
+ bRequired &= !col.IsNullable;
+ return bRequired;
+ }
+ private bool ForeignPrimary(IForeignKey fk)
+ {
+ bool bPrimary=true;
+ foreach(IColumn col in fk.ForeignColumns)
+ {
+ bPrimary &= col.IsInPrimaryKey;
+ }
+ return bPrimary;
+ }
+ public int FindColumn(IList cols, IColumn col)
+ {
+ for(int i=0;i= 0)
+ {
+ uniqueColumns.RemoveAt(ii);
+ }
+ else
+ {
+ uniqueColumns.Clear();
+ }
+ }
+ if(uniqueColumns.Count > 0)// This is a uniqueIndex which includes the parent columns
+ {
+ //ShowColumns(uniqueColumns,4,"Unique Index " + ind.Name);
+ retval.Add(uniqueColumns);
+ }
+ }
+ }
+ return retval;
+ }
+ public bool ContainsList(IList lst1, IList lst2)
+ {
+ foreach(IColumn col in lst2)
+ if(FindColumn(lst1,col)<0)return false;
+ return true;
+ }
+ public IList FindUnique(ArrayList lst, IList cols)
+ {
+ foreach(IList lstcols in lst)
+ {
+ if(ContainsList(cols,lstcols))return lstcols;
+ }
+ return null;
+ }
+ //public ArrayList zzFilteredColumnsAny(IColumns columns,Filter [] fs){
+ // ArrayList l = new ArrayList();
+ // foreach(IColumn column in columns)
+ // {
+ // bool check = false;
+ // foreach(Filter f in fs)check |= f(column);
+ // if(check)l.Add(column);
+ // }
+ // return l;
+ //}
+ //public ArrayList zzExcludedColumnsAny(IColumns columns,Filter [] fs){
+ // ArrayList l = new ArrayList();
+ // foreach(IColumn column in columns)
+ // {
+ // bool check = false;
+ // foreach(Filter f in fs)check |= f(column);
+ // if(!check)l.Add(column);
+ // }
+ // return l;
+ //}
+ #endregion
diff --git a/PROMS/MYGENERATION/csla_21/ForeignKeyProcessing.cs b/PROMS/MYGENERATION/csla_21/ForeignKeyProcessing.cs
new file mode 100644
index 00000000..c13c4fbf
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/ForeignKeyProcessing.cs
@@ -0,0 +1,206 @@
+// Foreign Key Processing
+ public delegate void ProcessFK(IForeignKey fk,string alias);
+ public string ParentName(IForeignKey fk)
+ {
+ if(fk == null)return "Parent";
+ string sKey = fk.ForeignColumns[0].Name;
+ if(sKey.StartsWith("Prev") || sKey.StartsWith("Prv"))return "Previous";
+ if(sKey.StartsWith("Next") || sKey.StartsWith("Nxt"))return "Next";
+ return "Parent";
+ }
+ public string ChildName(IForeignKey fk)
+ {
+ string sKey = fk.ForeignColumns[0].Name;
+ if(sKey.StartsWith("Prev") || sKey.StartsWith("Prv"))return "Next";
+ if(sKey.StartsWith("Next") || sKey.StartsWith("Nxt"))return "Previous";
+ return "Child";
+ }
+ public string ChildrenName(IForeignKey fk)
+ {
+ string sKey = fk.ForeignColumns[0].Name;
+ if(sKey.StartsWith("Prev") || sKey.StartsWith("Prv"))return "Next";
+ if(sKey.StartsWith("Next") || sKey.StartsWith("Nxt"))return "Previous";
+ return "Children";
+ }
+ public string GetAlias(Hashtable hTbl,ITable tbl)
+ {
+ string sAlias = tbl.Alias;
+ if(!hTbl.Contains(sAlias))
+ {
+ hTbl[sAlias]=0;
+ return "";
+ }
+// WriteLine("-- Hashtable count = {0}, TableName = [{1}]",hTbl.Count,tbl.Name);
+ int iAlias = 1+ (int)hTbl[sAlias];
+ hTbl[sAlias]=iAlias;
+// return "_" + iAlias.ToString();
+ return "_" + "ABCDEFGHIJKLMNOP".Substring(iAlias,1);
+ }
+ public string GetAlias(IForeignKey fk)
+ {
+ if(fk.PrimaryTable.Name == fk.ForeignTable.Name)return "";
+ // First I need to check to see if there are more than one Foreign Keys pointing to the same Primary Table
+ int count=0;
+ foreach(IForeignKey fk1 in fk.ForeignTable.ForeignKeys)
+ {
+ if(fk1.PrimaryTable.Name == fk.PrimaryTable.Name) count++;
+ }
+ if(count > 1)
+ return FormatColumns("_{prop}",fk.ForeignColumns,"","");
+ return "";
+ }
+ public void ProcessFKAlias(ITable tbl,ProcessFK pfk)
+ {
+ Hashtable dicByNames = new Hashtable();
+ foreach(ForeignKey fk in tbl.ForeignKeys)
+ {
+ if(fk.ForeignTable == tbl)
+ {
+ pfk(fk,GetAlias(dicByNames,fk.PrimaryTable));
+ }
+ }
+ }
+ private bool IsPrimaryKey(IForeignKey fk)
+ {
+// bool retval=true;
+// foreach(IColumn c in fk.ForeignColumns)retval &= c.IsInPrimaryKey;
+ return SameList(fk.ForeignTable.PrimaryKeys,fk.ForeignColumns);
+// return retval;
+// return IsPrimaryKey(fk.ForeignColumns);
+ }
+ private bool IsPrimaryKey1(IForeignKey fk)
+ {
+// bool retval=true;
+// foreach(IColumn c in fk.ForeignColumns)retval &= c.IsInPrimaryKey;
+ return SameList(fk.PrimaryTable.PrimaryKeys,fk.PrimaryColumns);
+// return retval;
+// return IsPrimaryKey(fk.ForeignColumns);
+ }
+ private string ColumnList(IColumns cols)
+ {
+ string retval="";
+ string sep = "";
+ foreach(IColumn col in cols)
+ {
+ retval += sep + col.Name;
+ sep = ", ";
+ }
+ return retval;
+ }
+ private bool IsPrimaryKey(IColumns cols)
+ {
+ ITable tbl = cols[0].Table;
+ int match = tbl.PrimaryKeys.Count;
+ foreach(IColumn col in cols)
+ {
+ if(col.Table.Name != tbl.Name)
+ {
+// WriteLine("Table Mismatch - {0},{1}",col.Table.Name,tbl.Name);
+ return false; // If it points to multiple tables, it is not a primary key
+ }
+ if(col.IsInPrimaryKey)match --;
+ else
+ {
+// WriteLine("Not In Primary Key {0} in {1} ({2})",col.Name, tbl.Name, ColumnList(tbl.PrimaryKeys));
+ return false;
+ }
+ }
+// WriteLine("Match = {0}",match);
+ return match==0;
+ }
+ private bool IsPrimaryKey(IColumns cols1,IColumns cols2)
+ {
+ ITable tbl = cols1[0].Table;
+ int match = tbl.PrimaryKeys.Count;
+ foreach(IColumn col in cols1)
+ {
+ if(col.Table.Name != tbl.Name)
+ {
+// WriteLine("Table Mismatch - {0},{1}",col.Table.Name,tbl.Name);
+ return false; // If it points to multiple tables, it is not a primary key
+ }
+ if(col.IsInPrimaryKey)match --;
+ else
+ {
+// WriteLine("Not In Primary Key {0} in {1} ({2})",col.Name, tbl.Name, ColumnList(tbl.PrimaryKeys));
+ return false;
+ }
+ }
+// WriteLine("Match = {0}",match);
+ foreach(IColumn col in cols2)
+ {
+ if(col.Table.Name != tbl.Name)
+ {
+// WriteLine("Table Mismatch - {0},{1}",col.Table.Name,tbl.Name);
+ return false; // If it points to multiple tables, it is not a primary key
+ }
+ if(col.IsInPrimaryKey)match --;
+ else
+ {
+// WriteLine("Not In Primary Key {0} in {1} ({2})",col.Name, tbl.Name, ColumnList(tbl.PrimaryKeys));
+ return false;
+ }
+ }
+// WriteLine("Match = {0}",match);
+ return match==0;
+ }
+ private bool ManyToMany(ITable tbl,IForeignKey fk,IForeignKey pk)
+ {
+ if(tbl != fk.PrimaryTable)return false;// It should be the Primary Table
+ if(tbl == pk.PrimaryTable)return false;// It should not loop back to the Primary Table
+ if(fk.PrimaryTable == fk.ForeignTable)return false;// Ignore Parent/Child relationships
+ if(pk.PrimaryTable == pk.ForeignTable)return false;// Ignore Parent/Child relationships
+ // Now for the detail check - the primary columns in each foreign key should be the primary key in the primary table
+// WriteLine("Checking Primary Keys - {0}",tbl.Name);
+ if(!IsPrimaryKey(fk.PrimaryColumns))return false;
+ if(!IsPrimaryKey(pk.PrimaryColumns))return false;
+ // And the foreign columns from both foreign keys should be the primary key in the foreigntable
+// WriteLine("Checking Foreign Keys - {0}",tbl.Name);
+ if(!IsPrimaryKey(fk.ForeignColumns,pk.ForeignColumns))return false;
+ return true;
+ }
+ private bool OneToOne(ITable tbl)
+ {
+ // Check to see if the Primary Key is also the Foreign Part of a Foreign Key
+ foreach(IColumn col in tbl.PrimaryKeys)
+ {
+ if(IsPrimaryKey(col))
+ {
+ foreach(IForeignKey fk in col.ForeignKeys)
+ {
+ //WriteLine("{0} {1} {2} {3} {4}",fk.Name,fk.PrimaryTable.Name,fk.ForeignTable.Name,
+ //fk.ForeignTable.Name == tbl.Name, fk.PrimaryTable.Name != tbl.Name);
+ if(fk.ForeignTable.Name == tbl.Name && fk.PrimaryTable.Name != tbl.Name )
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ private bool AnyNotOneToOne(ITable tbl)
+ {
+ bool retval = true;
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ if(fk.ForeignTable == tbl)
+ {
+ if(!OneToOne(fk))return true;
+ //WriteLine("{0} {1} {2} {3} {4}",fk.Name,fk.PrimaryTable.Name,fk.ForeignTable.Name,
+ // fk.ForeignTable.Name == tbl.Name, fk.PrimaryTable.Name != tbl.Name);
+ retval = false;
+ }
+ }
+ return retval;
+ }
+ private bool OneToOne(IForeignKey fk1)
+ {
+ ITable tbl=fk1.ForeignTable; // Check to see if the Primary Key is also the Foreign Part of a Foreign Key
+// WriteLine("{0} {1} {2} {3} {4}",fk1.Name,fk1.PrimaryTable.Name,fk1.ForeignTable.Name,
+// fk1.ForeignTable.Name == tbl.Name, fk1.PrimaryTable.Name != tbl.Name);
+ foreach(IColumn col in fk1.ForeignColumns)
+ {
+// WriteLine("Column {0} Primary {1}",col.Name,IsPrimaryKey(col));
+ if(!IsPrimaryKey(col))return false;
+ }
+ return true;
+ }
diff --git a/PROMS/MYGENERATION/csla_21/FormatColumns.cs b/PROMS/MYGENERATION/csla_21/FormatColumns.cs
new file mode 100644
index 00000000..332b6037
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/FormatColumns.cs
@@ -0,0 +1,519 @@
+//// FormatColumns
+// private string FormatColumnOld(string sFormat,IColumn column,string sAlias)
+// {
+// string s=sFormat;
+// s=s.Replace("{member}",ColumnToMemberVariable(column));//m - Member _firstname
+// s=s.Replace("{fmember}",(column.Table.Name==_workingTable.Name?"":"_" + ToClassName(column.Table.Name).ToLower() + sAlias)+ColumnToMemberVariable(column));//m - Member _firstname
+// s=s.Replace("{pmember}",(column.Table.Name==_workingTable.Name?"":ToClassName(column.Table.Name).ToLower() + sAlias)+"."+ColumnToPropertyName(column));//m - Member _firstname
+// s=s.Replace("{local}",ColumnToMemberVariable(column).Substring(1));//l Local firstname
+// s=s.Replace("{prop}",ColumnToPropertyName(column));
+// s=s.Replace("{memberprop}",(column.IsInPrimaryKey ? ColumnToMemberVariable(column) : ColumnToPropertyName(column)));
+// s=s.Replace("{@}",ColumnToParameterName(column));
+// s=s.Replace("{@new}",ColumnToNewParameterName(column));
+// string cType = ColumnToCSLAType(column);
+// s=s.Replace("{ctype}",cType);
+// s=s.Replace("{rmember}",vlnReturnMember(cType));
+// s=s.Replace("{rtype}",vlnReturnType(cType));
+//// s=s.Replace("{dbtype}",ColumnToMemberVariable(column).Substring(1));
+// s=s.Replace("{name}",column.Name);
+// s=s.Replace("{class}",ToClassName(column.Table.Alias.Replace( " ", "" )));
+// s=s.Replace("{fname}",(column.Table.Name==_workingTable.Name?"":column.Table.Name.Replace(" ","")+sAlias+"_")+column.Name);
+// s=s.Replace("{sqltype}",ColumnToSQLDbType(column));
+// s=s.Replace("{?ref}",(column.IsComputed || column.IsAutoKey ? "ref " : ""));
+// s=s.Replace("{?dbtype}",(ColumnToCSLAType( column )=="SmartDate" ? ".DBValue" : ""));
+// s=s.Replace("{?dbprefix}",(ColumnToCSLAType( column )=="SmartDate" ? "new SmartDate(" : ""));
+// s=s.Replace("{?dbsuffix}",(ColumnToCSLAType( column )=="SmartDate" ? ").DBValue" : ""));
+// s=s.Replace("{?dbsuff}",(ColumnToCSLAType( column )=="SmartDate" ? ")" : ""));
+// s=s.Replace("{default}",ColumnDefault(column));
+// //s=s.Replace("{xxx}","");
+// return s;
+// }
+// private string FormatColumnOld(string sFormat,IColumn column)
+// {
+// return FormatColumn(sFormat,column,"");
+// }
+// private string ColumnToSQLDbType(IColumn column)
+// {
+// switch(column.DataTypeName)
+// {
+// case "timestamp":
+// return "SqlDbType.Timestamp";
+// case "int":
+// return "SqlDbType.Int";
+// default:
+// //return "//TODO: Need to fix ColumnToSQLDbType" + " " + column.DataType + " " + column.DataTypeName + " " + column.DataTypeNameComplete + " " + column.DbTargetType;
+// return "SqlDBType./* " + column.DataTypeNameComplete + " " + column.DbTargetType + "*/";
+// }
+// }
+// private string vlnReturnType(string sType)
+// {
+// string sReturnType=sType;
+// if(sType=="SmartDate")sReturnType="string";
+// return sReturnType;
+// }
+// private string vlnReturnMember(string sType)
+// {
+// string sReturnMember="";
+// return sReturnMember;
+// }
+// private string FormatColumns(string sFormat,IColumns columns)
+// {
+// return FormatColumns(sFormat,columns,"");
+// }
+// private string FormatColumns(string sFormat,IList columns,string sep)
+// {
+// string s="";
+// string ssep="";
+// foreach(IColumn column in columns)
+// {
+// s+=ssep+FormatColumn(sFormat,column);
+// ssep=sep;
+// }
+// return s;
+// }
+// private string ColumnToMemberVariable( IColumn Column )
+// {
+// return _prefix + UniqueColumn( Column ).ToLower();
+// }
+//
+// private string ColumnToPropertyName( IColumn Column )
+// {
+// return ToPascalCase( UniqueColumn( Column ) );
+// }
+//
+// private string ColumnFKToClassName( IColumn c )
+// {
+// return ToPascalCase( c.ForeignKeys[0].PrimaryTable.Alias.Replace( " ", "" ) );
+// }
+// private string ColumnToParameterName(IColumn col)
+// {
+// return "@" + ToLeadingLower(col.Name).Replace(" ","");
+// }
+// private string ColumnToNewParameterName(IColumn col)
+// {
+// return "@new" + col.Name.Replace(" ","");
+// }
+// private string ColumnToArgumentName( IColumn Column )
+// {
+// return UniqueColumn( Column ).ToLower();
+// }
+//
+// private string ColumnToNHibernateProperty( IColumn Column )
+// {
+// return _prefix + UniqueColumn( Column );
+// }
+//
+// private string UniqueColumn( IColumn Column )
+// {
+// string c = Column.Alias.Replace( " ", "" );
+// if( Column.Table != null && Column.Table.Alias.Replace( " ", "" ) == c )
+// {
+// c += "Name";
+// }
+// if( Column.View != null && Column.View.Alias.Replace( " ", "" ) == c )
+// {
+// c += "Name";
+// }
+// return c;
+// }
+//
+// // nhibernate doesn't have these, so use the existing types
+// private string ColumnToCSLAType( IColumn Column )
+// {
+// string retVal = Column.LanguageType;
+//
+// switch( Column.LanguageType )
+// {
+// case "DateTime":
+// if(Column.Description.IndexOf("{datetime}")>=0)
+// retVal="DateTime";
+// else
+// retVal = "SmartDate";
+// break;
+// // case "uint":
+// // retVal = "int";
+// // break;
+// // case "ulong":
+// // retVal = "long";
+// // break;
+// // case "ushort":
+// // retVal = "short";
+// // break;
+// }
+// return retVal;
+// }
+// private string ColumnToDefault( IColumn Column )
+// {
+// string retVal=";";
+// if(Column.DataTypeName=="timestamp")
+// {
+// retVal = " = new byte[8];//timestamp";
+// }
+// else
+// {
+// //if(Column.Default != ""){
+// // retVal = ConvertDefault(Column) + ";// TODO: Default from DB " + RemoveParens(Column.Default) + " ";
+// //}
+// //else
+// //{
+// switch( ColumnToCSLAType(Column ) )
+// {
+// case "string":
+// retVal = " = string.Empty;";
+// break;
+// case "DateTime":
+// retVal = " = new DateTime();";
+// break;
+// case "SmartDate":
+// retVal = " = string.Empty;";
+// break;
+// //case "Guid":
+// // retVal = "=new Guid();";
+// // break;
+// default:
+// // nothing to do here
+// break;
+// }
+// //}
+// }
+// return retVal;
+// }
+// string ConvertDefault(IColumn column)
+// {
+// string s = RemoveParens(column.Default);
+// switch(s)
+// {
+// case "getdate()":
+// if(ColumnToCSLAType(column)=="DateTime")
+// s="=DateTime.Now";
+// else
+// s="=DateTime.Now.ToShortDateString()";
+// break;
+// case "upper(suser_sname())":
+// s= "=Environment.UserName.ToUpper()";
+// break;
+// case "suser_sname()":
+// s="=Environment.UserName";
+// break;
+// default:
+// if(IsNumeric(s))s="=" + s;
+// else s="";
+// break;
+// }
+// return s;
+// }
+// string ColumnDefault(IColumn column)
+// {
+// string s = RemoveParens(column.Default);
+// switch(s)
+// {
+// case "getdate()":
+// if(ColumnToCSLAType(column)=="DateTime")
+// s="DateTime.Now";
+// else
+// s="DateTime.Now.ToShortDateString()";
+// break;
+// case "upper(suser_sname())":
+// s= "Environment.UserName.ToUpper()";
+// break;
+// case "suser_sname()":
+// s="Environment.UserName";
+// break;
+// default:
+// if(IsNumeric(s))s="" + s;
+// else s="";
+// break;
+// }
+// return s;
+// }
+// private string ToLeadingCaps( string name )
+// {
+// char[] chars = name.ToLower().ToCharArray();
+// chars[0] = Char.ToUpper( chars[0] );
+// return new string( chars );
+// }
+//
+//
+// private string ToPascalCase( string name )
+// {
+// string notStartingAlpha = Regex.Replace( name, "^[^a-zA-Z]+", "" );
+// string workingString = ToLowerExceptCamelCase( notStartingAlpha );
+// workingString = RemoveSeparatorAndCapNext( workingString );
+// return workingString;
+// }
+// private string ToClassName(string name)
+// {
+// return Regex.Replace(ToPascalCase(name),"s$","");
+// }
+// private string RemoveSeparatorAndCapNext( string input )
+// {
+// string dashUnderscore = "-_";
+// string workingString = input;
+// char[] chars = workingString.ToCharArray();
+// int under = workingString.IndexOfAny( dashUnderscore.ToCharArray() );
+// while( under > -1 )
+// {
+// chars[ under + 1 ] = Char.ToUpper( chars[ under + 1 ], CultureInfo.InvariantCulture );
+// workingString = new String( chars );
+// under = workingString.IndexOfAny( dashUnderscore.ToCharArray(), under + 1 );
+// }
+// chars[ 0 ] = Char.ToUpper( chars[ 0 ], CultureInfo.InvariantCulture );
+// workingString = new string( chars );
+// return Regex.Replace( workingString, "[-_]", "" );
+// }
+// private string ToLowerExceptCamelCase( string input )
+// {
+// char[] chars = input.ToCharArray();
+// for( int i = 0; i < chars.Length; i++ )
+// {
+// int left = ( i > 0 ? i - 1 : i );
+// int right = ( i < chars.Length - 1 ? i + 1 : i );
+// if( i != left && i != right )
+// {
+// if( Char.IsUpper( chars[i] ) && Char.IsLetter( chars[ left ] ) && Char.IsUpper( chars[ left ] ) )
+// {
+// chars[i] = Char.ToLower( chars[i], CultureInfo.InvariantCulture );
+// }
+// else if( Char.IsUpper( chars[i] ) && Char.IsLetter( chars[ right ] ) && Char.IsUpper( chars[ right ] ) )
+// {
+// chars[i] = Char.ToLower( chars[i], CultureInfo.InvariantCulture );
+// }
+// else if( Char.IsUpper( chars[i] ) && !Char.IsLetter( chars[ right ] ) )
+// {
+// chars[i] = Char.ToLower( chars[i], CultureInfo.InvariantCulture );
+// }
+// }
+// }
+// chars[ chars.Length - 1 ] = Char.ToLower( chars[ chars.Length - 1 ], CultureInfo.InvariantCulture );
+// return new string( chars );
+// }
+ private string FormatColumnNew(string sFormat,IColumn column)
+ {
+ return FormatColumnNew(sFormat,column,"");
+ }
+ private string FormatColumnNew(string sFormat,IColumn col,string sAlias)
+ {
+ string s=sFormat;
+ IColumn column = col.Table.Columns[col.Name];
+// IForeignKey fkkk = RelObjFK(column);
+ string relProp=RelObjProp(column);
+ string relType=RelObjType(column);
+ string suffix = "";//(PropertyName(column)==ClassName(column.Table)?"Fld":"");
+ s=s.Replace("{member}",MemberName(column)+suffix);//m - Member _firstname
+ s=s.Replace("{fmember}",(column.Table.Alias==_tableName?"":_prefix + ClassName(column.Table)+sAlias)+MemberName(column)+suffix);//m - Member _firstname
+ s=s.Replace("{pmember}",(column.Table.Alias==_tableName?_prefix:LocalName(ClassName(column.Table))+".")+PropertyName(column)+suffix);//m - Member _firstname
+ s=s.Replace("{rmember}",LocalName(ClassName(column.Table))+"."+PropertyName(column));//m - Member _firstname
+ s=s.Replace("{!prop}",relProp);
+ s=s.Replace("{!member}",MemberName(relProp));
+// s=s.Replace("{!membercolumn}",MemberName(relProp) + (IsRelObj(column)?"." + RelObjCol(column):""));
+ s=s.Replace("{!membercolumn}",MemberName(relProp) + (IsRelObj(column)?"." + RelObjProp(RelObjCol2(column)):""));
+ s=s.Replace("{!local}",LocalName(relProp));
+ s=s.Replace("{!localcolumn}",LocalName(relProp) + (IsRelObj(column)?"." + RelObjCol(column):""));
+ s=s.Replace("{!type}",relType);
+ s=s.Replace("{!rtype}",ReturnType(relType));
+ s=s.Replace("{!memberprop}",(column.IsInPrimaryKey ? MemberName(relProp) : relProp)+suffix);
+ s=s.Replace("{!propmember}",(IsRelObj(column) ? relProp : MemberName(relProp))+suffix);
+ s=s.Replace("{!column}",RelObjCol(column));
+ s=s.Replace("{!empty}",RelObjEmpty(column));
+ s=s.Replace("{!typecast}",RelObjTypeCast(column));
+ s=s.Replace("{local}",LocalName(column)+suffix);//l Local firstname
+ s=s.Replace("{prop}",PropertyName(column)+suffix);
+ s=s.Replace("{memberprop}",(column.IsInPrimaryKey ? MemberName(column) : PropertyName(column))+suffix);
+ s=s.Replace("{@}",ParameterName(column));
+ s=s.Replace("{@new}",NewParameterName(column));
+ string cType = CSLAType(column);
+ s=s.Replace("{ctype}",cType);
+ s=s.Replace("{ctype1}",cType.Replace("?",""));
+ s=s.Replace("{rmember}",ReturnMember(cType));
+ s=s.Replace("{rtype}",ReturnType(cType));
+// s=s.Replace("{dbtype}",LocalName(column));
+ s=s.Replace("{dtype}",DBType(column));
+ s=s.Replace("{name}",column.Name);
+ s=s.Replace("{class}",ClassName(column.Table));
+ s=s.Replace("{fname}",(column.Table.Alias==_tableName?"":ClassName(column.Table)+sAlias+"_")+column.Name);
+ s=s.Replace("{sqltype}",column.DbTargetType);
+ s=s.Replace("{?ref}",(column.IsComputed || column.IsAutoKey ? "ref " : ""));
+ s=s.Replace("{?dbtype}",(CSLAType( column )=="SmartDate" ? ".DBValue" : ""));
+ s=s.Replace("{?dbprefix}",(CSLAType( column )=="SmartDate" ? "new SmartDate(" : ""));
+ s=s.Replace("{?dbsuffix}",(CSLAType( column )=="SmartDate" ? ").DBValue" : ""));
+ s=s.Replace("{?dbsuff}",(CSLAType( column )=="SmartDate" ? ")" : ""));
+ s=s.Replace("{default}",DefaultValue(column));
+ s=s.Replace("{?output}",(column.IsComputed || column.IsAutoKey ? " output" : ""));
+ s=s.Replace("{@key}",ParamKeyName(column));
+ s=s.Replace("{tbl}",column.Table.Name + sAlias);
+ s=s.Replace("{?null}",(column.IsNullable?"=null":""));
+ s=s.Replace("{parent}",parentName(column));
+ s=s.Replace("{Parent}",ParentName(column));
+ s=s.Replace("{ParentType}",ParentTypeName(column));
+ s=s.Replace("{autoseed}",AutoSeed(column));
+ if(s.Contains("{ifLogic"))
+ {
+ string ifLogic="";
+ switch (CSLAType(column))
+ {
+ case("DateTime"):
+ ifLogic = "if ({name}.Year >= 1753 && {name}.Year <= 9999) ";
+ break;
+ case("DateTime?"):
+ ifLogic = "if ({name} != null && ((DateTime){name}).Year >= 1753 && ((DateTime){name}).Year <= 9999) ";
+ break;
+ default:
+ if(column.IsNullable && IsRelObj(column) && s.Contains("{ifLogicL"))
+ ifLogic="if({name} != null)";
+ break;
+ }
+ s=s.Replace("{ifLogicL}",ifLogic.Replace("{name}",FormatColumnNew("{!local}{?dbtype}",column,sAlias)));
+ s=s.Replace("{ifLogicP}",ifLogic.Replace("{name}",FormatColumnNew("{?dbprefix}{member}{?dbsuffix}",column,sAlias)));
+ s=s.Replace("{ifLogic@}",ifLogic.Replace("{name}",FormatColumnNew("criteria.{prop}{?dbtype}",column,sAlias)));
+ //string name = FormatColumnNew("{local}{?dbtype}",column,sAlias);
+ //s=s.Replace("{ifLogicL}",(CSLAType(column)=="DateTime"?"if (" + name + ".Year >= 1753 && " + name + ".Year <= 9999) ":"" ));
+ //name = FormatColumnNew("{?dbprefix}{member}{?dbsuffix}",column,sAlias);
+ //s=s.Replace("{ifLogicP}",(CSLAType(column)=="DateTime"?"if (" + name + ".Year >= 1753 && " + name + ".Year <= 9999) ":"" ));
+ //name = FormatColumnNew("criteria.{prop}{?dbtype}",column,sAlias);
+ //s=s.Replace("{ifLogic@}",(CSLAType(column)=="DateTime"?"if (" + name + ".Year >= 1753 && " + name + ".Year <= 9999) ":"" ));
+ }
+ return s;
+ }
+ private string FormatColumnFKNew(string sFormat,IColumn column)
+ {
+ string s=sFormat;
+ s=s.Replace("{fkname}",column.Name);
+ s=s.Replace("{fktable}",column.Table.Name);
+ return s;
+ }
+ private string FormatPKColumns(string sFormat,IForeignKey pk,string sep,string sPrefix,ref string ssep,string sAlias)
+ {
+ string s="";
+ foreach(IColumn column in pk.PrimaryTable.Columns)
+ {
+ if(!IsIn(column,pk.PrimaryColumns) && column.DataTypeName != "timestamp")
+ {
+ s+=ssep+sPrefix+FormatColumn(sFormat,column,sAlias);
+ ssep=sep;
+ }
+ }
+ return s;
+ }
+ private string FormatFKColumns(string sFormat,IForeignKey fk,string sep,string sPrefix,ref string ssep)
+ {
+ string s="";
+ foreach(IColumn column in fk.ForeignTable.Columns)
+ {
+ //if(!IsIn(column,fk.ForeignColumns))
+ //{
+ s+=ssep+sPrefix+FormatColumn(sFormat,column);
+ ssep=sep;
+ //}
+ }
+ return s;
+ }
+ private bool IsIn(IColumn column,IColumns columns)
+ {
+ foreach(IColumn col in columns)
+ if(col.Name==column.Name && col.Table.Name == column.Table.Name)
+ return true;
+ return false;
+ }
+ private string FormatColumns(string sFormat,IList columns,ref string sep,string sPrefix,ref string ssep)
+ {
+ string s="";
+ foreach(IColumn column in columns)
+ {
+ s+=ssep+sPrefix+FormatColumn(sFormat,column);
+ ssep=sep;
+ }
+ return s;
+ }
+ private string FormatColumns(string sFormat,IList columns,string sep)
+ {
+ return FormatColumns(sFormat,columns,sep,"");
+ }
+ private string FormatColumns(string sFormat,IList columns,string sep,string sPrefix)
+ {
+ string s="";
+ string ssep="";
+ foreach(IColumn column in columns)
+ {
+ s+=ssep+sPrefix+FormatColumn(sFormat,column);
+ ssep=sep;
+ }
+ return s;
+ }
+ private string FormatColumn(string sFormat,IColumn column)
+ {
+ return FormatColumn(sFormat,column,"");
+ }
+ private string FormatColumn(string sFormat,IColumn column,string sAlias)
+ {
+ return FormatColumnNew(sFormat,column,sAlias);
+ }
+ private string FormatColumns(string sFormat,IForeignKey FK,string sep,string sPrefix)
+ {
+ string s="";
+ string ssep="";
+ for(int i = 0;i 0)
+ {
+ btnOK.Enabled = true;
+ Status = string.Format("Will process: {0} {1}",status.Substring(2),lb.SelectedItems.Count);
+ }
+ else
+ {
+ Status = "Select one or more tables to process.";
+ btnOK.Enabled = false;
+ }
+ }
+ }
+ public void checkbox_onclick( GuiCheckBox control )
+ {
+ SetupOkButton();
+ }
+ public void chooseTable_onclick( GuiListBox control )
+ {
+ SetupOkButton();
+ }
+ private string GetDefault(string sName)
+ {
+ if( input.Contains( sName ) )
+ {
+ return input[sName].ToString();
+ }
+ return "";
+ }
+ <%#FILE MakeGuiCheckBox.cs %>
+
+}
+##|GUI_END
+##|BODY_MODE Markup
+##|BODY_ENGINE .Net Script
+##|BODY_LANGUAGE C#
+##|BODY_TAG_START <%
+##|BODY_TAG_END %>
+##|BODY_BEGIN
+<%
+public class GeneratedTemplate : DotNetScriptTemplate
+{
+ public GeneratedTemplate(ZeusContext context) : base(context) {}
+ //---------------------------------------------------
+ // Render() is where you want to write your logic
+ //---------------------------------------------------
+ public override void Render()
+ {
+ string dbName = input["chooseDatabase"].ToString();
+ ArrayList selectedTables = input["chooseTables"] as ArrayList;
+ foreach(string tblName in selectedTables)
+ {
+ ITable tbl = MyMeta.Databases[dbName].Tables[tblName];
+ if((bool)input["chkPrimary"])PrimaryKeys(tbl);
+ if((bool)input["chkColumns"])Details(tbl);
+ if((bool)input["chkFK"])ForeignKeys(tbl);
+ }
+ }
+ private void PrimaryKeys(ITable tbl)
+ {
+ output.writeln("Table - " + tbl.Name);
+ foreach(IColumn col in tbl.PrimaryKeys)
+ {
+ output.writeln(" Column - " + col.Name);
+ }
+ }
+ private void Details(ITable tbl)
+ {
+ Details(tbl,0);
+ }
+ private void Details(ITable tbl, int indent)
+ {
+ string sPad = "".PadRight(indent * 2);
+%> <%=sPad%> Table - <%=tbl.Name%><%
+ foreach(IColumn col in tbl.Columns)
+ {
+ %>
+ <%=sPad%> Column - <%=col.Name%> <%=col.DataTypeNameComplete%><%
+ }
+ }
+ private void ForeignKeys(ITable tbl)
+ {
+ output.writeln("Table - " + tbl.Name);
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ %>
+ ForeignKey - <%=fk.Name%>
+ Primary
+<%Details(fk.PrimaryTable,6);%>
+ Foreign
+<%Details(fk.ForeignTable,6);%><%
+ }
+ }
+}
+%>
+##|BODY_END
diff --git a/PROMS/MYGENERATION/csla_21/MakeGuiCheckBox.cs b/PROMS/MYGENERATION/csla_21/MakeGuiCheckBox.cs
new file mode 100644
index 00000000..67140b3e
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/MakeGuiCheckBox.cs
@@ -0,0 +1,14 @@
+ public GuiCheckBox MakeGuiCheckBox(string name,string caption,bool def, string helptext,int width,GuiCheckBox related,int offX, int offY)
+ {
+ GuiCheckBox tmp = ui.AddCheckBox( name, caption, def, helptext );
+ tmp.Width=width;
+ tmp.Top=related.Top+(offY<0?-offY * related.Height:offY);
+ tmp.Left=related.Left+(offX<0?-offX * related.Width:offX);
+ return tmp;
+ }
+ public GuiCheckBox MakeGuiCheckBox(string name,string caption,bool def, string helptext,int width)
+ {
+ GuiCheckBox tmp = ui.AddCheckBox( name, caption, def, helptext );
+ tmp.Width=width;
+ return tmp;
+ }
diff --git a/PROMS/MYGENERATION/csla_21/NamingConvention.cs b/PROMS/MYGENERATION/csla_21/NamingConvention.cs
new file mode 100644
index 00000000..56e7db7b
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/NamingConvention.cs
@@ -0,0 +1,468 @@
+ private string FKSelectName(ITable tbl,IForeignKey FK,string sAlias)
+ {
+ if(tbl.Name == FK.PrimaryTable.Name)return ChildName(FK) + ClassesName(tbl.Name);
+ //return ClassesName(tbl.Name) + "By" + ClassName(FK.PrimaryTable) + sAlias;
+ return ClassesName(tbl.Name) + "By" + ForeignKeyName(FK) + sAlias;
+ }
+ private string ForeignKeyName(IForeignKey FK)
+ {
+ string retval="";
+ string sep = "";
+
+ foreach(IColumn col in FK.ForeignColumns)
+ {
+ retval = retval + sep + ClassName(col.Name);
+ sep = "_And_";
+ }
+ return retval;
+ }
+ private string FKFieldName(IForeignKey fk)
+ {
+ string cName = ClassName( fk.ForeignTable );
+ string className=ClassName( fk.PrimaryTable );
+ if(className==cName)return ChildName(fk);
+ return ClassName( fk.ForeignTable );
+ }
+ private string FKFieldsName(IForeignKey fk)
+ {
+ string cName = ClassesName( fk.ForeignTable );
+ string className=ClassesName( fk.PrimaryTable );
+ if(className==cName)return ChildrenName(fk);
+ return cName;
+ }
+ private string FKClassesName(IForeignKey fk)
+ {
+ string cName = ClassesName( fk.ForeignTable );
+ string className=ClassesName( fk.PrimaryTable );
+ if(className==cName)return ChildName(fk) + ClassesName( fk.PrimaryTable );
+ return ClassName( fk.PrimaryTable ) + cName;
+ }
+ private string FKClassName(string className,IForeignKey fk)
+ {
+ string cName = ClassName( fk.ForeignTable );
+ if(className==cName)return ChildName(fk) + cName;
+ return className + cName;
+ }
+ private string FKClassName(IForeignKey fk)
+ {
+ string className=ClassName(fk.PrimaryTable);
+ return FKClassName(className,fk);
+ }
+ private string FKClassName1(string className,IForeignKey fk)
+ {
+ string cName = ClassName( fk.ForeignTable);
+ if(className==cName)return ChildName(fk) + cName;
+ return className + cName + GetAlias(fk);
+ }
+ private string FKClassName1(IForeignKey fk)
+ {
+ string className=ClassName(fk.PrimaryTable);
+ return FKClassName1(className,fk);
+ }
+ private string FKBy(IForeignKey fk)
+ {
+ if(fk.PrimaryTable.Name==fk.ForeignTable.Name)return ChildrenName(fk);
+ return "By" +FormatColumns("{prop}",fk.ForeignColumns,"_","");
+ }
+ private string FKAndString(string className,IForeignKey fk,string str)
+ {
+ string cName = ClassName( fk.ForeignTable );
+ if(className==cName)return str;
+ return "";
+ }
+ private string FKCountName(ITable tbl,IForeignKey FK,string sAlias)
+ {
+ if(tbl.Name == FK.ForeignTable.Name)return ChildName(FK);
+ return ClassName(FK.ForeignTable) + sAlias;
+ }
+ private bool FKParent(ITable tbl)
+ {
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ if(fk.PrimaryTable == fk.ForeignTable)return true;
+ }
+ return false;
+ }
+ private IForeignKey FKParentFK(ITable tbl)
+ {
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ if(fk.PrimaryTable == fk.ForeignTable)return fk;
+ }
+ return null;
+ }
+ private bool IsParentCol(IColumn col)
+ {
+ IForeignKey fk = FKParentFK(col.Table);
+ if(fk==null)return false;
+ foreach(IColumn col1 in fk.ForeignColumns)
+ {
+ if(col.Name==col1.Name)return true;
+ }
+ return false;
+ }
+ private string parentName(IColumn col)
+ {
+ IColumn colp = ParentCol(col);
+ if (colp == null)
+ {
+ if(IsRelObj(col))return LocalName(RelObjProp(col)) + "." + RelObjCol(col);
+ return LocalName(RelObjProp(col));
+ }
+ return "my" + ParentName(col.ForeignKeys[0]) + "." + PropertyName(colp.Name);
+ }
+ private string ParentName(IColumn col)
+ {
+ IColumn colp = ParentCol(col);
+ if (colp == null)
+ {
+ if(IsRelObj(col))return PropertyName(col);
+ return MemberName(RelObjProp(col));
+ }
+ return PropertyName(col.Name);
+ }
+ private string ParentRef(IColumn col)
+ {
+ IColumn colp = ParentCol(col);
+ if (colp != null) return ClassName(col.Table) + ".Get(" + RelObjTypeCast(col) + MemberName(col) + ")";
+ return null;
+ }
+ private string ParentTypeName(IColumn col)
+ {
+ IColumn colp = ParentCol(col);
+ if (colp != null) return ClassName(col.Table) + " myParent";
+ return null;
+ }
+ private IColumn ParentCol(IColumn col)
+ {
+ IForeignKey fk = FKParentFK(col.Table);
+ if(fk==null)return null;
+ return RelatedColumnF(col,fk);
+ }
+ private bool IsParentColumn(IColumn col)
+ {
+ IForeignKey fk = FKParentFK(col.Table);
+ if(fk==null)return false;
+ foreach(IColumn colf in fk.ForeignColumns)
+ if(colf.Name == col.Name)return true;
+ return false;
+ }
+ private string AutoSeed(IColumn col)
+ {
+ IForeignKey fk = FKParentFK(col.Table);
+ if(fk==null)return null;
+ IColumn colp = RelatedColumnF(col,fk);
+ if(colp==null)return "";
+ return (colp.IsAutoKey?colp.AutoKeySeed.ToString():"");
+ }
+
+ private IColumn RelatedColumn(IColumn column,IForeignKey fk){
+ if(column.Table.Name == fk.PrimaryTable.Name && fk.ForeignColumns.Count == 1){
+ return fk.ForeignColumns[0];
+ }
+ if(column.Table.Name == fk.ForeignTable.Name && fk.PrimaryColumns.Count == 1){
+ return fk.PrimaryColumns[0];
+ }
+ return null;
+ }
+ private IColumn RelatedColumnF(IColumn col,IForeignKey fk){
+ for(int i =0; i < fk.PrimaryColumns.Count;i++) // Loop through the related columns
+ {
+ IColumn pcol=fk.PrimaryColumns[i]; // This is the primary column
+ IColumn fcol=fk.ForeignColumns[i]; // This is the foreign column
+ //if(pcol.Name == col.Name && pcol.Table.Name == col.Table.Name)return fcol;
+ if(fcol.Name == col.Name && fcol.Table.Name == col.Table.Name)return pcol;
+ }
+ return null;
+ }
+ private IColumn RelatedColumnP(IColumn col,IForeignKey fk){
+ for(int i =0; i < fk.PrimaryColumns.Count;i++) // Loop through the related columns
+ {
+ IColumn pcol=fk.PrimaryColumns[i]; // This is the primary column
+ IColumn fcol=fk.ForeignColumns[i]; // This is the foreign column
+ if(pcol.Name == col.Name && pcol.Table.Name == col.Table.Name)return fcol;
+ //if(fcol.Name == col.Name && fcol.Table.Name == col.Table.Name)return pcol;
+ }
+ return null;
+ }
+ private IColumn RelatedColumnB(IColumn col,IForeignKey fk){
+ for(int i =0; i < fk.PrimaryColumns.Count;i++) // Loop through the related columns
+ {
+ IColumn pcol=fk.PrimaryColumns[i]; // This is the primary column
+ IColumn fcol=fk.ForeignColumns[i]; // This is the foreign column
+ if(pcol.Name == col.Name && pcol.Table.Name == col.Table.Name)return fcol;
+ if(fcol.Name == col.Name && fcol.Table.Name == col.Table.Name)return pcol;
+ }
+ return null;
+ }
+ private string ProcessName(Match m)
+ {
+ return m.Value.TrimStart("-_ ".ToCharArray()).ToUpper();
+ }
+ private string Suffix(IColumn col)
+ {
+ //return (PropertyName(col.Name)==_className?"Fld":"");
+ return (PropertyName(col.Name)==ClassName(col.Table.Name)?"Fld":"");
+ }
+ private string PropertyName(IColumn col)
+ {
+ return PropertyName(col.Name)+Suffix(col);
+ }
+ private string PropertyName(string name)
+ {
+ return Regex.Replace(name, "^[a-z]|[-_ ][a-zA-Z0-9]",new MatchEvaluator(ProcessName));
+ }
+ private bool MixedCase(string s)
+ {
+ bool hasUpper = false;
+ bool hasLower = false;
+ foreach (char c in s.ToCharArray())
+ {
+ hasUpper |= Char.IsUpper(c);
+ hasLower |= char.IsLower(c);
+ if (hasLower && hasUpper) return true;
+ }
+ return false;
+ }
+ private string MemberName(string name)
+ {
+ return _prefix + name;
+ }
+ private string MemberName(IColumn c)
+ {
+ return MemberName(PropertyName(c));
+ }
+ private string LocalName(IColumn col)
+ {
+ return LocalName(col.Name)+Suffix(col);
+ }
+ private string LocalName(string s)
+ {
+ s=PropertyName(s);
+ if(MixedCase(s))return ToLeadingLower(s);
+ else return s.ToLower();
+ }
+ private string ClassName(string name)
+ {
+ return SingularName(PropertyName(name));
+ }
+ private string ClassName(ITable table)
+ {
+ return ClassName(table.Alias);
+ }
+ private string ClassName(IView view)
+ {
+ return ClassName(view.Alias);
+ }
+ private string ClassName(IColumn column)
+ {
+ if(column.Table != null)return ClassName(column.Table);
+ if(column.View != null)return ClassName(column.View);
+ return null;
+ }
+ private string ClassesName(string name)
+ {
+ return PluralName(PropertyName(name));
+ }
+ private string ClassesName(ITable table)
+ {
+ return ClassesName(table.Alias);
+ }
+ private string ClassesName(IView view)
+ {
+ return ClassesName(view.Name);
+ }
+ private string ClassesName(IColumn column)
+ {
+ if(column.Table != null)return ClassesName(column.Table);
+ if(column.View != null)return ClassesName(column.View);
+ return null;
+ }
+ private string SingularName(string s)
+ {
+ if(Regex.IsMatch(s,"crises$"))return Regex.Replace(s,"crises$","crisis");
+ if(Regex.IsMatch(s,"uses$"))return Regex.Replace(s,"uses$","us");
+ if(Regex.IsMatch(s,"is$"))return s;
+ if(Regex.IsMatch(s,"us$"))return s;
+ if(Regex.IsMatch(s,"sses$"))return Regex.Replace(s,"sses$","ss");
+ if(Regex.IsMatch(s,"ches$"))return Regex.Replace(s,"ches$","ch");
+ if(Regex.IsMatch(s,"ies$"))return Regex.Replace(s,"ies$","y");
+ if(Regex.IsMatch(s,"ss$"))return s;
+ return Regex.Replace(s,"s$","");
+ }
+ private string PluralName(string s)
+ {
+ s=SingularName(s);
+ if(Regex.IsMatch(s,"crisis$"))return Regex.Replace(s,"crisis$","crises");
+ if(Regex.IsMatch(s,"us$"))return Regex.Replace(s,"us$","uses");
+ if(Regex.IsMatch(s,"ises$"))return s;
+ if(Regex.IsMatch(s,"uses$"))return s;
+ if(Regex.IsMatch(s,"ss$"))return Regex.Replace(s,"ss$","sses");
+ if(Regex.IsMatch(s,"ch$"))return Regex.Replace(s,"ch$","ches");
+ if(Regex.IsMatch(s,"y$"))return Regex.Replace(s,"y$","ies");
+ return s + "s";
+ }
+ private string ReturnType(string type)
+ {
+ if(type=="SmartDate")type="string";
+ return type;
+ }
+ private string ReturnMember(string type)
+ {
+ string member="";
+ return member;
+ }
+ private string CSLAType(IColumn column)
+ {
+ return CSLAType(column,(column.IsNullable? "?":""));
+ }
+ private string CSLAType(IColumn column,string suffix)
+ {
+ string type = column.LanguageType;
+ switch( column.LanguageType )
+ {
+ case "DateTime":
+ if(column.Description.IndexOf("{datetime}")>=0)
+ type="DateTime" + suffix;
+ else
+ type = "SmartDate";
+ break;
+ case "short":
+ type="Int16" + suffix;
+ break;
+ case "string":
+ break;
+ case "byte[]":
+ break; default:
+ type += suffix;
+ break;
+ // case "uint":
+ // retVal = "int";
+ // break;
+ // case "ulong":
+ // retVal = "long";
+ // break;
+ // case "ushort":
+ // retVal = "short";
+ // break;
+
+ }
+ return type;
+ }
+ string DefaultValue(IColumn column)
+ {
+ string s = RemoveParens(column.Default);
+ switch(s)
+ {
+ case "getdate()":
+ if(CSLAType(column)=="DateTime")
+ s="DateTime.Now";
+ else
+ s="DateTime.Now.ToShortDateString()";
+ break;
+ case "upper(suser_sname())":
+ s= "Environment.UserName.ToUpper()";
+ break;
+ case "suser_sname()":
+ s="Environment.UserName";
+ break;
+ default:
+ if(IsNumeric(s))s="" + s;
+ else s="";
+ break;
+ }
+ return s;
+ }
+ private string InitializeValue( IColumn Column )
+ {
+ string retVal=";";
+ if(Column.DataTypeName=="timestamp")
+ {
+ retVal = " = new byte[8];//timestamp";
+ }
+ else
+ {
+ //if(Column.Default != ""){
+ // retVal = ConvertDefault(Column) + ";// TODO: Default from DB " + RemoveParens(Column.Default) + " ";
+ //}
+ //else
+ //{
+ switch( CSLAType(Column ) )
+ {
+ case "string":
+ retVal = " = string.Empty;";
+ break;
+ case "DateTime":
+ retVal = " = new DateTime();";
+ break;
+ case "SmartDate":
+ retVal = " = string.Empty;";
+ break;
+ //case "Guid":
+ // retVal = "=new Guid();";
+ // break;
+ default:
+ // nothing to do here
+ break;
+ }
+ //}
+ }
+ return retVal;
+ }
+ public static bool IsNumeric(string stringToTest)
+ {
+ double newVal;
+ return double.TryParse(stringToTest, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out newVal);
+ }
+ private string RemoveParens(string s)
+ {
+ while(s.StartsWith("(") && s.EndsWith(")"))
+ s=s.Substring(1,s.Length-2);
+ return s;
+ }
+ private string ParameterName(IColumn column)
+ {
+ return "@" + PropertyName(column.Name);
+ }
+ private string NewParameterName(IColumn column)
+ {
+ return "@new" + PropertyName(column.Name);
+ }
+ private string ParamKeyName(IColumn column)
+ {
+ if(column.IsAutoKey)return NewParameterName(column);
+ return ParameterName(column);
+ }
+ private string ToLeadingLower( string name )
+ {
+ char[] chars = name.ToCharArray();
+ chars[0] = Char.ToLower( chars[0] );
+ return new string( chars );
+ }
+ private string DBType(IColumn column)
+ {
+ string s=column.DataTypeNameComplete;
+ switch(s){
+ case "text":
+ s="varchar(MAX)";
+ break;
+ case "ntext":
+ s="nvarchar(MAX)";
+ break;
+ }
+ return s;
+ }
+// Old ----------------------------------------------
+// private string ToClassName(string name)
+// {
+// return Regex.Replace(ToPascalCase(name),"s$","");
+// }
+// private string ColumnToMemberVariable( IColumn Column )
+// {
+// return _prefix + UniqueColumn( Column ).ToLower();
+// }
+//
+// private string ColumnToPropertyName( IColumn Column )
+// {
+// return ToPascalCase( UniqueColumn( Column ) );
+// }
diff --git a/PROMS/MYGENERATION/csla_21/WriteLine.cs b/PROMS/MYGENERATION/csla_21/WriteLine.cs
new file mode 100644
index 00000000..25f93007
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/WriteLine.cs
@@ -0,0 +1,27 @@
+ private void WriteLine(string format,params object [] args)
+ {
+ output.writeln(string.Format(format,args));
+ }
+ private void Write(string format,params object [] args)
+ {
+ output.write(string.Format(format,args));
+ }
+ private void WriteProp(object arg)
+ {
+ WriteProp(",",arg,"");
+ }
+ private void WriteProp(string prefix,object arg,string suffix)
+ {
+ try
+ {
+ if(arg.GetType()==typeof(string))Write("{0}\"{1}\"{2}",prefix,arg,suffix);
+ else if(arg.GetType().IsPrimitive)Write("{0}{1}{2}",prefix,arg,suffix);
+ else Write("{0}\"{1}\"{2}",prefix,arg,suffix);
+ }
+ catch(Exception)
+ {
+ Write("{0}{2}",prefix,arg,suffix);
+ }
+ }
+
+
diff --git a/PROMS/MYGENERATION/csla_21/vlnCSLA_SQL.csgen b/PROMS/MYGENERATION/csla_21/vlnCSLA_SQL.csgen
new file mode 100644
index 00000000..f866434c
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/vlnCSLA_SQL.csgen
@@ -0,0 +1,722 @@
+##|TYPE Template
+##|UNIQUEID d6b504d5-d9c6-42fe-8819-07780ea72506
+##|TITLE CSLA Stored Procedures - Volian
+##|NAMESPACE CSLA_21
+##|SOURCE_TYPE Source
+##|OUTPUT_LANGUAGE Transact-SQL
+##|GUI_ENGINE .Net Script
+##|GUI_LANGUAGE C#
+##|GUI_BEGIN
+
+public class GeneratedGui : DotNetScriptGui
+{
+ public GeneratedGui(ZeusContext context) : base(context) {}
+
+ //-----------------------------------------
+ // The User Interface Entry Point
+ //-----------------------------------------
+ public override void Setup()
+ {
+ 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;
+ 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", GetDefault("defaultOutputPath"), "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;
+
+ GuiLabel label2 = ui.AddLabel( "label2", "Namespace: ", "Provide your objects namespace." );
+ label2.Width = 280;
+ GuiTextBox classNamespace = ui.AddTextBox( "classNamespace", "Volian.Object.Library", "Provide your objects namespace." );
+ classNamespace.Width = 280;
+
+ GuiLabel label3 = ui.AddLabel( "label3", "Member prefix: ", "Provide your member prefix." );
+ label3.Width = 100;
+ label3.Top = label2.Top;
+ label3.Left = label2.Width + 20;
+ GuiTextBox memberPrefix = ui.AddTextBox( "memberPrefix", "_", "Provide your member prefix." );
+ memberPrefix.Width = 100;
+ memberPrefix.Top = classNamespace.Top;
+ memberPrefix.Left = classNamespace.Width + 20;
+
+ GuiLabel label3A = ui.AddLabel( "label3A", "dbConnection: ", "Provide a Connection Name." );
+ label3A.Width = 150;
+ label3A.Top = label3.Top;
+ label3A.Left = label3.Left+label3.Width + 10;
+ GuiTextBox dbConnection = ui.AddTextBox( "dbConnection", "VEPROMS", "Provide a Connection Name." );
+ dbConnection.Width = 150;
+ dbConnection.Top = memberPrefix.Top;
+ dbConnection.Left = memberPrefix.Left + memberPrefix.Width + 10;
+
+ // Setup Database selection combobox.
+ GuiLabel label4 = ui.AddLabel( "label4", "Select a database:", "Select a database in the dropdown below." );
+ label4.Width = 280;
+ GuiComboBox chooseDatabase = ui.AddComboBox( "chooseDatabase", "Select a database." );
+ chooseDatabase.Width = 280;
+
+ GuiCheckBox chkSelect = MakeGuiCheckBox( "chkSelect", "Select All", true, "Select All Records",100 );
+ GuiCheckBox chkUpdate = MakeGuiCheckBox( "chkUpdate", "Update One", true, "Update One Record" ,150,chkSelect,150,0);
+ GuiCheckBox chkFiles = MakeGuiCheckBox( "chkFiles", "Files", true, "Create Files" ,150,chkUpdate,200,0);
+ GuiCheckBox chkInsert = MakeGuiCheckBox( "chkInsert", "Insert One", true, "Insert One Record" ,150,chkSelect,0,-1);
+ GuiCheckBox chkDelete = MakeGuiCheckBox( "chkDelete", "Delete One", true, "Delete One Record" ,150,chkInsert,150,0);
+ GuiCheckBox chkSelectPK = MakeGuiCheckBox( "chkSelectPK", "Select One", true, "Select One Record" ,150,chkInsert,0,-1);
+ GuiCheckBox chkExists = MakeGuiCheckBox("chkExists","Exists",true,"Check Record Exists",150,chkSelectPK,150,0);
+ GuiCheckBox chkPurge = MakeGuiCheckBox("chkPurge","Purge",true,"Purge All Data",150,chkSelectPK,0,-1);
+ GuiCheckBox chkSelectFKs = MakeGuiCheckBox("chkSelectFKs","Select Group",true,"Select by Foreign Key",150,chkPurge,150,0);
+
+ // Setup Tables selection multi-select listbox.
+ 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;
+ }
+ }
+ 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 + ".Object.Library";
+ }
+ private string GetDefault(string sName)
+ {
+ if( input.Contains( sName ) )
+ {
+ return input[sName].ToString();
+ }
+ return "";
+ }
+ <%#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
+{
+ public GeneratedTemplate(ZeusContext context) : base(context) {}
+ // Members
+ private string _dbName;
+ private ArrayList _selectedTables;
+ private ArrayList _selectedViews;
+ private string _exportPath;
+ private string _nameSpace;
+ private string _prefix;
+ private string _dbConnection;
+ private string _tableName;
+ private string _className="";
+ private ITable _workingTable;
+ //private Hashtable dicRead;
+ //private Hashtable dicReadI;
+ public void SaveFile(string sProc)
+ {
+ if((bool)input["chkFiles"]){
+ output.save( Path.Combine( _exportPath, sProc + ".SQL" ), false );
+ //output.writeln("--" + Path.Combine( _exportPath, "CSLA.SQL" ));
+ output.clear();
+ }
+ }
+ public delegate bool Filter(IColumn column);
+ //---------------------------------------------------
+ // Render() is where you want to write your logic
+ //---------------------------------------------------
+ public override void Render()
+ {
+ if(context.Objects.ContainsKey("DnpUtils"))DnpUtils.SaveInputToCache(context);
+ InitializeMembers();
+ if((bool)input["chkPurge"])SQLPurge();
+ foreach(string sTable in _selectedTables)
+ {
+ ITable tbl = MyMeta.Databases[_dbName].Tables[sTable];
+ _workingTable=tbl;
+ if((bool)input["chkSelect"])SQLSelect(tbl);// Load all records
+ if((bool)input["chkUpdate"])SQLUpdate(tbl);// Update single record based upon Primary Key
+ if((bool)input["chkInsert"])SQLInsert(tbl);// Insert single record
+ if((bool)input["chkDelete"])SQLDelete(tbl);// Delete single record based upon Primary Key
+ if((bool)input["chkSelectPK"])SQLSelectPK(tbl);// Load one record by Primary Key
+ if((bool)input["chkSelectPK"])SQLSelectUnique(tbl);// Load one record by Primary Key
+ if((bool)input["chkSelectPK"])SQLSelectParent(tbl);// Load one record by Primary Key
+ if((bool)input["chkExists"])SQLExists(tbl);// Check for existance by Primary Key
+ if((bool)input["chkSelectFKs"])SQLSelectFKs(tbl);// Load all records by Foreign Keys
+ //SQLIndexes(tbl);
+ }
+ _exportPath = input["outputPath"].ToString();
+ //SaveFile();
+ }
+ private void SQLIndexes(ITable tbl)
+ {
+ foreach(IIndex ind in tbl.Indexes)
+ {
+ if(!ind.Name.StartsWith("PK_"))
+ {
+ output.writeln(ind.Name);
+ foreach(IColumn col in ind.Columns)
+ {
+ output.writeln(" " + col.Name);
+ }
+ }
+ }
+ }
+ private IColumn IntegerIdentity(ITable tbl)
+ {
+ if(tbl.PrimaryKeys.Count == 1){
+ IColumn c = tbl.PrimaryKeys[0];
+ if(c.IsAutoKey && c.DataTypeName != "Guid")return c;
+ }
+ return null;
+ }
+ private void SQLPurge()
+ {
+ StartProc("purgeData");
+ %>
+AS<%
+ ArrayList toProcess = new ArrayList();
+ ArrayList processed = new ArrayList();
+ foreach(string sTable in _selectedTables)
+ {
+ toProcess.Add(MyMeta.Databases[_dbName].Tables[sTable]);
+ }
+ while(toProcess.Count > processed.Count)
+ {
+ int pCount = processed.Count;
+ foreach(ITable tbl in toProcess)
+ {
+ if(!processed.Contains(tbl))
+ {
+ int count=0;
+ IColumn colid = IntegerIdentity(tbl);
+ string sSeed = (colid==null?"0":(colid.AutoKeySeed - colid.AutoKeyIncrement).ToString());
+// output.writeln(string.Format("111 - {0} - {1},{2}",colid.Name,colid.AutoKeySeed,colid.AutoKeyIncrement));
+ string sWhere = "";
+ foreach(ForeignKey fk in tbl.ForeignKeys)
+ {
+ if(fk.PrimaryTable.Name == tbl.Name)
+ {
+ if(fk.ForeignTable.Name != tbl.Name)
+ {
+ if(toProcess.Contains(fk.ForeignTable) && !processed.Contains(fk.ForeignTable))
+ count++;
+ }
+ else
+ {
+ // sWhere = string.Format(" WHERE {0} <> {1}",colid.Name,colid.AutoKeySeed);
+ // sSeed = (colid==null?"0":(colid.AutoKeySeed + colid.AutoKeyIncrement).ToString());
+// // output.writeln(string.Format("222 - {0} - {1},{2}",colid.Name,colid.AutoKeySeed,colid.AutoKeyIncrement));
+ }
+ }
+ }
+ if(count == 0)
+ {
+%>
+ delete from [<%=tbl.Name%>]<%=sWhere%><%
+ // Need logic to only do this for identity columns
+ if(colid != null)
+ {
+%>
+ dbcc checkident([<%=tbl.Name%>],reseed,<%=sSeed%>)<%
+ }
+ processed.Add(tbl);
+ }
+ }
+ }
+ if(processed.Count ==pCount)return;
+ }
+ EndProc("purgeData");
+ }
+ private void InitializeMembers()
+ {
+ _dbName = input["chooseDatabase"].ToString();
+ _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();
+ }
+ //----------------------------------------------------------------------
+ // Select
+ //----------------------------------------------------------------------
+ private void SQLSelect(ITable tbl)
+ {
+ string sproc = "get" + ClassesName(tbl);
+ StartProc(sproc);
+%>
+AS
+ SELECT
+<%=FormatColumns("[{name}]",tbl.Columns,",\r\n","\t\t")%><%=FKCounts(tbl)%>
+ FROM [<%=tbl.Name%>]<%
+ EndProc(sproc);
+ }
+ private string FKCounts(ITable tbl)
+ {
+ string retval="";
+ Hashtable dicAlias = new Hashtable();
+ foreach(ForeignKey FK in tbl.ForeignKeys)
+ {
+ if(FK.PrimaryTable == tbl)
+ {
+ //string sAlias = GetAlias(dicAlias,FK.ForeignTable);
+ string sAlias = GetAlias(FK);
+ string sep="";
+ string sAliasFK = FK.ForeignTable.Name;
+ string sAliasFK2 = "";
+ if(FK.PrimaryTable == FK.ForeignTable)
+ {
+ sAliasFK=ChildrenName(FK);
+ sAliasFK2=" [" + sAliasFK + "]";
+ }
+ retval += ",\r\n\t\t(SELECT COUNT(*) FROM [" + FK.ForeignTable.Name + "]" + sAliasFK2 + " WHERE ";
+ for(int i=0;i
+ -- Update cannot be performed on <%=tbl.Name%> since it doesn't contain
+ -- any columns that are not part of the Primary Key
+<%
+ return;
+ }
+ string sproc = "update" + ClassName(tbl);
+ StartProc(sproc);
+ %>
+(
+<%=FormatColumns("{@} {dtype}{?null}",tbl.Columns,",\r\n","\t")%><%=FormatColumns("{@new} {dtype} output",Computed(tbl),"",",\r\n\t")%>
+)
+AS
+ UPDATE [<%=tbl.Name%>]
+ SET
+<%=FormatColumns("[{name}]={@}",Updatable(tbl),",\r\n","\t\t\t")%>
+ WHERE <%=FormatColumns("[{name}]={@}",NotUpdatable(tbl)," AND ","")%>
+ IF @@ROWCOUNT = 0
+ BEGIN
+ IF NOT exists(select * from [<%=tbl.Name%>] WHERE <%=FormatColumns("[{name}]={@}",PrimaryKey(tbl)," AND ","")%>)
+ RAISERROR('<%=ClassName(tbl)%> record has been deleted by another user', 16, 1)
+ ELSE
+ RAISERROR('<%=ClassName(tbl)%> has been edited by another user', 16, 1)
+ END
+<%
+ if(Computed(tbl).Count > 0){
+%>
+ SELECT <%=FormatColumns("{@new}=[{name}]",Computed(tbl),",\r\n","\t\t")%>
+ FROM [<%=tbl.Name%>] WHERE <%=FormatColumns("[{name}]={@}",tbl.PrimaryKeys," AND ","")%>
+<%
+ }
+ EndProc(sproc);
+ }
+ //----------------------------------------------------------------------
+ // Insert
+ //----------------------------------------------------------------------
+ private void SQLInsert(ITable tbl)
+ {
+ string sproc = "add" + ClassName(tbl);
+ StartProc(sproc);
+%>
+(
+<%=FormatColumns("{@} {dtype}{?null}",Insertable(tbl),",\r\n","\t")%><%=FormatColumns("{@new} {dtype} output",NotInsertable(tbl),"",",\r\n\t")%>
+)
+AS
+ INSERT INTO [<%=tbl.Name%>]
+ (
+<%=FormatColumns("[{name}]",Insertable(tbl),",\r\n","\t\t")%>
+ )
+ VALUES
+ (
+<%=FormatColumns("{@}",Insertable(tbl),",\r\n","\t\t")%>
+ )
+<%=FormatColumns("SELECT {@new}= SCOPE_IDENTITY()",AutoKey(tbl),"\r\n","\t")%><%
+ // Update Output Values
+ ArrayList cmp = Computed(tbl);
+ if(cmp.Count > 0){
+%>
+ SELECT <%=FormatColumns("{@new}=[{name}]",cmp,"\r\n","\t\t")%>
+ FROM [<%=tbl.Name%>] WHERE <%=FormatColumns("[{name}]={@key}",tbl.PrimaryKeys," AND ","")%><%
+ }
+ EndProc(sproc);
+ }
+ //----------------------------------------------------------------------
+ // Delete
+ //----------------------------------------------------------------------
+ private void SQLDelete(ITable tbl)
+ {
+ string sproc = "delete" + ClassName(tbl);
+ StartProc(sproc);
+%>
+(
+<%=FormatColumns("{@} {dtype}",tbl.PrimaryKeys,",\r\n","\t")%>
+)
+AS<%
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ if(tbl != fk.ForeignTable)
+ {
+%>
+ DELETE [<%=fk.ForeignTable.Name%>]
+ WHERE<%
+ string sep = " ";
+ for(int j=0;j
+ DELETE [<%=tbl.Name%>]
+ WHERE <%=FormatColumns("[{name}] = {@}",tbl.PrimaryKeys," AND ","")%><%
+ EndProc(sproc);
+ }
+ //----------------------------------------------------------------------
+ // SelectPK
+ //----------------------------------------------------------------------
+ private void SQLSelectPK(ITable tbl)
+ {
+ string sproc = "get" + ClassName(tbl);
+ StartProc(sproc);
+ %>
+(
+<%=FormatColumns("{@} {dtype}",tbl.PrimaryKeys,",\r\n","\t")%>
+)
+AS
+ SELECT
+<%=FormatColumns("[{name}]",tbl.Columns,",\r\n","\t\t")%><%=FKCounts(tbl)%>
+ FROM [<%=tbl.Name%>]
+ WHERE <%=FormatColumns("[{name}]={@}",tbl.PrimaryKeys," AND ","")%><%
+ // Need to loop through foreign keys and select related records
+ FKSelects(tbl);
+ EndProc(sproc);
+ }
+ 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(
+<%=FormatColumns("{@} {dtype}",ind.Columns,",\r\n","\t")%>
+)
+AS
+ SELECT
+<%=FormatColumns("[{name}]",tbl.Columns,",\r\n","\t\t")%><%=FKCounts(tbl)%>
+ FROM [<%=tbl.Name%>]
+ WHERE <%=FormatColumns("[{name}]={@}",ind.Columns," AND ","")%><%
+ // Need to loop through foreign keys and select related records
+ EndProc(sproc);
+ }
+ }
+ }
+ //----------------------------------------------------------------------
+ // SelectParent
+ //----------------------------------------------------------------------
+ private void SQLSelectParent(ITable tbl)
+ {
+ if(!FKParent(tbl))return;
+ IForeignKey fk = FKParentFK(tbl);
+ string sproc = "get" + ParentName(fk) + ClassName(tbl);
+ StartProc(sproc);
+ %>(
+<%=FormatColumns("{@} {dtype}",fk.ForeignColumns,",\r\n","\t")%>
+)
+AS
+ SELECT
+<%=FormatColumns("[{name}]",tbl.Columns,",\r\n","\t\t")%><%=FKCounts(tbl)%>
+ FROM [<%=tbl.Name%>]
+ WHERE<%
+ string sep="";
+ for(int i = 0; i
+ <%=FormatColumn("[{name}]=",fk.PrimaryColumns[i])%><%=FormatColumn("{@}",fk.ForeignColumns[i])%><%=sep%><%
+ sep=" AND";
+ }
+ EndProc(sproc);
+ }
+ //----------------------------------------------------------------------
+ // Exists
+ //----------------------------------------------------------------------
+ private void SQLExists(ITable tbl)
+ {
+ string sproc = "exists" + ClassName(tbl);
+ StartProc(sproc);
+ %>
+(
+<%=FormatColumns("{@} {dtype}",tbl.PrimaryKeys,",\r\n","\t")%>
+)
+ AS
+ SELECT COUNT(*)
+ FROM [<%=tbl.Name%>] WHERE <%=FormatColumns("[{name}]={@}",tbl.PrimaryKeys," AND ","")%><%
+ EndProc(sproc);
+ }
+ //----------------------------------------------------------------------
+ // SelectFKs
+ //----------------------------------------------------------------------
+ private void SQLSelectFKs(ITable tbl)
+ {
+ Hashtable dicAlias = new Hashtable();
+ foreach(IForeignKey FK in tbl.ForeignKeys)
+ {
+ if(tbl == FK.ForeignTable)
+ {
+ //string sAlias = GetAlias(dicAlias,FK.PrimaryTable);
+ string sAlias = GetAlias(FK);
+ SQLSelectFK(tbl,FK,sAlias);
+ }
+ }
+ }
+ private void SQLSelectFKChild(ITable tbl, IForeignKey FK,string sAlias)
+ {
+ string sproc = "get" + FKSelectName(tbl,FK,sAlias);
+ StartProc(sproc);
+%>
+(
+<%=FormatColumns2("{@} {dtype}",FK,",\r\n","\t")%>
+)
+AS
+ SELECT
+<%=FormatColumns("[{name}]",tbl.Columns,",\r\n","\t\t")%><%=FKCounts(tbl)%>
+ FROM [<%=tbl.Name%>] WHERE <%=FormatColumns2("[{fkname}]={@}",FK," AND ","")%> AND <%=FormatColumns2("[{!column}]<>{@}",FK," AND ","")%><%
+ EndProc(sproc);
+ }
+ private void SQLSelectFK(ITable tbl, IForeignKey FK,string sAlias)
+ {
+ if(FK.PrimaryTable == FK.ForeignTable){
+ SQLSelectFKChild(tbl,FK,sAlias);
+ }
+ else
+ {
+ //string sproc = "get" + FKSelectName(tbl,FK,sAlias);
+ string sproc = "get" + FKSelectName(tbl,FK,"");
+ StartProc(sproc);
+%>
+(
+<%=FormatColumns2("{@} {dtype}",FK,",\r\n","\t")%>
+)
+AS<%
+ string sWhere = "\r\n\tWHERE\r\n\t\t" + FormatColumns2("[{fktable}].[{fkname}]={@}",FK," AND ","");
+ FKSelect(FK,(FK.PrimaryTable==tbl?FK.ForeignTable:FK.PrimaryTable),FKCounts(tbl),sWhere);
+ EndProc(sproc);
+ }
+ }
+ private void StartProc(string sproc)
+ {
+ // Drop and recreate
+%>
+/****** Object: StoredProcedure [<%=sproc%>] ******/
+IF EXISTS (SELECT * FROM dbo.sysobjects WHERE id = OBJECT_ID(N'[<%=sproc%>]') AND OBJECTPROPERTY(id,N'IsProcedure') = 1)
+ DROP PROCEDURE [<%=sproc%>];
+GO
+
+CREATE PROCEDURE [dbo].[<%=sproc%>]
+<%
+ }
+ private void EndProc(string sproc)
+ {
+%>
+ RETURN
+GO
+-- Display the status of Proc creation
+IF (@@Error = 0) PRINT 'Procedure Creation: <%=sproc%> Succeeded'
+ELSE PRINT 'Procedure Creation: <%=sproc%> Error on Creation'
+GO
+<%
+ SaveFile(sproc);
+ }
+ private void FKSelects(ITable tbl)
+ {
+ foreach(ForeignKey fk in tbl.ForeignKeys)
+ {
+// WriteLine("\r\n--ForeignKey - {0} - {1}\r\n",fk.Name,IsPrimaryKey(fk));
+ if(tbl != fk.ForeignTable)
+ //if(!IsPrimaryKey(fk)) - This was removed so that one to one relationships would return records.
+ FKSelect(fk,tbl,"",BuildWhere(fk));
+ }
+ }
+ private void FKSelect(IForeignKey fk, ITable tbl, string sCounts,string sWhere)
+ {
+ string sjoin="";
+ string ssep="";
+ Hashtable dicAlias = new Hashtable();
+%>
+
+ SELECT
+<%=FormatFKColumns("[{tbl}].[{name}]",fk,",\r\n","\t\t",ref ssep)%><%
+ foreach(ForeignKey pk in fk.ForeignTable.ForeignKeys)
+ {
+// if(ManyToMany(tbl,fk,pk))
+ if(tbl != pk.PrimaryTable && fk.ForeignTable == pk.ForeignTable && pk.PrimaryTable != pk.ForeignTable && ForeignRequired(pk))
+ {
+ //string sAlias=GetAlias(dicAlias,pk.PrimaryTable);
+ string sAlias=GetAlias(pk);
+ string sJoinAdd = BuildJoin(pk,sAlias);
+ if(sJoinAdd != null) // Only add related tables that are associated with a required field
+ {
+ sjoin += sJoinAdd;
+%><%=FormatPKColumns("[{tbl}].[{name}] [{fname}]",pk,",\r\n","\t\t",ref ssep,sAlias)%><%
+ }
+ }
+ }
+%><%=sCounts%>
+ FROM [<%=fk.ForeignTable.Name%>]<%=sjoin%><%=sWhere%>
+<%
+ }
+/*
+ private string DefineAlias(IForeignKey pk,Hashtable dicAlias)
+ {
+ if(((int)dicAlias[pk.PrimaryTable.Name])==0)return "";
+ return "[" + pk.PrimaryTable.Name + "_" + dicAlias[pk.PrimaryTable.Name].ToString() + "]";
+ }
+ private string UseAlias(string tblname,Hashtable dicAlias)
+ {
+ if(((int)dicAlias[tblname])==0)return tblname;
+ return tblname + "_" + dicAlias[tblname].ToString();
+
+ }
+*/
+ private string BuildJoin(IForeignKey pk,string sAlias)
+ {
+ string sjoin="\r\n\t\tJOIN [" + pk.PrimaryTable.Name + "] " + (sAlias==""?"":"[" + pk.PrimaryTable.Name + sAlias + "]") + " ON";
+ for(int j=0;j 0)
+ {
+ btnOK.Enabled = true;
+ Status = string.Format("Will process: {0} {1}",status.Substring(2),lb.SelectedItems.Count);
+ }
+ else
+ {
+ Status = "Select one or more tables to process.";
+ btnOK.Enabled = false;
+ }
+ }
+ }
+ public void checkbox_onclick( GuiCheckBox control )
+ {
+ SetupOkButton();
+ }
+ public void chooseTable_onclick( GuiListBox control )
+ {
+ SetupOkButton();
+ }
+ private string GetDefault(string sName)
+ {
+ if( input.Contains( sName ) )
+ {
+ return input[sName].ToString();
+ }
+ return "";
+ }
+ <%#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
+{
+ public GeneratedTemplate(ZeusContext context) : base(context) {}
+ // Members
+ private string _dbName;
+ private ArrayList _selectedTables;
+ private ArrayList _selectedViews;
+ private string _exportPath;
+ private string _nameSpace;
+ private string _prefix="_";
+ private string _dbConnection;
+ private string _tableName;
+ private string _className="";
+ private ITable _workingTable;
+ private Hashtable dicIndexes;
+ private Hashtable dicDrop;
+ //private Hashtable dicRead;
+ //private Hashtable dicReadI;
+ //public void SaveFile(string sProc)
+ //{
+ // output.save( Path.Combine( _exportPath, sProc + ".SQL" ), false );
+ // //output.writeln("--" + Path.Combine( _exportPath, "CSLA.SQL" ));
+ // output.clear();
+ //}
+ public delegate bool Filter(IColumn column);
+ //---------------------------------------------------
+ // Render() is where you want to write your logic
+ //---------------------------------------------------
+ public override void Render()
+ {
+ if(context.Objects.ContainsKey("DnpUtils"))DnpUtils.SaveInputToCache(context);
+ //InitializeMembers();
+ _exportPath = input["outputPath"].ToString();
+ _dbName = input["chooseDatabase"].ToString();
+ IDatabase db = MyMeta.Databases[_dbName];
+ output.clear();
+ _selectedTables = input["chooseTables"] as ArrayList;
+ dicIndexes = new Hashtable();
+ dicDrop = new Hashtable();
+ foreach( string _newTable in _selectedTables )
+ {
+ _workingTable = MyMeta.Databases[_dbName].Tables[_newTable];
+ if((bool)input["chkDetail"])ShowTable1( _workingTable );
+ if((bool)input["chkColumns"])ShowTable2( _workingTable );
+ if((bool)input["chkFKCalc1"])ShowTable3( _workingTable );
+ if((bool)input["chkUnique"])ShowTable4( _workingTable );
+ if((bool)input["chkFKCalc2"])ShowTable5( _workingTable );
+ if((bool)input["chkColumns2"])ShowTable6( _workingTable );
+ if((bool)input["chkRelated"])ShowTable7( _workingTable );
+ if((bool)input["chkOne2One"])ShowTable8( _workingTable );
+ if((bool)input["chkIndexes"])ShowTable9( _workingTable );
+ if((bool)input["chkInternal"])ShowInternalRelated( _workingTable );
+ if((bool)input["chkAlias"])ShowAlias( _workingTable );
+ if((bool)input["chkNames"])ShowNames( _workingTable );
+ }
+ //foreach(ITable tbl in db.Tables)
+ //{
+ // ShowTable3(tbl);
+ //}
+ //foreach(IProcedure ip in db.Procedures)
+ //{
+ // if(ip.Schema != "sys" && ip.Name.StartsWith("sp_")){
+ // WriteLine("{0} {1}",ip.Name,ip.Schema);
+ // ShowProperties(ip.Properties,2);
+ // }
+ //}
+ //SaveFile();
+ }
+ private string ForeignKeyCheck(IColumn col)
+ {
+ if(col.IsInForeignKey)
+ {
+ foreach(IForeignKey fk in col.ForeignKeys)
+ {
+ if(IsIn(col,fk.ForeignColumns))return " FK";
+ }
+ return " fk";
+ }
+ return "";
+ }
+ private void ShowColumns(IList cols,int indent,string title)
+ {
+ output.writeln(string.Format("{0}{1}","".PadRight(indent),title));
+ foreach(IColumn col in cols)
+ {
+ output.writeln(string.Format("{0}{1}{2} {3}{4}{5} {6} {7} {8}",
+ (col.IsNullable?" ":"*"),
+ "".PadRight(indent+2),
+ col.Name,
+ col.DataTypeNameComplete,
+ (col.IsInPrimaryKey?" PK":""),
+ ForeignKeyCheck(col),
+ (col.IsAutoKey ? "Auto - (" + col.AutoKeySeed.ToString() + ")":""),
+ col.Default,col.Description));
+ ShowProperties(col.AllProperties,indent+2);
+ }
+ }
+ private void ShowProperties(IPropertyCollection prps, int indent)
+ {
+ if(prps.Count == 0)return;
+ output.writeln(string.Format("{0}Properties:","".PadRight(indent)));
+ foreach(IProperty prp in prps)
+ {
+ output.writeln(string.Format("{0}{1}={2}","".PadRight(indent+2),prp.Key,prp.Value));
+ }
+ }
+ 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 0){
+ output.writeln(string.Format("Table {0}",tbl.Name));
+ //ShowProperties(tbl.AllProperties,2);
+ //ShowColumns(tbl.Columns,2,"Columns:");
+ //ShowColumns(tbl.PrimaryKeys,2,"Primary Key:");
+ //output.writeln(" Foreign Keys:");
+ output.writeln(string.Format(" Name: {0} Primary Table: {1}.{2} Foreign Table: {3}"
+ ,fk.Name,fk.PrimaryTable.Name,fk.PrimaryKeyName,fk.ForeignTable.Name));
+ foreach(ArrayList al in uniqueChildren)
+ ShowColumns(al,4,"Unique Index");
+ }
+ }
+ }
+*/
+/*
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ if(tbl == fk.PrimaryTable && fk.ForeignTable != fk.PrimaryTable) // Ignore Parent/Child relationships
+ {
+ if(IsInPrimaryKey(fk.ForeignColumns) && IsInPrimaryKey(fk.PrimaryColumns)) // Are the Keys in the Primary Keys
+ {
+ foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys) // Look at other relationships
+ {
+ if(IsInPrimaryKey(pk.ForeignColumns) && IsInPrimaryKey(pk.PrimaryColumns)) // Are the Keys in the Primary Keys
+ {
+ if(pk.ForeignTable == fk.ForeignTable && pk.PrimaryTable != fk.PrimaryTable && pk.PrimaryTable != pk.ForeignTable && ForeignRequired(pk))
+ {
+ WriteLine("Many to Many [{0}] [{1}] [{2}]",fk.PrimaryTable.Name,fk.ForeignTable.Name,pk.PrimaryTable.Name);
+ }
+ }
+ }
+ }
+ }
+ }
+*/
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys) // Look at other relationships
+ {
+ if(ManyToMany(tbl,fk,pk))
+ {
+ WriteLine("Many to Many [{0}] [{1}] [{2}]",fk.PrimaryTable.Name,fk.ForeignTable.Name,pk.PrimaryTable.Name);
+ }
+ }
+ }
+ }
+ private void ShowTable5(ITable tbl)
+ {
+ output.writeln(string.Format("Table {0}",tbl.Name));
+ ShowProperties(tbl.AllProperties,2);
+ //ShowColumns(tbl.Columns,2,"Columns:");
+ //ShowColumns(tbl.PrimaryKeys,2,"Primary Key:");
+ output.writeln(" Foreign Keys:");
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ //if(_selectedTables.Contains(fk.ForeignTable.Name)){
+ output.writeln(string.Format(" Name: {0} Primary Table: {1}.{2} Foreign Table: {3}"
+ ,fk.Name,fk.PrimaryTable.Name,fk.PrimaryKeyName,fk.ForeignTable.Name));
+ //ShowColumns(fk.PrimaryColumns,6,"Primary Columns:");
+ //ShowColumns(fk.ForeignColumns,6,"Foreign Columns:");
+ //ShowRequiredColumns(fk.ForeignTable.Columns,6,"Required Foreign Columns:");
+ //ShowFK1(fk);
+ //ShowFK2(fk);
+ CheckFK(fk);
+ //}
+ }
+ }
+ private void ShowTable6a(ITable tbl)
+ {
+ string sPrefix = tbl.Name + "\r\n";
+ ArrayList fkCols = new ArrayList();
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ WriteLine("fk - {0} {1}",fk.Name,fk.ForeignTable.Name);
+ if(fk.ForeignTable != fk.PrimaryTable)
+ {
+ foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys)
+ {
+ if(pk.ForeignTable == fk.ForeignTable && pk.PrimaryTable != fk.PrimaryTable && pk.PrimaryTable != pk.ForeignTable)
+ {
+ foreach(IColumn col in pk.ForeignColumns){
+ if(!col.IsNullable){
+ WriteLine("Adding {0}", col.Name);
+ fkCols.Add(col);
+ }
+ }
+ }
+ }
+ }
+ bool bManyToMany = true;
+ if(fkCols.Count > 0){
+ // Here it is
+ string sFkKeysTypes = FormatColumns("{!type} {!local}",fkCols,", ");
+ string sFkKeys = FormatColumns("{!local}",fkCols,", ");
+ string reqKeysTypes = "";
+ string sep2="";
+ bool bParentRef=false;
+ foreach(IColumn column in fk.ForeignTable.Columns)
+ {
+ if(IsRequired(column) && !column.IsComputed && !column.IsAutoKey)
+ {
+ if(!IsIn(column,fk.ForeignColumns))
+ {
+ WriteLine("Adding1 {0}", column.Name);
+ reqKeysTypes+=sep2+FormatColumn("{!type} {!local}",column);
+ sep2=", ";
+ } else {
+ if(!bParentRef && FKParentFK(_workingTable) == fk){
+ WriteLine("Adding2 {0}", column.Name);
+ bParentRef=true;
+ reqKeysTypes=FormatColumn("{ParentType}",column)+sep2+reqKeysTypes;
+ sep2=", ";
+ }
+ }
+ }
+ }
+ WriteLine("Add - {0}",reqKeysTypes);
+ WriteLine("Check - {0}",sFkKeys);
+ WriteLine("Contains - {0}",sFkKeysTypes);
+ }
+ }
+ }
+ private void ShowTable6b(ITable tbl) // Refresh Logic
+ {
+ Hashtable dicAlias = new Hashtable();
+ foreach(IForeignKey fk in tbl.ForeignKeys) // 20070220
+ {
+ if(fk.PrimaryTable != fk.ForeignTable) // Parent Child
+ {
+ if(!IsPrimaryKey(fk) && tbl == fk.PrimaryTable){
+ // Need to determine if the PrimaryKey for the Foreign Table includes The Primary Key from this Table
+ string sAlias = GetAlias(dicAlias,fk.ForeignTable);
+ string sItem = ClassName(fk.ForeignTable);
+ string sFItem = ClassName(tbl) + ClassName(fk.ForeignTable) + sAlias;
+ string sFItems = ClassName(tbl) + 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) + ".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}";
+ string 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(this,tmp);\r\n\t\t\t}";
+ WriteLine("{0}-{1} in {2}",ForeignPrimary(fk),sFItem,sFItems);
+ }
+ }
+ }
+ }
+ private void ShowTable6(ITable tbl) // Refresh Logic
+ {
+ foreach(IForeignKey fk in tbl.ForeignKeys) // 20070220
+ {
+ WriteLine("FK - {0}", fk.Name);
+ string sepu="";
+ string sUpdate="";
+ string sTimestamp="";
+ foreach(IColumn column in fk.ForeignTable.Columns)
+ {
+ if(column.DataTypeName=="timestamp")
+ sTimestamp=FormatColumn("{member} = ",column);
+ if(!IsIn(column,fk.ForeignColumns))
+ {
+ string sRef = ParentRef(column);
+ if(sRef==null)
+ {
+ if(column.IsComputed || column.IsAutoKey)
+ sRef=FormatColumn("ref {?dbprefix}{member}{?dbsuff}",column);
+ else
+ {
+ //if(column.IsInPrimaryKey)
+ // sRef=FormatColumn("/*--->1*/{?dbprefix}{!membercolumn}{?dbsuff}",column);// 20070323
+ //else
+ if(FormatColumn("{!type}",column)==ClassName(fk.ForeignTable))
+ sRef=FormatColumn("{?dbprefix}{!membercolumn}{?dbsuff}",column);// 20070323
+ else
+ sRef=FormatColumn("{?dbprefix}{!member}{?dbsuff}",column);// 20070323
+ }
+ }
+ sUpdate+=sepu + sRef;
+ sepu=", ";
+ }
+ else
+ {
+ string sRef;
+ if(IsRelObj(column))
+ sRef = FormatColumn("{?dbprefix}{!local}{?dbsuff}",column);
+ else
+ sRef = FormatColumn("{?dbprefix}{rmember}{?dbsuff}",RelatedColumn(column,fk));
+ sUpdate+=sepu + sRef;
+ sepu=", ";
+ }
+ }
+ WriteLine(" sUpdate - {0}",sUpdate);
+ string sKeysTypesI="";
+ string sKeysI="";
+ string sValuesI="";
+ string sepi="";
+ ITable ftbl = fk.ForeignTable;
+ ITable tmpTbl = _workingTable;
+ _workingTable = ftbl;
+ foreach(IColumn column in ftbl.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 + " parent";
+ sKeysI+=sepi + "parent";
+ }
+ else
+ {
+ sKeysTypesI+=sepi + FormatColumn("{?ref}{!type} {!local}",column);
+ sKeysI+=sepi + FormatColumn("{?ref}{member}",column);
+ }
+ sepi=", ";
+ }
+ }
+ _workingTable=tmpTbl;
+ WriteLine(" KeysTypesI {0}",sKeysTypesI);
+ }
+ }
+ private void ShowInternalRelated(ITable tbl)
+ {
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ if(fk.PrimaryTable == fk.ForeignTable)
+ {
+ WriteLine("{0} - {1}",fk.PrimaryTable.Name,fk.ForeignColumns[0].Name);
+ }
+ }
+ }
+ private void ShowAlias(ITable tbl)
+ {
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ string s = GetAlias(fk);
+ if(s != "")
+ {
+ WriteLine("{0} - {1}{2}{3}",tbl.Name,ClassName(fk.PrimaryTable),fk.ForeignTable.Name,s );
+ }
+ }
+ }
+ private void ShowNames(ITable tbl)
+ {
+ WriteLine("{0} Singular {1} - Plural {2}",tbl.Name,SingularName(tbl.Name),PluralName(tbl.Name) );
+ foreach(IColumn col in tbl.Columns)
+ {
+ WriteLine(" {0} Singular {1} - Plural {2}",col.Name,SingularName(col.Name),PluralName(col.Name) );
+ }
+ }
+ private void ShowTable7a(ITable tbl)
+ {
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ foreach(IColumn column in fk.ForeignTable.Columns)
+ {
+ if(!IsIn(column,fk.ForeignColumns))
+ {
+ if(IsRequired(column) && !column.IsComputed && !column.IsAutoKey)
+ {
+ if(column.ForeignKeys.Count==1)
+ {
+ try{
+ IColumn colf = RelatedColumnF(column,fk);
+ IColumn colp = RelatedColumnP(column,fk);
+ WriteLine("'{0}','{1}','{2}','{3}','{4}','{5}'",
+ tbl.Name,
+ RelatedObject(fk,column),
+ RelatedObjectType(column),
+ RelatedObjectType2(fk,column),
+ colf,
+ colp);
+ }
+ catch(Exception)
+ {
+ WriteLine("Exception");
+ }
+ //WriteLine("RelatedObject - {0}",RelatedObject(fk,column));
+ //WriteLine("RelatedObject - {0}",RelatedObjectType2(fk,column)); // 20070301
+ //if(!column.IsInForeignKey){
+ // WriteLine(FormatColumn("\t\t\t{member} = {local};",column));
+ //}
+ //else
+ //{
+ // IForeignKey pk = column.ForeignKeys[0];
+ // IColumn colf = RelatedColumnF(column,pk);
+ // WriteLine(FormatColumn("{rmember}",colf));
+ //}
+ }
+ }
+ }
+ }
+ }
+ }
+ private void ShowTable7b(ITable tbl)
+ {
+ foreach(IColumn column in tbl.Columns)
+ {
+ if(!column.IsComputed && !column.IsAutoKey) // Exclude computed and Identity Columns
+ {
+ if(!column.IsInPrimaryKey) // Exclude Primary Key
+ {
+ if(column.ForeignKeys.Count==1) // Look for a Foreign Key on a field
+ {
+ IForeignKey fk = column.ForeignKeys[0];
+ if(fk.PrimaryTable.Name != fk.ForeignTable.Name)
+ {
+ try
+ {
+ IColumn colf = RelatedColumnF(column,fk);
+ WriteLine("'{0}','{1}','{2}','{3}'",
+ tbl.Name,
+ RelatedObjectType2(fk,column),
+ colf.Name,
+ column.Name);
+ }
+ catch(Exception)
+ {
+ WriteLine("Exception");
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ private void ShowTable7(ITable tbl)
+ {
+ foreach(IColumn col in tbl.Columns)
+ {
+ IForeignKey fk = RelObjFK(col);
+ string typ=RelObjType(col);
+ string prop=RelObjProp(col);
+ WriteLine(" {0} {1} {2} {3}",col.IsComputed,col.IsAutoKey,col.IsInPrimaryKey,col.ForeignKeys.Count);
+ WriteLine("{0} '{1}','{2}','{3}','{4}','{5}','{6}'"
+ ,(IsRelObj(col)?"* ":" ")
+ ,tbl.Name
+ ,col.Name
+ ,typ
+ ,prop
+ ,MemberName(prop)
+ ,LocalName(prop)
+ );
+ output.writeln(FormatColumn("'{tbl}','{ctype}','{prop}','{!type}','{!prop}','{!member}','{!localcolumn}'",col));
+ }
+ }
+ private void ShowTable8(ITable tbl)// Shows One to Many and One to One
+ {
+ if(OneToOne(tbl))WriteLine("{0}", tbl.Name);
+ }
+ private void ShowTable9(ITable tbl)// Shows One to Many and One to One
+ {
+ // Loop through Foreign Keys;
+ foreach(IForeignKey fk in tbl.ForeignKeys)
+ {
+ // Check the indexes for each part of the Foreign Key
+ //CheckIndex(fk.PrimaryTable,fk.PrimaryColumns);
+ CheckIndex(fk);
+ }
+ }
+ private bool DoesContain(IColumns cols,IColumn col)
+ {
+ foreach(IColumn cc in cols)
+ if(cc.Name==col.Name)return true;
+ return false;
+ }
+ private void CheckIndex(IForeignKey fk)
+ {
+ ITable tbl = fk.ForeignTable;
+ IColumns cols = fk.ForeignColumns;
+ bool InIndex = true;
+ // Check the primary keys first
+ foreach(IColumn col in cols)
+ {
+ InIndex = InIndex && col.IsInPrimaryKey;
+ }
+ if(InIndex)return;
+ string sIndexName = "IX_" + tbl.Name + FormatColumns("{prop}",cols,"_","");
+ foreach(IIndex ind in tbl.Indexes)
+ {
+ InIndex = true;
+ //WriteLine("{0} - {1} Existing Index {2} - {3}",tbl.Name,fk.Name,ind.Name,FormatColumns("{prop}",ind.Columns,", ",""));
+ //foreach(IColumn col in cols)
+ //{
+ // //WriteLine(" Index {0} ({1}) {2} {3}",ind.Name,FormatColumns("{prop}",ind.Columns,", ",""),(DoesContain(ind.Columns,col)?"Contains":"Doesn't Contain"),col.Name);
+ // InIndex = InIndex && DoesContain(ind.Columns,col);
+ //}
+ for(int i = 0; i < cols.Count; i++)
+ {
+ //WriteLine(" Index {0} ({1}) {2} {3}",ind.Name,FormatColumns("{prop}",ind.Columns,", ",""),(DoesContain(ind.Columns,col)?"Contains":"Doesn't Contain"),col.Name);
+ InIndex = InIndex && (ind.Columns[i].Name == cols[i].Name);
+ }
+ if(InIndex)
+ {
+ return;
+ if(ind.Name == sIndexName)return;
+ if(!dicDrop.ContainsKey(ind.Name))
+ {
+ WriteLine("DROP INDEX {0} ON [dbo].[{1}]",ind.Name,tbl.Name);
+ dicDrop.Add(ind.Name,ind.Name);
+ }
+ break;
+ }
+ }
+// WriteLine("Needs Index {0} - {1} - ({2})",tbl.Name,fk.Name,FormatColumns("{prop}",cols,", ",""));
+ if (dicIndexes.ContainsKey(sIndexName))return;
+ WriteLine("CREATE NONCLUSTERED INDEX {0} ON [dbo].[{1}]\r\n\t({2})",sIndexName,tbl.Name,FormatColumns("{prop}",cols,", ",""));
+ dicIndexes.Add(sIndexName,sIndexName);
+ }
+ private void ShowFK1(IForeignKey fk)
+ {
+ string slName=LocalName(ClassName(fk.ForeignTable));
+ ArrayList fkCols = new ArrayList();
+ output.write("\r\n// FK.P " + fk.PrimaryTable.Name + " FK.F " +fk.ForeignTable.Name);
+ 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.Name != pk.ForeignTable.Name)
+ {
+ foreach(IColumn col in pk.ForeignColumns){
+ output.write("\r\n// col " + col.Name + " IsInPrimaryKey " + col.IsInPrimaryKey.ToString());
+ //if(col.IsInPrimaryKey)
+ fkCols.Add(col);
+ }
+ }
+ }
+ //bool bManyToMany = true;
+ if(fkCols.Count == 0){
+ //bManyToMany = false;
+%>
+ // One To Many<%
+ foreach(IColumn col in fk.ForeignTable.PrimaryKeys)
+ {
+ fkCols.Add(col);
+ }
+ }
+ else
+ {
+%>
+ // Many To Many<%
+ }
+ //string sFkKeysTypes = FormatColumns("{ctype} {local}",fkCols,", ");
+ //string sFkKeys = FormatColumns("{local}",fkCols,", ");
+ //string sFkCheck = FormatColumns(slName +".{prop} == {local}",fkCols," && ");
+ //string sReqKeysCheck= "";
+ string sKeysTypes="";
+ //string sKeys="";
+ //string sValues="";
+ //string sValues2="";
+ //string sep="";
+ string sep2="";
+ //string sep3="";
+ //string reqKeys="";
+ //string reqKeysTypes="";
+ string sValues="";
+ string sValues2="";
+ //ArrayList reqCols = new ArrayList();
+ foreach(IColumn column in fk.ForeignTable.Columns)
+ {
+ //WriteLine("{0} IsRequired {1} IsComputed {2} IsAutoKey {3} IsInfk {4}",column.Name,IsRequired(column),
+ // column.IsComputed,column.IsAutoKey,IsIn(column,fk.ForeignColumns));
+ if(IsRequired(column) && !column.IsComputed && !column.IsAutoKey)
+ {
+ if(!IsIn(column,fk.ForeignColumns))
+ {
+ sValues+=sep2+RelatedObject(fk,column);
+ sValues2+=sep2+RelatedObjectType2(fk,column); // 20070301
+ sKeysTypes+=sep2+FormatColumn("{ctype} {local}",column);
+ sep2=", ";
+ }
+ }
+ }
+ WriteLine("\r\nsKeysTypes='{0}'",sKeysTypes);
+ WriteLine("\r\nsValues='{0}'",sValues);
+ WriteLine("\r\nsValues2='{0}'",sValues2);
+ }
+ public void ShowFK2(IForeignKey fk)
+ {
+ string sInit="";
+ string sep2="";
+ Hashtable dicAlias=new Hashtable();
+ foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys)
+ {
+ if(pk.ForeignTable == fk.ForeignTable && pk.PrimaryTable.Name != pk.ForeignTable.Name && pk.Name != fk.Name)
+ {
+ string sAlias = GetAlias(dicAlias,pk.PrimaryTable);
+ sAlias = GetNewAlias(fk,pk);
+ foreach(IColumn column in pk.PrimaryTable.Columns)
+ {
+ 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";
+ }
+ }
+ }
+ }
+ }
+ }
+ WriteLine("\r\nsInit:\r\n{0}",sInit);
+ }
+ public void ShowFK3(IForeignKey fk)
+ {
+ string slName=LocalName(ClassName(fk.ForeignTable));
+ ArrayList fkCols = new ArrayList();
+ if(fk.ForeignTable != fk.PrimaryTable)
+ {
+ foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys)
+ {
+ if(pk.ForeignTable == fk.ForeignTable && pk.PrimaryTable != fk.PrimaryTable)
+ {
+ foreach(IColumn col in pk.ForeignColumns){
+ fkCols.Add(col);
+ }
+ }
+ }
+ }
+ //bool bManyToMany = true;
+ if(fkCols.Count == 0){
+ //bManyToMany = false;
+%>
+ // One To Many
+<%
+ foreach(IColumn col in fk.ForeignTable.PrimaryKeys)
+ {
+ fkCols.Add(col);
+ }
+ }
+ else
+ {
+%>
+ // Many To Many
+<%
+ }
+ }
+ private void CheckFK(IForeignKey fk)
+ {
+ string slName=LocalName(ClassName(fk.ForeignTable));
+ ArrayList fkCols = new ArrayList();
+ //output.write("\r\n// FK.P " + fk.PrimaryTable.Name + " FK.F " +fk.ForeignTable.Name);
+ if(fk.ForeignTable == fk.PrimaryTable)// Child Relationship
+ {
+ WriteLine(" Child - {0} - Primary {1} - Foreign {2}",fk.Name,fk.PrimaryTable.Name,fk.ForeignTable.Name);
+ }
+ else
+ {
+ // Now determine if the Primary.Columns are Primary Keys
+ WriteLine(" Non-Child - {0} - Primary {1} - Foreign {2}",fk.Name,fk.PrimaryTable.Name,fk.ForeignTable.Name);
+ ShowColumns(fk.PrimaryColumns,6,"PrimaryColumns");
+ ShowColumns(fk.ForeignColumns,6,"ForeignColumns");
+ foreach(IForeignKey pk in fk.ForeignTable.ForeignKeys)
+ {
+ //output.write("\r\n// PK.P " + pk.PrimaryTable.Name + " PK.F " +pk.ForeignTable.Name);
+ string sAlias = GetNewAlias(fk,pk);
+ if(sAlias != "")
+ {
+ WriteLine(" PK - {0} - Primary {1} - Foreign {2}",pk.Name,pk.PrimaryTable.Name,pk.ForeignTable.Name);
+ WriteLine(" Alias - {0}",sAlias);
+ }
+ if(pk.ForeignTable == fk.ForeignTable && pk.PrimaryTable != fk.PrimaryTable && pk.PrimaryTable != pk.ForeignTable)
+ {
+ foreach(IColumn col in pk.ForeignColumns){
+ //output.write("\r\n// col " + col.Name + " IsInPrimaryKey " + col.IsInPrimaryKey.ToString());
+ //if(col.IsInPrimaryKey)
+ fkCols.Add(col);
+ }
+ }
+ }
+ }
+ }
+ private void CheckFK2(IForeignKey fk)
+ {
+ string slName=LocalName(ClassName(fk.ForeignTable));
+ ArrayList fkCols = new ArrayList();
+ output.write("\r\n// FK.P " + fk.PrimaryTable.Name + " FK.F " +fk.ForeignTable.Name);
+ 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)
+ {
+ foreach(IColumn col in pk.ForeignColumns){
+ //output.write("\r\n// col " + col.Name + " IsInPrimaryKey " + col.IsInPrimaryKey.ToString());
+ //if(col.IsInPrimaryKey)
+ fkCols.Add(col);
+ }
+ }
+ }
+ }
+// bool bManyToMany = true;
+ if(fkCols.Count == 0){
+// bManyToMany = false;
+ foreach(IColumn col in fk.ForeignTable.PrimaryKeys)
+ {
+ fkCols.Add(col);
+ }
+ WriteLine("One to Many fkCols - {0}",FormatColumns("{prop}",fkCols,", ",""));
+ }
+ else
+ {
+ WriteLine("Many to Many fkCols - {0}",FormatColumns("{prop}",fkCols,", ",""));
+ }
+ string sFkKeysTypes = FormatColumns("{ctype} {local}",fkCols,", ");
+ WriteLine("sFkKeysTypes - {0}",sFkKeysTypes);
+ string sFkKeys = FormatColumns("{local}",fkCols,", ");
+ WriteLine("sFkKeys - {0}",sFkKeys);
+ string sFkCheck = FormatColumns(slName +".{prop} == {local}",fkCols," && ");
+ WriteLine("sFkCheck - {0}",sFkCheck);
+ 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)
+ {
+ WriteLine("Column {0} IsRequired {1} IsComputed {2} IsAutoKey {3}",column.Name,
+ IsRequired(column), column.IsComputed, column.IsAutoKey);
+ 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("{ctype} {local}",column);
+ sKeys+=sep2+FormatColumn("{local}",column);
+ sReqKeysCheck+=sep3+FormatColumn(slName +".{prop} == {local}",column);
+ reqKeys+=sep2+FormatColumn("{local}",column);
+ reqKeysTypes+=sep2+FormatColumn("{ctype} {local}",column);
+ reqCols.Add(column);
+ sep2=", ";
+ sep3=" && ";
+ } else {
+ if(!bParentRef){
+ WriteLine("Add a parent reference",sKeysTypes);
+ reqKeys="parent"+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);
+ WriteLine("sKeysTypes - {0}",sKeysTypes);
+ WriteLine("sKeys - {0}",sKeys);
+ WriteLine("sReqKeysCheck - {0}",sReqKeysCheck);
+ WriteLine("reqKeys - {0}",reqKeys);
+ WriteLine("reqKeysTypes - {0}",reqKeysTypes);
+
+ }
+%><%#FILE NamingConvention.cs%><%
+%><%#FILE ForeignKeyProcessing.cs%><%
+%><%#FILE FilteredColumns.cs%><%
+%><%#FILE FormatColumns.cs%><%
+%><%#FILE WriteLine.cs%><%
+}
+%>
+##|BODY_END
diff --git a/PROMS/MYGENERATION/csla_21/vlnSQL_List.csgen b/PROMS/MYGENERATION/csla_21/vlnSQL_List.csgen
new file mode 100644
index 00000000..461bf143
--- /dev/null
+++ b/PROMS/MYGENERATION/csla_21/vlnSQL_List.csgen
@@ -0,0 +1,331 @@
+##|TYPE Template
+##|UNIQUEID ad80d306-3f72-4b18-a21e-3e543240152a
+##|TITLE List Stored Procedures - Volian
+##|NAMESPACE CSLA_21
+##|SOURCE_TYPE Source
+##|OUTPUT_LANGUAGE Transact-SQL
+##|GUI_ENGINE .Net Script
+##|GUI_LANGUAGE C#
+##|GUI_BEGIN
+
+public class GeneratedGui : DotNetScriptGui
+{
+ public GeneratedGui(ZeusContext context) : base(context) {}
+
+ //-----------------------------------------
+ // The User Interface Entry Point
+ //-----------------------------------------
+ public override void Setup()
+ {
+ 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;
+ 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", GetDefault("defaultOutputPath"), "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;
+
+ GuiLabel label2 = ui.AddLabel( "label2", "Namespace: ", "Provide your objects namespace." );
+ label2.Width = 280;
+ GuiTextBox classNamespace = ui.AddTextBox( "classNamespace", "Volian.Object.Library", "Provide your objects namespace." );
+ classNamespace.Width = 280;
+
+ GuiLabel label3 = ui.AddLabel( "label3", "Member prefix: ", "Provide your member prefix." );
+ label3.Width = 100;
+ label3.Top = label2.Top;
+ label3.Left = label2.Width + 20;
+ GuiTextBox memberPrefix = ui.AddTextBox( "memberPrefix", "_", "Provide your member prefix." );
+ memberPrefix.Width = 100;
+ memberPrefix.Top = classNamespace.Top;
+ memberPrefix.Left = classNamespace.Width + 20;
+
+ GuiLabel label3A = ui.AddLabel( "label3A", "dbConnection: ", "Provide a Connection Name." );
+ label3A.Width = 150;
+ label3A.Top = label3.Top;
+ label3A.Left = label3.Left+label3.Width + 10;
+ GuiTextBox dbConnection = ui.AddTextBox( "dbConnection", "VEPROMS", "Provide a Connection Name." );
+ dbConnection.Width = 150;
+ dbConnection.Top = memberPrefix.Top;
+ dbConnection.Left = memberPrefix.Left + memberPrefix.Width + 10;
+
+ // Setup Database selection combobox.
+ GuiLabel label4 = ui.AddLabel( "label4", "Select a database:", "Select a database in the dropdown below." );
+ label4.Width = 280;
+ GuiComboBox chooseDatabase = ui.AddComboBox( "chooseDatabase", "Select a database." );
+ chooseDatabase.Width = 280;
+
+ GuiCheckBox chkSelect = MakeGuiCheckBox( "chkSelect", "Select All", true, "Select All Records",100 );
+ GuiCheckBox chkUpdate = MakeGuiCheckBox( "chkUpdate", "Update One", true, "Update One Record" ,150,chkSelect,150,0);
+ GuiCheckBox chkFiles = MakeGuiCheckBox( "chkFiles", "Files", true, "Create Files" ,150,chkUpdate,200,0);
+ GuiCheckBox chkInsert = MakeGuiCheckBox( "chkInsert", "Insert One", true, "Insert One Record" ,150,chkSelect,0,-1);
+ GuiCheckBox chkDelete = MakeGuiCheckBox( "chkDelete", "Delete One", true, "Delete One Record" ,150,chkInsert,150,0);
+ GuiCheckBox chkDrop = MakeGuiCheckBox( "chkDrop", "Drop", true, "Drop Procedures" ,150,chkDelete,200,0);
+ GuiCheckBox chkSelectPK = MakeGuiCheckBox( "chkSelectPK", "Select One", true, "Select One Record" ,150,chkInsert,0,-1);
+ GuiCheckBox chkExists = MakeGuiCheckBox("chkExists","Exists",true,"Check Record Exists",150,chkSelectPK,150,0);
+ GuiCheckBox chkPurge = MakeGuiCheckBox("chkPurge","Purge",true,"Purge All Data",150,chkSelectPK,0,-1);
+ GuiCheckBox chkSelectFKs = MakeGuiCheckBox("chkSelectFKs","Select Group",true,"Select by Foreign Key",150,chkPurge,150,0);
+
+ // Setup Tables selection multi-select listbox.
+ 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;
+ }
+ }
+ 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 + ".Object.Library";
+ }
+ private string GetDefault(string sName)
+ {
+ if( input.Contains( sName ) )
+ {
+ return input[sName].ToString();
+ }
+ return "";
+ }
+ <%#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
+{
+ public GeneratedTemplate(ZeusContext context) : base(context) {}
+ // Members
+ private string _dbName;
+ private ArrayList _selectedTables;
+ private ArrayList _selectedViews;
+ private string _exportPath;
+ private string _nameSpace;
+ private string _prefix;
+ private string _dbConnection;
+ private string _tableName;
+ private string _className="";
+ private ITable _workingTable;
+ //private Hashtable dicRead;
+ //private Hashtable dicReadI;
+ public void SaveFile(string sFile)
+ {
+ if((bool)input["chkFiles"]){
+ output.save( Path.Combine( _exportPath, sFile + ".SQL" ), false );
+ //output.writeln("--" + Path.Combine( _exportPath, "CSLA.SQL" ));
+ output.clear();
+ }
+ }
+ //private bool IsPrimaryKey(IForeignKey fk)
+ //{
+ // bool retval=true;
+ // foreach(IColumn c in fk.ForeignColumns)retval &= c.IsInPrimaryKey;
+ // return retval;
+ //}
+ public delegate bool Filter(IColumn column);
+ //---------------------------------------------------
+ // Render() is where you want to write your logic
+ //---------------------------------------------------
+ public override void Render()
+ {
+ if(context.Objects.ContainsKey("DnpUtils"))DnpUtils.SaveInputToCache(context);
+ //InitializeMembers();
+ _exportPath = input["outputPath"].ToString();
+ _dbName = input["chooseDatabase"].ToString();
+ IDatabase db = MyMeta.Databases[_dbName];
+ SaveProcs(db);
+ //SaveTables(db);
+ }
+ private void SaveProcs(IDatabase db)
+ {
+ foreach(IProcedure ip in db.Procedures)
+ {
+ if(ip.Schema != "sys"){
+ string sName = ip.Name;
+ if((bool)input["chkDrop"]){
+ if(sName.Contains("sp_")==false && sName.Contains("fn_")==false)
+ output.writeln("Drop procedure [" + sName + "]");
+ } else {
+ if(sName.Contains("sp_")==false && sName.Contains("fn_")==false)
+ {
+%>
+/****** Object: StoredProcedure [<%=sName%>] ******/
+IF EXISTS (SELECT * FROM dbo.sysobjects WHERE id = OBJECT_ID(N'[<%=sName%>]') AND OBJECTPROPERTY(id,N'IsProcedure') = 1)
+ DROP PROCEDURE [<%=sName%>];
+GO
+
+<%
+ output.write(ip.ProcedureText.TrimEnd("\r\n".ToCharArray()).Replace(" \r\n","\r\n"));
+%>
+GO
+-- Display the status of Proc creation
+IF (@@Error = 0) PRINT 'Procedure Creation: <%=sName%> Succeeded'
+ELSE PRINT 'Procedure Creation: <%=sName%> Error on Creation'
+GO
+<%
+ SaveFile(ip.Name);
+ }
+ }
+ }
+ }
+ }
+ private void ShowColumns(IColumns cols,int indent,string title)
+ {
+ output.writeln(string.Format("{0}{1}","".PadRight(indent),title));
+ foreach(IColumn col in cols)
+ {
+ output.writeln(string.Format("{0}{1} {2}{3}{4}","".PadRight(indent+2),col.Name,col.DataTypeNameComplete,
+ (col.IsInPrimaryKey?" PK":""),(col.IsInForeignKey?" FK":"")));
+ ShowProperties(col.AllProperties,indent+2);
+ }
+ }
+ private void ShowProperties(IPropertyCollection prps, int indent)
+ {
+ if(prps.Count == 0)return;
+ output.writeln(string.Format("{0}Properties:","".PadRight(indent)));
+ foreach(IProperty prp in prps)
+ {
+ output.writeln(string.Format("{0}{1}={2}","".PadRight(indent+2),prp.Key,prp.Value));
+ }
+ }
+ 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<%#FILE NamingConvention.cs%><%
+%><%#FILE ForeignKeyProcessing.cs%><%
+%><%#FILE FilteredColumns.cs%><%
+%><%#FILE FormatColumns.cs%><%
+%><%#FILE WriteLine.cs%><%
+}
+%>
+##|BODY_END