comesmith 4.1 试用笔记－

<%@ CodeTemplate Language="C#" TargetLanguage="C#" Description="Generates a very simple business object." %>
<%@ Property Name="SourceTable" Type="SchemaExplorer.TableSchema" Category="Context" Description="Table that the object is based on." %>
<%@ Assembly Name="SchemaExplorer" %>
<%@ Assembly Name="System.Data" %>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Import Namespace="System.Data" %>
<%@ Property Name="NameSpace" Type="System.String" Default="Sbm" Optional="False" Category="Context" Description="The name of the event." %>

using System;
using System.Data;

namespace <%=NameSpace %>.Model
{
    #region <%= GetClassName(SourceTable) %>
    /// <summary>
    /// This object represents the properties and methods of a <%= GetClassName(SourceTable) %>.
    /// </summary>
    [Serializable]
    public class <%= GetClassName(SourceTable) %>
    {
        protected <%= GetPrimaryKeyType(SourceTable) %> _id;
        <% foreach (ColumnSchema column in SourceTable.NonPrimaryKeyColumns) { %>
        <%= GetMemberVariableDeclarationStatement(column) %>
        <% } %>
        
        public <%= GetClassName(SourceTable) %>()
        {
        }
        
        public <%= GetClassName(SourceTable) %>(<%= GetPrimaryKeyType(SourceTable) %> id)
        {
            SqlService sql = new SqlService();
            sql.AddParameter("@<%= SourceTable.PrimaryKey.MemberColumns[0].Name %>", SqlDbType.<%= GetSqlDbType(SourceTable.PrimaryKey.MemberColumns[0]) %>, id);
            SqlDataReader reader = sql.ExecuteSqlReader("SELECT * FROM <%= SourceTable.Name %> WHERE <%= SourceTable.PrimaryKey.MemberColumns[0].Name %> = '" + id.ToString() + "'");
            
            if (reader.Read()) 
            {
                this.LoadFromReader(reader);
                reader.Close();
            }
            else
            {
                if (!reader.IsClosed) reader.Close();
                throw new ApplicationException("<%= GetClassName(SourceTable) %> does not exist.");
            }
        }
        
        public <%= GetClassName(SourceTable) %>(SqlDataReader reader)
        {
            this.LoadFromReader(reader);
        }
        
        protected void LoadFromReader(SqlDataReader reader)
        {
            if (reader != null && !reader.IsClosed)
            {
                _id = reader.<%= GetReaderMethod(SourceTable.PrimaryKey.MemberColumns[0]) %>(0);
                <% for (int i = 1; i < SourceTable.Columns.Count; i++) { %>
                <%= GetReaderAssignmentStatement(SourceTable.Columns[i], i) %>
                <% } %>
            }
        }
        
        #region Public Properties
        public <%= GetPrimaryKeyType(SourceTable) %> Id
        {
            get {return _id;}
        }
        
        <% for (int i = 0; i < SourceTable.NonPrimaryKeyColumns.Count; i++) { %>
        public <%= GetCSharpVariableType(SourceTable.NonPrimaryKeyColumns[i]) %> <%= GetPropertyName(SourceTable.NonPrimaryKeyColumns[i]) %>
        {
            //<%=GetColumnDesc(SourceTable.NonPrimaryKeyColumns[i]) %>;
            get {return <%= GetMemberVariableName(SourceTable.NonPrimaryKeyColumns[i]) %>;}
            set {<%= GetMemberVariableName(SourceTable.NonPrimaryKeyColumns[i]) %> = value;}
        }
        <% if (i < SourceTable.NonPrimaryKeyColumns.Count - 1) Response.Write("\r\n"); %>        
        <% } %>
        #endregion
        
        public static <%= GetClassName(SourceTable) %> Get<%= GetClassName(SourceTable) %>(<%= GetPrimaryKeyType(SourceTable) %> id)
        {
            return new <%= GetClassName(SourceTable) %>(id);
        }
    }
    #endregion
}
<script runat="template">
public string GetMemberVariableDeclarationStatement(ColumnSchema column)
{
    return GetMemberVariableDeclarationStatement("protected", column);
}

public string GetMemberVariableDeclarationStatement(string protectionLevel, ColumnSchema column)
{
    string statement = protectionLevel + " ";
    statement += GetCSharpVariableType(column) + " " + GetMemberVariableName(column);
    
    string defaultValue = GetMemberVariableDefaultValue(column);
    if (defaultValue != "")
    {
        statement += " = " + defaultValue;
    }
    
    statement += ";";
    
    return statement;
}

public string GetReaderAssignmentStatement(ColumnSchema column, int index)
{
    string statement = "if (!reader.IsDBNull(" + index.ToString() + ")) ";
    statement += GetMemberVariableName(column) + " = ";
    
    if (column.Name.EndsWith("TypeCode")) statement += "(" + column.Name + ")";
    
    statement += "reader." + GetReaderMethod(column) + "(" + index.ToString() + ");";
    
    return statement;
}

public string GetCamelCaseName(string value)
{
    return value.Substring(0, 1).ToLower() + value.Substring(1);
}

public string GetMemberVariableName(ColumnSchema column)
{
    
    string propertyName = GetPropertyName(column);
    string memberVariableName = "_" + GetCamelCaseName(propertyName);
    
    return memberVariableName;
}

public string GetPropertyName(ColumnSchema column)
{
    string propertyName = column.Name;
    
    if (propertyName == column.Table.Name + "Name") return "Name";
    if (propertyName == column.Table.Name + "Description") return "Description";
    
    if (propertyName.EndsWith("TypeCode")) propertyName = propertyName.Substring(0, propertyName.Length - 4);
    
    return propertyName;
}
        
public string GetMemberVariableDefaultValue(ColumnSchema column)
{
    switch (column.DataType)
    {
        case DbType.Guid:
        {
            return "Guid.Empty";
        }
        case DbType.AnsiString:
        case DbType.AnsiStringFixedLength:
        case DbType.String:
        case DbType.StringFixedLength:
        {
            return "String.Empty";
        }
        default:
        {
            return "";
        }
    }
}

public string GetCSharpVariableType(ColumnSchema column)
{
    if (column.Name.EndsWith("TypeCode")) return column.Name;
    
    switch (column.DataType)
    {
        case DbType.AnsiString: return "string";
        case DbType.AnsiStringFixedLength: return "string";
        case DbType.Binary: return "byte[]";
        case DbType.Boolean: return "bool";
        case DbType.Byte: return "byte";
        case DbType.Currency: return "decimal";
        case DbType.Date: return "DateTime";
        case DbType.DateTime: return "DateTime";
        case DbType.Decimal: return "decimal";
        case DbType.Double: return "double";
        case DbType.Guid: return "Guid";
        case DbType.Int16: return "short";
        case DbType.Int32: return "int";
        case DbType.Int64: return "long";
        case DbType.Object: return "object";
        case DbType.SByte: return "sbyte";
        case DbType.Single: return "float";
        case DbType.String: return "string";
        case DbType.StringFixedLength: return "string";
        case DbType.Time: return "TimeSpan";
        case DbType.UInt16: return "ushort";
        case DbType.UInt32: return "uint";
        case DbType.UInt64: return "ulong";
        case DbType.VarNumeric: return "decimal";
        default:
        {
            return "__UNKNOWN__" + column.NativeType;
        }
    }
}

public string GetReaderMethod(ColumnSchema column)
{
    switch (column.DataType)
    {
        case DbType.Byte:
        {
            return "GetByte";
        }
        case DbType.Int16:
        {
            return "GetInt16";
        }
        case DbType.Int32:
        {
            return "GetInt32";
        }
        case DbType.Int64:
        {
            return "GetInt64";
        }
        case DbType.AnsiStringFixedLength:
        case DbType.AnsiString:
        case DbType.String:
        case DbType.StringFixedLength:
        {
            return "GetString";
        }
        case DbType.Boolean:
        {
            return "GetBoolean";
        }
        case DbType.Guid:
        {
            return "GetGuid";
        }
        case DbType.Currency:
        case DbType.Decimal:
        {
            return "GetDecimal";
        }
        case DbType.DateTime:
        case DbType.Date:
        {
            return "GetDateTime";
        }
        case DbType.Binary:
        {
            return "GetBytes";
        }
        default:
        {
            return "__SQL__" + column.DataType;
        }
    }
}

public string GetClassName(TableSchema table)
{
    if (table.Name.EndsWith("s"))
    {
        return table.Name.Substring(0, table.Name.Length - 1);
    }
    else
    {
        return table.Name;
    }
}

public string GetSqlDbType(ColumnSchema column)
{
    switch (column.NativeType)
    {
        case "bigint": return "BigInt";
        case "binary": return "Binary";
        case "bit": return "Bit";
        case "char": return "Char";
        case "datetime": return "DateTime";
        case "decimal": return "Decimal";
        case "float": return "Float";
        case "image": return "Image";
        case "int": return "Int";
        case "money": return "Money";
        case "nchar": return "NChar";
        case "ntext": return "NText";
        case "numeric": return "Decimal";
        case "nvarchar": return "NVarChar";
        case "real": return "Real";
        case "smalldatetime": return "SmallDateTime";
        case "smallint": return "SmallInt";
        case "smallmoney": return "SmallMoney";
        case "sql_variant": return "Variant";
        case "sysname": return "NChar";
        case "text": return "Text";
        case "timestamp": return "Timestamp";
        case "tinyint": return "TinyInt";
        case "uniqueidentifier": return "UniqueIdentifier";
        case "varbinary": return "VarBinary";
        case "varchar": return "VarChar";
        default: return "__UNKNOWN__" + column.NativeType;
    }
}

public string GetPrimaryKeyType(TableSchema table)
{
    if (table.PrimaryKey != null)
    {
        if (table.PrimaryKey.MemberColumns.Count == 1)
        {
            return GetCSharpVariableType(table.PrimaryKey.MemberColumns[0]);
        }
        else
        {
            throw new ApplicationException("This template will not work on primary keys with more than one member column.");
        }
    }
    else
    {
        throw new ApplicationException("This template will only work on tables with a primary key.");
    }
}

public override string GetFileName()
{
    return this.GetClassName(this.SourceTable) + ".cs";
}
public   string GetColumnDesc(ColumnSchema column )
{
    return  column.ExtendedProperties["CS_Description"].Value.ToString();
}
</script>

功能太强了，正好符合自己大量重复代码的需要。
花了一天的实际，看了几个例子，很容易就做出了自己需要的代码，
真后悔没有早一天使用啊。
具体看看我写的例子：
生成数据库的类model

<%-- 
Name:Interface 
Author: ydf
Description: 
--%>
<%@ CodeTemplate Language="C#" TargetLanguage="Text" Src="" Inherits="" Debug="False" Description="Template description here." %>
<%@ Property Name="NameSpace" Type="System.String" Default="Sbm.Test" Optional="True" Category="Strings" Description="NameSpace " %>
<%@ Property Name="ClassName" Type="System.String" Default="ClassName" Optional="True" Category="Strings" Description="ClassName " %>
<%@ Property Name="SourceTable" Type="SchemaExplorer.TableSchema" Category="Context" Description="Table that the object is based on." %>

<%@ Assembly Name="SchemaExplorer" %>
<%@ Assembly Name="System.Data" %>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Import Namespace="System.Data" %>

using System;
using System.Data;

namespace <%=NameSpace %>.ShareImplement
{

    /// <summary>
    /// Summary description for I<%=ClassName %>.
    /// </summary>
    public interface I<%=ClassName %>
    {
        string EntityName();
        bool Insert(int userID,string tokenString,string xmlDoc,ref int id,ref string msg);
        bool Update(int userID,string tokenString,string xmlDoc,ref string msg);
        bool Delete(int userID,string tokenString,int id,ref string msg);
         
        DataSet SelectByID(int userID,string tokenString,int id);
        void SelectByIDFillDataSet(int userID,string tokenString,int id,ref DataSet ds,string[] tableName);
        DataSet SelectBySql(int userID,string tokenString,string sqlString);
        void SelectBySqlFillDataSet(int userID,string tokenString,string sqlSting,ref DataSet ds,string[] tableName);
        
        bool Audit(int userID,string tokenString,int id,string fieldName,bool action ,ref string msg);
        bool UpdateText(int userID,string tokenString,int id,string fieldName,object txt,ref string msg);
        bool UpdateDateTime(int userID,string tokenString,int id,string fieldName,object dt,ref string msg);
        bool UpdateNumber(int userID,string tokenString,int id,string fieldName,object number,ref string msg);
        bool UpdateNumberInt(int userID,string tokenString,int id,string fieldName,object number,ref string msg);

    }
    
}



<script runat="template">
 

public string SampleMethod()
{
    return "Method output.";
}
</script>

<%------------------------------------------------------------------------------------------
* Author: Eric J. Smith 
* Description: This template will generate standard CRUD stored procedures for a given 
*   database table.
------------------------------------------------------------------------------------------%>
<%@ CodeTemplate Debug="True" Language="C#" Inherits="CodeSmith.BaseTemplates.SqlCodeTemplate" TargetLanguage="T-SQL"
    Description="Generates standard CRUD procedures based on a database table schema." %>
<%-- Context --%>
<%@ Property Name="SourceTable" Type="SchemaExplorer.TableSchema" Category="1. Context"
    Description="Table that the stored procedures should be based on." %>
<%-- Options --%>
<%@ Property Name="IncludeDropStatements" Type="System.Boolean" Default="True" Category="2. Options"
    Description="If true drop statements will be generated to drop existing stored procedures." %>
<%@ Property Name="IsolationLevel" Type="TransactionIsolationLevelEnum" Default="ReadCommitted" Category="2. Options"
    Description="Isolation level to use in the generated procedures." %>
<%@ Property Name="ProcedurePrefix" Type="System.String" Default="usp_" Category="2. Options"
    Description="Prefix to use for all generated procedure names." %>
<%@ Property Name="TablePrefix" Type="System.String" Default="tbl_" Category="2. Options"
    Description="If this prefix is found at the start of a table name, it will be stripped off." %>
<%@ Property Name="AutoExecuteScript" Type="System.Boolean" Default="False" Category="2. Options"
    Description="Whether or not to immediately execute the script on the target database." %>
<%@ Property Name="OrderByExpression" Type="System.String" Default="" Optional="True" Category="2. Options"
    Description="If supplied, this expression will be used to apply an order to the results on SELECT statements." %>
<%@ Property Name="ExcludedColumns" Type="StringCollection" Default="" Optional="True" Category="2. Options"
    Description="If supplied, any columns in this list will be excluded from all stored procedures unless the column is part of the primary key. (* is treated as a wildcard)" %>
<%@ Property Name="ReadOnlyColumns" Type="StringCollection" Default="" Optional="True" Category="2. Options"
    Description="If supplied, any columns in this list will be treated as read only. (* is treated as a wildcard)" %>
<%-- Procedure Types --%>
<%@ Property Name="IncludeInsert" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true an INSERT procedure will be generated." %>
<%@ Property Name="IncludeUpdate" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true an UPDATE procedure will be generated." %>
<%@ Property Name="IncludeInsertUpdate" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true an INSERT/UPDATE procedure will be generated." %>
<%@ Property Name="IncludeDelete" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a DELETE procedure will be generated." %>
<%@ Property Name="IncludeSelect" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a SELECT procedure will be generated." %>
<%@ Property Name="IncludeSelectAll" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a SELECT all procedure will be generated." %>
<%@ Property Name="IncludeSelectPaged" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a SELECT procedure will be generated that allows for server side paging." %>
<%@ Property Name="IncludeSelectByForeignKey" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a SELECT procedure will be generated for each foreign key." %>
<%@ Property Name="IncludeSelectByIndex" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a SELECT procedure will be generated for each table index." %>
<%@ Property Name="IncludeSelectDynamic" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a SELECT procedure will be generated that allows a dynamic WHERE condition to be used." %>
<%@ Property Name="IncludeDeleteByForeignKey" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a DELETE procedure will be generated for each foreign key." %>
<%@ Property Name="IncludeDeleteByIndex" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a DELETE procedure will be generated for each table index." %>
<%@ Property Name="IncludeDeleteDynamic" Type="System.Boolean" Default="True" Category="3. Procedure Types"
    Description="If true a DELETE procedure will be generated that allows a dynamic WHERE condition to be used." %>
<%-- Assembly References --%>
<%@ Assembly Name="SchemaExplorer" %>
<%@ Assembly Name="CodeSmith.BaseTemplates" %>
<%@ Assembly Name="CodeSmith.CustomProperties" %>
<%@ Assembly Name="System.Data" %>
<%-- Namespace Imports --%>
<%@ Import Namespace="SchemaExplorer" %>
<%@ Import Namespace="CodeSmith.CustomProperties" %>
<%@ Import Namespace="CodeSmith.BaseTemplates" %>
<%@ Import Namespace="System.Data" %>
<%@ Import Namespace="System.Text.RegularExpressions" %>
<%
this.Progress.MaximumValue = 13;
this.Progress.Step = 1;

// this template requires a primary key on the source table
if (!SourceTable.HasPrimaryKey) throw new ApplicationException("SourceTable does not contain a primary key.");

// generate drop statements
if (IncludeDropStatements)
{
    Response.WriteLine("--region Drop Existing Procedures");
    Response.WriteLine("");
    
    if (IncludeInsert) GenerateDropStatement(GetInsertProcedureName());
    if (IncludeUpdate) GenerateDropStatement(GetUpdateProcedureName());
    if (IncludeInsertUpdate) GenerateDropStatement(GetInsertUpdateProcedureName());
    if (IncludeDelete)
    {
        GenerateDropStatement(GetDeleteProcedureName());
        // this is to keep a drop statement for a delete by procedure with only the primary key columns from being generated
        _droppedProcedureNames.Add(GetDeleteByProcedureName(SourceTable.PrimaryKey.MemberColumns));
    }
    if (IncludeDeleteDynamic) GenerateDropStatement(GetDeleteDynamicProcedureName());
    if (IncludeSelect)
    {
        GenerateDropStatement(GetSelectProcedureName());
        // this is to keep a drop statement for a select by procedure with only the primary key columns from being generated
        _droppedProcedureNames.Add(GetSelectByProcedureName(SourceTable.PrimaryKey.MemberColumns));
    }
    if (IncludeSelectDynamic) GenerateDropStatement(GetSelectDynamicProcedureName());
    if (IncludeSelectAll) GenerateDropStatement(GetSelectAllProcedureName());
    
    if (IncludeSelectByForeignKey)
    {
        for (int i = 0; i < SourceTable.ForeignKeys.Count; i++)
        {
            GenerateDropStatement(GetSelectByProcedureName(SourceTable.ForeignKeys[i].ForeignKeyMemberColumns));
        }
    }
    
    if (IncludeSelectByIndex)
    {
        for (int i = 0; i < SourceTable.Indexes.Count; i++)
        {
            GenerateDropStatement(GetSelectByProcedureName(SourceTable.Indexes[i].MemberColumns));
        }
    }
    
    if (IncludeDeleteByForeignKey)
    {
        for (int i = 0; i < SourceTable.ForeignKeys.Count; i++)
        {
            GenerateDropStatement(GetDeleteByProcedureName(SourceTable.ForeignKeys[i].ForeignKeyMemberColumns));
        }
    }
    
    if (IncludeDeleteByIndex)
    {
        for (int i = 0; i < SourceTable.Indexes.Count; i++)
        {
            GenerateDropStatement(GetDeleteByProcedureName(SourceTable.Indexes[i].MemberColumns));
        }
    }
    
    Response.WriteLine("--endregion");
    Response.WriteLine("");
    Response.WriteLine("GO");
    Response.WriteLine("");
    
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Insert Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeInsert)
{
    GenerateProcedureHeader(GetInsertProcedureName());
    
    /*
     * Check to see if the primary key is a single column primary key and also if it's either an
     * identity column or a GUID.  If so, we will not include the primary key column in the
     * list of input parameters.
     */
    
    if (SourceTable.PrimaryKey.MemberColumns.Count == 1
        && (SourceTable.PrimaryKey.MemberColumns[0].DataType == DbType.Guid
        || ((SourceTable.PrimaryKey.MemberColumns[0].DataType == DbType.Int16
        || SourceTable.PrimaryKey.MemberColumns[0].DataType == DbType.Int32
        || SourceTable.PrimaryKey.MemberColumns[0].DataType == DbType.Int64)
        && (bool)SourceTable.PrimaryKey.MemberColumns[0].ExtendedProperties["CS_IsIdentity"].Value == true)))
    {
        ColumnSchema primaryKeyColumn = SourceTable.PrimaryKey.MemberColumns[0];
%>

CREATE PROCEDURE <%= GetInsertProcedureName() %>
<% GenerateParameters(FilterReadOnlyAndExcludedColumns(SourceTable.NonPrimaryKeyColumns), 1, true); %>
<% GenerateParameter(primaryKeyColumn, 1, false, true, true); %>
AS

SET NOCOUNT ON

<%-- If the primary key is a GUID, then assign a new GUID using NEWID(). --%>
<% if (primaryKeyColumn.DataType == DbType.Guid) { %>
SET @<%= primaryKeyColumn.Name %> = NEWID()

<% } %>
INSERT INTO <%= GetTableOwner() %>[<%= SourceTable.Name %>] (
    <% if (primaryKeyColumn.DataType == DbType.Guid) { %>
    [<%= primaryKeyColumn.Name %>],
    <% } %>
    <% GenerateColumns(FilterReadOnlyAndExcludedColumns(SourceTable.NonPrimaryKeyColumns), 1); %>
) VALUES (
    <% if (primaryKeyColumn.DataType == DbType.Guid) { %>
    @<%= primaryKeyColumn.Name %>,
    <% } %>
    <% GenerateVariables(FilterReadOnlyAndExcludedColumns(SourceTable.NonPrimaryKeyColumns), 1); %>
)
<%-- If the primary key is an identity column, then capture the newly assigned identity using SCOPE_IDENTITY(). --%>
<% if (primaryKeyColumn.DataType == DbType.Int16 || primaryKeyColumn.DataType == DbType.Int32 || primaryKeyColumn.DataType == DbType.Int64) { %>

SET @<%= primaryKeyColumn.Name %> = SCOPE_IDENTITY()
<% } %>

<%-- Primary key is not a identity column or a GUID, so include all columns as input parameters. --%>
<% } else { %>

CREATE PROCEDURE <%= GetInsertProcedureName() %>
<% GenerateParameters(FilterReadOnlyAndExcludedColumns(SourceTable.Columns), 1); %>
AS

SET NOCOUNT ON

INSERT INTO <%= GetTableOwner() %>[<%= SourceTable.Name %>] (
    <% GenerateColumns(SourceTable.Columns, 1); %>
) VALUES (
    <% GenerateVariables(SourceTable.Columns, 1); %>
)

<%
    }
    GenerateProcedureFooter(GetInsertProcedureName());
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Update Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeUpdate)
{
    GenerateProcedureHeader(GetUpdateProcedureName());
%>

CREATE PROCEDURE <%= GetUpdateProcedureName() %>
<% GenerateParameters(FilterReadOnlyAndExcludedColumns(SourceTable.Columns), 1); %>
AS

SET NOCOUNT ON

UPDATE <%= GetTableOwner() %>[<%= SourceTable.Name %>] SET
    <% GenerateUpdates(SourceTable.NonPrimaryKeyColumns, 1); %>
WHERE
    <% GenerateConditions(SourceTable.PrimaryKey.MemberColumns, 1); %>

<%
    GenerateProcedureFooter(GetUpdateProcedureName());
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* InsertUpdate Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeInsertUpdate)
{
    GenerateProcedureHeader(GetInsertUpdateProcedureName());
%>

CREATE PROCEDURE <%= GetInsertUpdateProcedureName() %>
<% GenerateParameters(SourceTable.Columns, 1); %>
AS

SET NOCOUNT ON

IF EXISTS(SELECT <% GenerateColumns(SourceTable.PrimaryKey.MemberColumns, -1); %> FROM <%= GetTableOwner() %>[<%= SourceTable.Name %>] WHERE <% GenerateConditions(SourceTable.PrimaryKey.MemberColumns, -1); %>)
BEGIN
    UPDATE <%= GetTableOwner() %>[<%= SourceTable.Name %>] SET
        <% GenerateUpdates(SourceTable.NonPrimaryKeyColumns, 2); %>
    WHERE
        <% GenerateConditions(SourceTable.PrimaryKey.MemberColumns, 2); %>
END
ELSE
BEGIN
    INSERT INTO <%= GetTableOwner() %>[<%= SourceTable.Name %>] (
        <% GenerateColumns(SourceTable.Columns, 2); %>
    ) VALUES (
        <% GenerateVariables(SourceTable.Columns, 2); %>
    )
END

<%
    GenerateProcedureFooter(GetInsertUpdateProcedureName());
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Delete Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeDelete)
{
    // this is to keep a delete by procedure with only the primary key columns from being generated
    _generatedProcedureNames.Add(GetDeleteByProcedureName(SourceTable.PrimaryKey.MemberColumns));
    
    GenerateProcedureHeader(GetDeleteProcedureName());
%>

CREATE PROCEDURE <%= GetDeleteProcedureName() %>
<% GenerateParameters(SourceTable.PrimaryKey.MemberColumns, 1); %>
AS

SET NOCOUNT ON

DELETE FROM <%= GetTableOwner() %>[<%= SourceTable.Name %>]
WHERE
    <% GenerateConditions(SourceTable.PrimaryKey.MemberColumns, 1); %>

<%
    GenerateProcedureFooter(GetDeleteProcedureName());
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Delete By Foreign Key Procedures
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeDeleteByForeignKey)
{
    for (int i = 0; i < SourceTable.ForeignKeys.Count; i++)
    {
        string procedureName = GetDeleteByProcedureName(SourceTable.ForeignKeys[i].ForeignKeyMemberColumns);
        if (!_generatedProcedureNames.Contains(procedureName))
        {
            _generatedProcedureNames.Add(procedureName);
            GenerateProcedureHeader(procedureName);
%>

CREATE PROCEDURE <%= procedureName %>
<% GenerateParameters(SourceTable.ForeignKeys[i].ForeignKeyMemberColumns, 1); %>
AS

SET NOCOUNT ON

DELETE FROM <%= GetTableOwner() %>[<%= SourceTable.Name %>]
WHERE
    <% GenerateConditions(SourceTable.ForeignKeys[i].ForeignKeyMemberColumns, 1); %>

GO

<%
            GenerateProcedureFooter(procedureName);
        }
    }
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Delete By Index Procedures
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeDeleteByIndex)
{
    for (int i = 0; i < SourceTable.Indexes.Count; i++)
    {
        string procedureName = GetDeleteByProcedureName(SourceTable.Indexes[i].MemberColumns);
        if (!_generatedProcedureNames.Contains(procedureName))
        {
            _generatedProcedureNames.Add(procedureName);
            GenerateProcedureHeader(procedureName);
%>

CREATE PROCEDURE <%= procedureName %>
<% GenerateParameters(SourceTable.Indexes[i].MemberColumns, 1); %>
AS

SET NOCOUNT ON

DELETE FROM <%= GetTableOwner() %>[<%= SourceTable.Name %>]
WHERE
    <% GenerateConditions(SourceTable.Indexes[i].MemberColumns, 1); %>

<%
            GenerateProcedureFooter(procedureName);
        }
    }
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Delete Dynamic Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeDeleteDynamic)
{
    GenerateProcedureHeader(GetDeleteDynamicProcedureName());
%>

CREATE PROCEDURE <%= GetDeleteDynamicProcedureName() %>
    @WhereCondition nvarchar(500)
AS

SET NOCOUNT ON

DECLARE @SQL nvarchar(3250)

SET @SQL = '
DELETE FROM
    <%= GetTableOwner() %>[<%= SourceTable.Name %>]
WHERE
    ' + @WhereCondition

EXEC sp_executesql @SQL

<%
    GenerateProcedureFooter(GetDeleteDynamicProcedureName());
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Select Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeSelect)
{
    // this is to keep a select by procedure with only the primary key columns from being generated
    _generatedProcedureNames.Add(GetSelectByProcedureName(SourceTable.PrimaryKey.MemberColumns));
    
    GenerateProcedureHeader(GetSelectProcedureName());
%>

CREATE PROCEDURE <%= GetSelectProcedureName() %>
<% GenerateParameters(SourceTable.PrimaryKey.MemberColumns, 1); %>
AS

SET NOCOUNT ON
<% GenerateSetTransactionIsolationLevelStatement(IsolationLevel); %>

SELECT
    <% GenerateColumns(SourceTable.Columns, 1); %>
FROM
    <%= GetTableOwner() %>[<%= SourceTable.Name %>]
WHERE
    <% GenerateConditions(SourceTable.PrimaryKey.MemberColumns, 1); %>

<%
    GenerateProcedureFooter(GetSelectProcedureName());
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Select By Foreign Key Procedures
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeSelectByForeignKey)
{
    for (int i = 0; i < SourceTable.ForeignKeys.Count; i++)
    {
        string procedureName = GetSelectByProcedureName(SourceTable.ForeignKeys[i].ForeignKeyMemberColumns);
        if (!_generatedProcedureNames.Contains(procedureName))
        {
            _generatedProcedureNames.Add(procedureName);
            GenerateProcedureHeader(procedureName);
%>

CREATE PROCEDURE <%= procedureName %>
<% GenerateParameters(SourceTable.ForeignKeys[i].ForeignKeyMemberColumns, 1); %>
AS

SET NOCOUNT ON
<% GenerateSetTransactionIsolationLevelStatement(IsolationLevel); %>

SELECT
    <% GenerateColumns(SourceTable.Columns, 1); %>
FROM
    <%= GetTableOwner() %>[<%= SourceTable.Name %>]
WHERE
    <% GenerateConditions(SourceTable.ForeignKeys[i].ForeignKeyMemberColumns, 1); %>
<% GenerateOrderByClause(); %>

<%
            GenerateProcedureFooter(procedureName);
        }
    }
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Select By Index Procedures
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeSelectByIndex)
{
    for (int i = 0; i < SourceTable.Indexes.Count; i++)
    {
        string procedureName = GetSelectByProcedureName(SourceTable.Indexes[i].MemberColumns);
        if (!_generatedProcedureNames.Contains(procedureName))
        {
            _generatedProcedureNames.Add(procedureName);
            GenerateProcedureHeader(procedureName);
%>

CREATE PROCEDURE <%= procedureName %>
<% GenerateParameters(SourceTable.Indexes[i].MemberColumns, 1); %>
AS

SET NOCOUNT ON
<% GenerateSetTransactionIsolationLevelStatement(IsolationLevel); %>

SELECT
    <% GenerateColumns(SourceTable.Columns, 1); %>
FROM
    <%= GetTableOwner() %>[<%= SourceTable.Name %>]
WHERE
    <% GenerateConditions(SourceTable.Indexes[i].MemberColumns, 1); %>
<% GenerateOrderByClause(); %>

<%
            GenerateProcedureFooter(procedureName);
        }
    }
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Select Dynamic Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeSelectDynamic)
{
    GenerateProcedureHeader(GetSelectDynamicProcedureName());
%>

CREATE PROCEDURE <%= GetSelectDynamicProcedureName() %>
    @WhereCondition nvarchar(500),
    @OrderByExpression nvarchar(250) = NULL
AS

SET NOCOUNT ON
<% GenerateSetTransactionIsolationLevelStatement(IsolationLevel); %>

DECLARE @SQL nvarchar(3250)

SET @SQL = '
SELECT
    <% GenerateColumns(SourceTable.Columns, 1); %>
FROM
    <%= GetTableOwner() %>[<%= SourceTable.Name %>]
WHERE
    ' + @WhereCondition

IF @OrderByExpression IS NOT NULL AND LEN(@OrderByExpression) > 0
BEGIN
    SET @SQL = @SQL + '
ORDER BY
    ' + @OrderByExpression
END
<% if (OrderByExpression != null && OrderByExpression.Trim().Length > 0) { %>
ELSE
BEGIN
    SET @SQL = @SQL + '
ORDER BY
    <%= OrderByExpression %>'
END
<% } %>

EXEC sp_executesql @SQL

<%
    GenerateProcedureFooter(GetSelectDynamicProcedureName());
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Select All Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeSelectAll)
{
    GenerateProcedureHeader(GetSelectAllProcedureName());
%>

CREATE PROCEDURE <%= GetSelectAllProcedureName() %>
AS

SET NOCOUNT ON
<% GenerateSetTransactionIsolationLevelStatement(IsolationLevel); %>

SELECT
    <% GenerateColumns(SourceTable.Columns, 1); %>
FROM
    <%= GetTableOwner() %>[<%= SourceTable.Name %>]
<% GenerateOrderByClause(); %>

<%
    GenerateProcedureFooter(GetSelectAllProcedureName());
    this.Progress.PerformStep();
}
%>
<%------------------------------------------------------------------------------------------
*
* Select Paged Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeSelectPaged)
{
    GenerateProcedureHeader(GetSelectPagedProcedureName());
%>

CREATE PROCEDURE <%= GetSelectPagedProcedureName() %>
AS

SET NOCOUNT ON
<% GenerateSetTransactionIsolationLevelStatement(IsolationLevel); %>

SELECT
    <% GenerateColumns(SourceTable.Columns, 1); %>
FROM
    <%= GetTableOwner() %>[<%= SourceTable.Name %>]
<% GenerateOrderByClause(); %>

<%
    GenerateProcedureFooter(GetSelectPagedProcedureName());
    this.Progress.PerformStep();
}
%>
<script runat="template">
#region Member Variables
private StringCollection _droppedProcedureNames = new StringCollection();
private StringCollection _generatedProcedureNames = new StringCollection();
#endregion

#region Isolation Level
public enum TransactionIsolationLevelEnum
{
    ReadCommitted,
    ReadUncommitted,
    RepeatableRead,
    Serializable
}

public void GenerateSetTransactionIsolationLevelStatement(TransactionIsolationLevelEnum isolationLevel)
{
    Response.Write("SET TRANSACTION ISOLATION LEVEL ");
    
    switch (isolationLevel)
    {
        case TransactionIsolationLevelEnum.ReadUncommitted:
        {
            Response.WriteLine("READ UNCOMMITTED");
            break;
        }
        case TransactionIsolationLevelEnum.RepeatableRead:
        {
            Response.WriteLine("REPEATABLE READ");
            break;
        }
        case TransactionIsolationLevelEnum.Serializable:
        {
            Response.WriteLine("SERIALIZABLE");
            break;
        }
        default:
        {
            Response.WriteLine("READ COMMITTED");
            break;
        }
    }
}
#endregion

#region Code Generation Helpers
public string GetTableOwner()
{
    return GetTableOwner(true);
}

public string GetTableOwner(bool includeDot)
{
    if (SourceTable.Owner.Length > 0)
    {
        if (includeDot)
        {
            return "[" + SourceTable.Owner + "].";
        }
        else
        {
            return "[" + SourceTable.Owner + "]";
        }
    }
    else
    {
        return "";
    }
}

public void GenerateDropStatement(string procedureName)
{
    // check to see if this procedure has already been dropped.
    if (!_droppedProcedureNames.Contains(procedureName))
    {
        Response.WriteLine("IF OBJECT_ID(N'{0}') IS NOT NULL", procedureName);
        GenerateIndent(1);
        Response.WriteLine("DROP PROCEDURE {0}", procedureName);
        Response.WriteLine("");
        
        // add this procedure to the list of dropped procedures
        _droppedProcedureNames.Add(procedureName);
    }
}

public void GenerateProcedureHeader(string procedureName)
{
    Response.WriteLine("--region {0}", procedureName);
    Response.WriteLine("");
    Response.WriteLine("------------------------------------------------------------------------------------------------------------------------");
    Response.WriteLine("-- Generated By:   {0} using CodeSmith {1}", System.Environment.UserName, typeof(CodeTemplate).Assembly.GetName().Version.ToString());
    Response.WriteLine("-- Template:       {0}", this.CodeTemplateInfo.FileName);
    Response.WriteLine("-- Procedure Name: {0}", procedureName);
    Response.WriteLine("-- Date Generated: {0}", DateTime.Now.ToLongDateString());
    Response.WriteLine("------------------------------------------------------------------------------------------------------------------------");
}

public void GenerateProcedureFooter(string procedureName)
{
    Response.WriteLine("--endregion");
    Response.WriteLine("");
    Response.WriteLine("GO");
    Response.WriteLine("");
}

public void GenerateIndent(int indentLevel)
{
    for (int i = 0; i < indentLevel; i++)
    {
        Response.Write('\t');
    }
}

public void GenerateParameter(ColumnSchema column, int indentLevel, bool isFirst, bool isLast)
{
    GenerateParameter(column, indentLevel, isFirst, isLast, false);
}

public void GenerateParameter(ColumnSchema column, int indentLevel, bool isFirst, bool isLast, bool isOutput)
{
    GenerateIndent(indentLevel);
    Response.Write(GetSqlParameterStatement(column, isOutput));
    if (!isLast) Response.Write(",");
    if (indentLevel >= 0)
    {
        Response.WriteLine("");
    }
    else if (!isLast)
    {
        Response.Write(" ");
    }
}

public void GenerateParameters(ColumnSchemaCollection columns, int indentLevel)
{
    GenerateParameters(columns, indentLevel, false);
}

public void GenerateParameters(ColumnSchemaCollection columns, int indentLevel, bool includeTrailingComma)
{
    ColumnSchemaCollection filteredColumns = FilterExcludedColumns(columns);
    for (int i = 0; i < filteredColumns.Count; i++)
    {
        GenerateParameter(filteredColumns[i], indentLevel, i == 0, i == filteredColumns.Count - 1 && !includeTrailingComma);
    }
}

public void GenerateColumn(ColumnSchema column, int indentLevel, bool isFirst, bool isLast)
{
    GenerateIndent(indentLevel);
    Response.Write("[");
    Response.Write(column.Name);
    Response.Write("]");
    if (!isLast) Response.Write(",");
    if (indentLevel >= 0)
    {
        Response.WriteLine("");
    }
    else if (!isLast)
    {
        Response.Write(" ");
    }
}

public void GenerateColumns(ColumnSchemaCollection columns, int indentLevel)
{
    ColumnSchemaCollection filteredColumns = FilterExcludedColumns(columns);
    for (int i = 0; i < filteredColumns.Count; i++)
    {
        GenerateColumn(filteredColumns[i], indentLevel, i == 0, i == filteredColumns.Count - 1);
    }
}

public void GenerateUpdate(ColumnSchema column, int indentLevel, bool isFirst, bool isLast)
{
    GenerateIndent(indentLevel);
    Response.Write("[");
    Response.Write(column.Name);
    Response.Write("] = @");
    Response.Write(column.Name);
    if (!isLast) Response.Write(",");
    if (indentLevel >= 0)
    {
        Response.WriteLine("");
    }
    else if (!isLast)
    {
        Response.Write(" ");
    }
}

public void GenerateUpdates(ColumnSchemaCollection columns, int indentLevel)
{
    ColumnSchemaCollection filteredColumns = FilterReadOnlyAndExcludedColumns(columns);
    for (int i = 0; i < filteredColumns.Count; i++)
    {
        GenerateUpdate(filteredColumns[i], indentLevel, i == 0, i == filteredColumns.Count - 1);
    }
}

public void GenerateCondition(ColumnSchema column, int indentLevel, bool isFirst, bool isLast)
{
    GenerateIndent(indentLevel);
    if (!isFirst) Response.Write("AND ");
    Response.Write("[");
    Response.Write(column.Name);
    Response.Write("] = @");
    Response.Write(column.Name);
    if (indentLevel >= 0)
    {
        Response.WriteLine("");
    }
    else if (!isLast)
    {
        Response.Write(" ");
    }
}

public void GenerateConditions(ColumnSchemaCollection columns, int indentLevel)
{
    ColumnSchemaCollection filteredColumns = FilterExcludedColumns(columns);
    for (int i = 0; i < filteredColumns.Count; i++)
    {
        GenerateCondition(filteredColumns[i], indentLevel, i == 0, i == filteredColumns.Count - 1);
    }
}

public void GenerateVariable(ColumnSchema column, int indentLevel, bool isFirst, bool isLast)
{
    GenerateIndent(indentLevel);
    Response.Write("@");
    Response.Write(column.Name);
    if (!isLast) Response.Write(",");
    if (indentLevel >= 0)
    {
        Response.WriteLine("");
    }
    else if (!isLast)
    {
        Response.Write(" ");
    }
}

public void GenerateVariables(ColumnSchemaCollection columns, int indentLevel)
{
    ColumnSchemaCollection filteredColumns = FilterExcludedColumns(columns);
    for (int i = 0; i < filteredColumns.Count; i++)
    {
        GenerateVariable(filteredColumns[i], indentLevel, i == 0, i == filteredColumns.Count - 1);
    }
}

public void GenerateOrderByClause()
{
    if (OrderByExpression != null && OrderByExpression.Trim().Length > 0)
    {
        Response.WriteLine("ORDER BY");
        GenerateIndent(1);
        Response.WriteLine(OrderByExpression);
    }
}

public ColumnSchemaCollection FilterReadOnlyColumns(ColumnSchemaCollection columns)
{
    ColumnSchemaCollection filteredColumns = new ColumnSchemaCollection();
    
    for (int i = 0; i < columns.Count; i++)
    {
        if (!ColumnIsReadOnly(columns[i])) filteredColumns.Add(columns[i]);
    }
    
    return filteredColumns;
}

public ColumnSchemaCollection FilterExcludedColumns(ColumnSchemaCollection columns)
{
    ColumnSchemaCollection filteredColumns = new ColumnSchemaCollection();
    
    for (int i = 0; i < columns.Count; i++)
    {
        if (!ColumnIsExcluded(columns[i])) filteredColumns.Add(columns[i]);
    }
    
    return filteredColumns;
}

public ColumnSchemaCollection FilterReadOnlyAndExcludedColumns(ColumnSchemaCollection columns)
{
    ColumnSchemaCollection filteredColumns = new ColumnSchemaCollection();
    
    for (int i = 0; i < columns.Count; i++)
    {
        if (!ColumnIsExcludedOrReadOnly(columns[i])) filteredColumns.Add(columns[i]);
    }
    
    return filteredColumns;
}

private Regex excludedColumnRegex = null;

public bool ColumnIsExcluded(ColumnSchema column)
{
    if (column.IsPrimaryKeyMember) return false;
    
    if (excludedColumnRegex == null)
    {
        if (ExcludedColumns != null && ExcludedColumns.Count > 0)
        {
            string excluded = String.Empty;
            for (int i = 0; i < ExcludedColumns.Count; i++)
            {
                if (ExcludedColumns[i].Trim().Length > 0)
                {
                    excluded += "(" + Regex.Escape(ExcludedColumns[i]).Replace("\\*", ".*?") + ")|";
                }
            }
            
            if (excluded.Length > 0)
            {
                excluded = excluded.Substring(0, excluded.Length - 1);
                excludedColumnRegex = new Regex(excluded, RegexOptions.IgnoreCase);
            }
        }
    }
    
    if (excludedColumnRegex != null && excludedColumnRegex.IsMatch(column.Name)) return true;
    
    return false;
}

private Regex readOnlyColumnRegex = null;

public bool ColumnIsReadOnly(ColumnSchema column)
{
    if (column.IsPrimaryKeyMember) return false;
    
    if (readOnlyColumnRegex == null)
    {
        if (ReadOnlyColumns != null && ReadOnlyColumns.Count > 0)
        {
            string readOnly = String.Empty;
            for (int i = 0; i < ReadOnlyColumns.Count; i++)
            {
                if (ReadOnlyColumns[i].Trim().Length > 0)
                {
                    readOnly += "(" + Regex.Escape(ReadOnlyColumns[i]).Replace("\\*", ".*?") + ")|";
                }
            }
            
            if (readOnly.Length > 0)
            {
                readOnly = readOnly.Substring(0, readOnly.Length - 1);
                readOnlyColumnRegex = new Regex(readOnly, RegexOptions.IgnoreCase);
            }
        }
    }
    
    if (readOnlyColumnRegex != null && readOnlyColumnRegex.IsMatch(column.Name)) return true;
    
    return false;
}

public bool ColumnIsExcludedOrReadOnly(ColumnSchema column)
{
    return ColumnIsExcluded(column) || ColumnIsReadOnly(column);
}
#endregion

#region Procedure Naming
public string GetInsertProcedureName()
{
    return String.Format("{0}[{1}{2}_Insert]", GetTableOwner(), ProcedurePrefix, GetEntityName(false));
}

public string GetUpdateProcedureName()
{
    return String.Format("{0}[{1}{2}_Update]", GetTableOwner(), ProcedurePrefix, GetEntityName(false));
}

public string GetInsertUpdateProcedureName()
{
    return String.Format("{0}[{1}{2}_InsertUpdate]", GetTableOwner(), ProcedurePrefix, GetEntityName(false));
}

public string GetDeleteProcedureName()
{
    return String.Format("{0}[{1}{2}_Delete]", GetTableOwner(), ProcedurePrefix, GetEntityName(false));
}

public string GetSelectProcedureName()
{
    return String.Format("{0}[{1}{2}_Select]", GetTableOwner(), ProcedurePrefix, GetEntityName(false));
}

public string GetSelectAllProcedureName()
{
    return String.Format("{0}[{1}{2}_SelectAll]", GetTableOwner(), ProcedurePrefix, GetEntityName(true));
}

public string GetSelectPagedProcedureName()
{
    return String.Format("{0}[{1}{2}_SelectPaged]", GetTableOwner(), ProcedurePrefix, GetEntityName(true));
}

public string GetSelectByProcedureName(ColumnSchemaCollection targetColumns)
{
    return String.Format("{0}[{1}{2}_SelectBy{3}]", GetTableOwner(), ProcedurePrefix, GetEntityName(true), GetBySuffix(targetColumns));
}

public string GetSelectDynamicProcedureName()
{
    return String.Format("{0}[{1}{2}_SelectDynamic]", GetTableOwner(), ProcedurePrefix, GetEntityName(true));
}

public string GetDeleteByProcedureName(ColumnSchemaCollection targetColumns)
{
    return String.Format("{0}[{1}{2}_DeleteBy{3}]", GetTableOwner(), ProcedurePrefix, GetEntityName(true), GetBySuffix(targetColumns));
}

public string GetDeleteDynamicProcedureName()
{
    return String.Format("{0}[{1}{2}_DeleteDynamic]", GetTableOwner(), ProcedurePrefix, GetEntityName(true));
}

public string GetEntityName(bool plural)
{
    string entityName = SourceTable.Name;
    
    if (entityName.StartsWith(TablePrefix))
    {
        entityName = entityName.Substring(TablePrefix.Length);
    }
    
    if (plural)
    {
        entityName = StringUtil.ToPlural(entityName);
    }
    else
    {
        entityName = StringUtil.ToSingular(entityName);
    }
    
    return entityName;
}

public string GetBySuffix(ColumnSchemaCollection columns)
{
    System.Text.StringBuilder bySuffix = new System.Text.StringBuilder();
    for (int i = 0; i < columns.Count; i++)
    {
        if (i > 0) bySuffix.Append("And");
        bySuffix.Append(columns[i].Name);
    }
    
    return bySuffix.ToString();
}
#endregion

#region Template Overrides
// Assign an appropriate file name to the output.
public override string GetFileName()
{
    if (this.SourceTable != null)
    {
        return this.SourceTable.Name + "_Procedures.sql";
    }
    else
    {
        return base.GetFileName();
    }
}

// Override the OutputFile property and assign our specific settings to it.
[Category("2. Options")]
[FileDialog(FileDialogType.Save, Title="Select Output File", Filter="Query Files (*.sql)|*.sql|All Files (*.*)|*.*", DefaultExtension=".sql")]
public override string OutputFile
{
    get {return base.OutputFile;}
    set {base.OutputFile = value;}
}

protected override void OnPostRender(string result) 
{
    if (this.AutoExecuteScript)
    {
        // execute the output on the same database as the source table.
        CodeSmith.BaseTemplates.ScriptResult scriptResult = CodeSmith.BaseTemplates.ScriptUtility.ExecuteScript(this.SourceTable.Database.ConnectionString, result, new System.Data.SqlClient.SqlInfoMessageEventHandler(cn_InfoMessage)); 
        Trace.WriteLine(scriptResult.ToString());
    }
    
    base.OnPostRender(result);
}

private void cn_InfoMessage(object sender, System.Data.SqlClient.SqlInfoMessageEventArgs e)
{
    Trace.WriteLine(e.Message);
}
#endregion

</scrip