ImaginaryDevelopment/FTargets.proj

## FTargets.proj
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
    <!-- for build server primarily -->
    <FSharpTargetsPath Condition="'$(FSharpTargetsPath)' == '' And Exists('C:\Program Files (x86)\Microsoft SDKs\F#\4.0\Framework\v4.0\Microsoft.FSharp.Targets')">C:\Program Files (x86)\Microsoft SDKs\F#\4.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
    <FSharpTargetsPath Condition="'$(FSharpTargetsPath)' == '' And Exists('C:\Program Files (x86)\Microsoft SDKs\F#\3.1\Framework\v4.0')">C:\Program Files (x86)\Microsoft SDKs\F#\3.1\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
    <FSharpTargetsPath Condition="'$(FSharpTargetsPath)' == '' ">..\3rdParty\Microsoft.FSharp.Targets</FSharpTargetsPath>
    <!-- love these option settings, but not required -->
    <WarningLevel>5</WarningLevel>
    <OtherFlags>--warnon:1182 --warnaserror-:0052</OtherFlags>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>
  <Choose>
    <When Condition="'$(VisualStudioVersion)' == '11.0'">
      <PropertyGroup Condition="'$(FSharpTargetsPath)' == '' And Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')">
        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
      </PropertyGroup>
    </When>
    <Otherwise>
      <PropertyGroup Condition="'$(FSharpTargetsPath)' == '' And Exists('$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets')">
        <FSharpTargetsPath>$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets</FSharpTargetsPath>
      </PropertyGroup>
    </Otherwise>
  </Choose>
  <Target Name="FDiagnostics" BeforeTargets="Build">
    <Message Importance="high" Text="MSBuildExtensionsPath32:$(MSBuildExtensionsPath32)" />
    <Message Importance="high" Text="FSharpTargetsPath:$(FSharpTargetsPath)" />
    <Message Importance="high" Condition="Exists('$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets')" Text="FSharpTargetsPath:Exists" />
  </Target>
  <Import Project="$(FSharpTargetsPath)" />
</Project>

## Project.fsproj
<!-- relevant changes to the fsproj here, not the entire fsproj file -->

<None Include="Template.ttus" />
<Content Include="template.txt" />

<!-- may not be relevant, but was helpful for build server -->
<Import Project="$(MSBuildProjectDirectory)\..\FTargets.proj" />
<!-- used if the templatus package starts working, otherwise not useful -->
<PropertyGroup>
    <PackagesFolder>$([System.IO.Path]::GetFullPath('$(MSBuildProjectDirectory)\..\packages'))</PackagesFolder>
</PropertyGroup>
<!-- required for templatus, hard coded to point at my local build of templatus that seems to work locally in VS2015 SP1 -->
<!-- could stand to be updated to pull in all .ttus files in the project via msbuild item group -->
<Target Name="Templates" BeforeTargets="Compile;Build" Inputs="Template.ttus" Outputs="output.txt">
    <Exec Command="C:\projects\Templatus\bin\Templatus.exe -t &quot;$(MSBuildProjectDirectory)\Template.ttus&quot; -p name=Timmy;age=3" Outputs="output.txt" />
    <!-- <Exec Command="$(PackagesFolder)\Templatus.0.2.0\tools\Templatus.exe -t &quot;$(MSBuildProjectDirectory)\Template.ttus&quot; -p name=Timmy;age=3" Outputs="output.txt" /> -->
</Target>

## Template.ttus
<#@ assembly name="C:\Windows\Microsoft.NET\Framework\v4.0.30319\System.Data.Entity.Design.dll" #>
<#@ output filename="template.txt" #>
<#
// really only handles the sql, pluralizer, and creating a string builder with all the generated code content (doesn't break up into individual files, or check out automagically)
#>
Params: <#= sprintf "Name: %s, Age: %s" name age #>

Indented numbers:
<#
[1 .. 10]
|> Seq.iter (fun num -> pushIndent " "; tprintfn "%d" num)

[9 .. -1 .. 1]
|> Seq.iter (fun num -> popIndent (); sprintf "%d" num |> tprintn)

clearIndent ()
tprintn "----"

open System
open System.Collections.Generic
open System.Linq

type CultureInfo = System.Globalization.CultureInfo
type StringBuilder = System.Text.StringBuilder
type PluralizationService = System.Data.Entity.Design.PluralizationServices.PluralizationService
type ColumnDescription = {ColumnName:string; Type:string; Length:int; Nullable:bool; IsIdentity:bool}

let cString = "Data Source=<redacted>;Initial Catalog=ApplicationDatabase;App=Templatus;User Id=<redacted>;Password=<redacted>;"
let generateTypeComment columnCount = sprintf "/// %i properties" columnCount

let mapNullableType(targetType:string , nullable:bool, useOptions:bool ) = targetType + (if nullable then (if useOptions then " option" else " Nullable") else String.Empty)

let mapSqlType(type' : string, nullable:bool , useOptions:bool ) =
    match type'.ToLower() with
        |"char"
        |"nchar"
        |"nvarchar"
        |"varchar" -> "string"
        |"bit" -> mapNullableType("bool", nullable, useOptions)
        |"date"
        |"datetime"
        |"smalldatetime" -> mapNullableType("DateTime", nullable, useOptions)
        |"uniqueidentifier" -> mapNullableType("Guid",nullable, useOptions)
        |"int" -> mapNullableType("int", nullable, useOptions)
        |"decimal" -> mapNullableType("decimal", nullable, useOptions)
        |"float" -> mapNullableType("float", nullable, useOptions)
        |_ -> if isNull type' then String.Empty else type'

let generateColumnComment (cd:ColumnDescription) = sprintf "/// %s (%i) %s" (if isNull cd.Type then "null" else cd.Type) cd.Length (if cd.Nullable then "null" else "not null")

let generateInterface (typeName:string , columns:IEnumerable<ColumnDescription> , appendLine:int * string -> unit, writeable:bool , useOptions:bool ) =
    appendLine(0, generateTypeComment (columns.Count()))
    appendLine(0,"type I" + typeName + (if writeable  then "RW" else String.Empty) + " =")
    if writeable then
        appendLine(1,"inherit I" + typeName)

    for cd in columns do
        appendLine(1, generateColumnComment cd)
        appendLine(1, "abstract member " + cd.ColumnName + ":" + mapSqlType(cd.Type, cd.Nullable, useOptions) + " with get" + (if writeable then ",set" else String.Empty))

    appendLine(0,String.Empty)

let getDefaultValue(mappedType:string ) =
    if mappedType.EndsWith("Nullable") then
        "Nullable()"
    elif mappedType.EndsWith("option") then
        "None"
    else
        match mappedType.ToLower() with
            |"int" -> "0"
            |"bool" -> "false"
            |"decimal" -> "0m"
            |"float" -> "0."
            |"datetime" -> "System.DateTime.MinValue"
            |"uniqueidentifier" -> "Guid.Empty"
            |_ -> "null"

let generateRecord(typeName:string, columns: ColumnDescription seq, appendLine:int * string -> unit, useOptions:bool) =
    appendLine(0, generateTypeComment (columns.Count()))
    if not useOptions then
        appendLine(0,"[<NoComparison>]")

    appendLine(0, "type " + typeName + "Record =")
    appendLine(1, "{")

    for cd in columns do
        appendLine(1, generateColumnComment(cd))
        appendLine(1, cd.ColumnName + ":" + mapSqlType(cd.Type,cd.Nullable,useOptions))

    appendLine(1,"}")
    appendLine(1,"interface I" + typeName + " with")

    for cd in columns do
        appendLine(2, "member x." + cd.ColumnName + " with get () = x." + cd.ColumnName)

    appendLine(1,"static member Zero () = ")
    appendLine(2,"{")

    for cd in columns do
        let mapped = mapSqlType(cd.Type, cd.Nullable, useOptions)
        appendLine(2, cd.ColumnName + " = " + getDefaultValue(mapped))

    appendLine(2,"}")
    appendLine(0,String.Empty)

let toCamel s = // https://github.com/ayoung/Newtonsoft.Json/blob/master/Newtonsoft.Json/Utilities/StringUtils.cs
    if String.IsNullOrEmpty s then
        s
    elif not <| Char.IsUpper s.[0] then
        s
    else
        let camelCase = Char.ToLower(s.[0], CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture)
        if (s.Length > 1) then
            camelCase + s.Substring(1)
        else
            camelCase

let generateModule(typeName:string, columns:IEnumerable<ColumnDescription>, schemaName:string , tableName:string , appendLine:int * string -> unit, useOptions:bool ) =
    let camelType = toCamel typeName
    appendLine(0, "module " + typeName + "Helpers =")
    appendLine(1, "open Microsoft.FSharp.Core.Operators.Unchecked")
    appendLine(1, String.Empty)
    appendLine(1, "let tableName = \"" + typeName + "\"")
    appendLine(1, "let ToRecord (i" + typeName + ":I" + typeName + ") =")
    appendLine(2, "{")

    for cd in columns do
        let mapped = mapSqlType(cd.Type,cd.Nullable,useOptions)
        appendLine(2, cd.ColumnName + " = i" + typeName + "." + cd.ColumnName)

    appendLine(2, "}")
    appendLine(0, String.Empty)

    appendLine(1, "let toRecord (" + camelType + ":I"+ typeName + ") =")
    appendLine(2, "{");

    for cd in columns do
        let mapped = mapSqlType(cd.Type,cd.Nullable,useOptions)
        appendLine(2, cd.ColumnName + " = " + camelType + "." + cd.ColumnName)

    appendLine(2, "}")
    appendLine(0,String.Empty)

    appendLine(1, "let FromF (camelTypeF:Func<string,obj option>) =")
    appendLine(2, "{")

    let mapConverter(type' : string , nullable: bool, useOptions:bool) =
        match type'.ToLower() with
            |"char"
            |"nchar"
            |"nvarchar"
            |"varchar" -> "ToString"
            |"bit" -> "ToBoolean"
            |"date"
            |"datetime"
            |"smalldatetime" -> "ToDateTime"
            |"uniqueidentifier" -> "ToGuid" // invalid
            |"int" -> "ToInt32"
            |"decimal" -> "ToDecimal"
            |"float"  -> "ToDouble"
            |_ -> if isNull type' then String.Empty else type'

    for cd in columns do
        let mapped = mapSqlType(cd.Type,cd.Nullable,useOptions)
        let converter = mapConverter(cd.Type,cd.Nullable,useOptions)
        appendLine(2, cd.ColumnName + " = ")
        appendLine(3, "match camelTypeF.Invoke \"" + cd.ColumnName + "\" with ")

        if cd.Nullable && (mapped <> typeof<string>.Name) && (mapped <> "string") && mapped <> "String" then
            appendLine(3, "|Some x -> Nullable (Convert." + converter + " x )")
        else
            appendLine(3, "|Some x -> Convert." + converter + " x ")
            appendLine(3, "|None -> Unchecked.defaultof<_>")

    appendLine(2, "}")

    appendLine(0,String.Empty)

    appendLine(1, "let inline toRecordStp (" + camelType + ": ^a) =")
    appendLine(2, "{")

    for cd in columns do
        let mapped = mapSqlType(cd.Type,cd.Nullable,useOptions)
        appendLine(2, cd.ColumnName + " = (^a: (member " + cd.ColumnName + ": _) " + camelType + ")")

    appendLine(2, "}")

    appendLine(0, String.Empty)
    appendLine(1,"let createInsert (r:I" + typeName + ") =")
    appendLine(2,"let quoted s = \"'\" + s + \"'\"")
    let mapValue (cd:ColumnDescription, prefix:string) :string  =
        match cd.Type.ToLower() with
            |"varchar" -> "if String.IsNullOrEmpty " + prefix + cd.ColumnName+ " then \"null\" else quoted " + prefix + cd.ColumnName
            |"int" -> if cd.Nullable then "if isNull (box " + prefix + cd.ColumnName + ") then \"null\" else " + prefix + cd.ColumnName + " |> string" else prefix + cd.ColumnName + " |> string"
            |_ ->  if cd.Nullable then "if isNull (box " + prefix + cd.ColumnName + ") then \"null\" else " + prefix + cd.ColumnName + " |> string |> quoted" else prefix + cd.ColumnName + " |> string |> quoted"

    appendLine(2,"[")

    for cd in columns.Where(fun c -> not c.IsIdentity) do
        let mapped = "\"" + cd.ColumnName + "\", " + mapValue(cd,"r.")
        appendLine(3,mapped)

    appendLine(2,"]")
    appendLine(2,"|> fun pairs -> sprintf \"insert into " + schemaName + "." + tableName + "(%s) values (%s)\" (String.Join(\",\", pairs |> Seq.map fst )) (String.Join(\",\", pairs |> Seq.map snd))" )
    appendLine(0,String.Empty)

let mapFieldNameFromType(columnName:string) =
    match toCamel columnName with
    | "type" ->  "type'"
    | camel -> camel

let generateClass(typeName:string, columns:IEnumerable<ColumnDescription> , appendLine:int * string -> unit, useOptions:bool ) =
    appendLine(0, generateTypeComment (columns.Count()))
    appendLine(0, "type "+ typeName + "N (model:" + typeName + "Record) = ")
    appendLine(0, String.Empty)
    appendLine(1, "let propertyChanged = new Event<_, _>()");
    appendLine(0, String.Empty)

    appendLine(0, String.Empty)
    for cd in columns do // https://fadsworld.wordpress.com/2011/05/18/f-quotations-for-inotifypropertychanged/
        let camel = mapFieldNameFromType(cd.ColumnName)
        appendLine(1, "let mutable "+ camel + " = model." + cd.ColumnName)

    appendLine(0, String.Empty)

    appendLine(1, "interface I" + typeName + " with")

    for cd in columns do
        appendLine(2,generateColumnComment cd)
        appendLine(2, "member x." + cd.ColumnName + " with get () = x." + cd.ColumnName)

    appendLine(1, "interface I" + typeName + "RW with" )

    for cd in columns do
        appendLine(2,generateColumnComment cd)
        appendLine(2, "member x." + cd.ColumnName + " with get () = x." + cd.ColumnName + " and set v = x." + cd.ColumnName + " <- v")

    appendLine(0, String.Empty)
    appendLine(1, "member x.MakeRecord () =")
    appendLine(2, "{")

    for cd in columns do
        appendLine(2, cd.ColumnName + " = x." + cd.ColumnName)

    appendLine(2, "}")

    appendLine(0, String.Empty)

    appendLine(1, "interface INotifyPropertyChanged with")
    appendLine(2, "[<CLIEvent>]")
    appendLine(2, "member x.PropertyChanged = propertyChanged.Publish")
    appendLine(1, "abstract member RaisePropertyChanged : string -> unit")
    appendLine(1, "default x.RaisePropertyChanged(propertyName : string) = propertyChanged.Trigger(x, PropertyChangedEventArgs(propertyName))")

    appendLine(0, String.Empty)
    appendLine(1, "abstract member SetAndNotify<'t> : string * 't byref * 't -> bool")
    appendLine(1, "default x.SetAndNotify<'t> (propertyName, field: 't byref, value:'t) =")
    appendLine(2, "if obj.ReferenceEquals(box field,box value) then false")
    appendLine(2, "else")
    appendLine(3, "field <- value")
    appendLine(3, "x.RaisePropertyChanged(propertyNam)");
    appendLine(3, "true")

    appendLine(0, String.Empty)
    appendLine(1, "abstract member SetAndNotify<'t,'b> : string * 'b * 't Action * 't -> bool")
    appendLine(1, "default x.SetAndNotify<'t,'b> (propertyName, baseValue:'b, baseSetter: 't Action, value:'t) =")
    appendLine(2, "if obj.ReferenceEquals(box baseValue,box value) then false")
    appendLine(2, "else");
    appendLine(3, "baseSetter.Invoke value")
    appendLine(3, "x.RaisePropertyChanged(propertyName)")
    appendLine(3, "true");

    for cd in columns do
        let camel = mapFieldNameFromType cd.ColumnName
        appendLine(0, String.Empty)
        appendLine(1, generateColumnComment cd)
        appendLine(1, "member x." + cd.ColumnName)
        appendLine(2, "with get() = " + camel)
        appendLine(2, "and set v = ")
        appendLine(3, camel + " <- v")
        appendLine(3, "x.RaisePropertyChanged \"" + cd.ColumnName + "\"")

let generate (generationEnvironment:StringBuilder, targetProjectName:string, tables:string seq, cString:string) (pluralizer:string -> string) (singularizer:string -> string) useOptions =
    let appendLine text = generationEnvironment.AppendLine(text) |> ignore
    let appendLine' (indentLevels, text) = generationEnvironment.AppendLine(String.Join(String.Empty,Enumerable.Repeat("    ",indentLevels)) + text) |> ignore
    use cn = new System.Data.SqlClient.SqlConnection(cString)
    cn.Open()
    for tableName in tables do
        //manager.StartNewFile(Path.Combine(targetProjectFolder,tableName + ".generated.fs"),targetProject)
        let typeName = singularizer tableName
        let columns = List<ColumnDescription>()
        let identities = List<string>()
        use cmd = new System.Data.SqlClient.SqlCommand("sp_help " + tableName,cn)
        use r = cmd.ExecuteReader()
        r.NextResult() |> ignore // ignore the first table
        while r.Read() do // column info
            // columns and info
            let columnName = r.["Column_name"].ToString()
            let type' = r.["Type"].ToString()
            // var computed = r["Computed"];
            let length = Convert.ToInt32(r.["Length"])
            // var prec = r["Prec"];
            columns.Add {ColumnName=columnName; Type= type'; Length=length; Nullable = r.["Nullable"].ToString() ="yes"; IsIdentity = false}

        r.NextResult() |> ignore
        while r.Read() do // identities
            if r.["Seed"] <> box System.DBNull.Value then // only valid identities (sql uses the identity column to say there are none defined instead of an empty set)
                identities.Add(r.["Identity"].ToString())
        let columns =
            columns
            |> Seq.map (fun c -> if identities.Contains(c.ColumnName) then {c with IsIdentity = true} else c)
            |> fun s -> s.ToList()

        let columns = columns.OrderBy(fun c -> c.ColumnName).ToList()
        appendLine ("namespace Pm.Schema.DataModels." + (pluralizer typeName))  // + " // Generated by item in namespace " + manager.DefaultProjectNamespace )

        appendLine String.Empty
        appendLine "open System"
        appendLine "open System.ComponentModel"
        appendLine "open System.Linq.Expressions"
        appendLine String.Empty
        appendLine "open FSharp.NullHelpers"

        generateInterface (typeName, columns, appendLine', false, useOptions)
        generateInterface (typeName, columns, appendLine', true, useOptions)
        generateRecord(typeName, columns, appendLine', useOptions)
        generateModule(typeName, columns, "dbo", tableName, appendLine', useOptions)
        generateClass(typeName, columns, appendLine', useOptions)

let sb = StringBuilder()
let pluralizer = PluralizationService.CreateService(CultureInfo "en") // https://msdn.microsoft.com/en-us/library/system.data.entity.design.pluralizationservices.pluralizationservice(v=vs.110).aspx
generate (sb, "Pm.Schema", ["Users"], cString) (pluralizer.Pluralize) (pluralizer.Singularize) false
tprint (sb.ToString())
#>

## template.txt
Params: Name: Timmy, Age: 3

Indented numbers:
 1
  2
   3
    4
     5
      6
       7
        8
         9
          10
         9
        8
       7
      6
     5
    4
   3
  2
 1
----
namespace Pm.Schema.DataModels.Users

open System
open System.ComponentModel
open System.Linq.Expressions

open FSharp.NullHelpers
/// 13 properties
type IUser =
    /// bit (1) not null
    abstract member IsLockedOut:bool with get
    /// int (4) not null
    abstract member LoginAttempts:int with get
    /// varchar (50) null
    abstract member RcopiaID:string with get
    /// bit (1) not null
    abstract member ResetPassword:bool with get
    /// int (4) not null
    abstract member UserFacilityID:int with get
    /// varchar (50) not null
    abstract member UserFirstName:string with get
    /// int (4) not null
    abstract member UserID:int with get
    /// varchar (50) not null
    abstract member UserLastName:string with get
    /// int (4) not null
    abstract member UserLevel:int with get
    /// varchar (1) null
    abstract member UserMiddleInitial:string with get
    /// varchar (50) null
    abstract member UserName:string with get
    /// varchar (50) not null
    abstract member UserPassword:string with get
    /// bit (1) not null
    abstract member UserPreviouslyLoggedIn:bool with get

/// 13 properties
type IUserRW =
    inherit IUser
    /// bit (1) not null
    abstract member IsLockedOut:bool with get,set
    /// int (4) not null
    abstract member LoginAttempts:int with get,set
    /// varchar (50) null
    abstract member RcopiaID:string with get,set
    /// bit (1) not null
    abstract member ResetPassword:bool with get,set
    /// int (4) not null
    abstract member UserFacilityID:int with get,set
    /// varchar (50) not null
    abstract member UserFirstName:string with get,set
    /// int (4) not null
    abstract member UserID:int with get,set
    /// varchar (50) not null
    abstract member UserLastName:string with get,set
    /// int (4) not null
    abstract member UserLevel:int with get,set
    /// varchar (1) null
    abstract member UserMiddleInitial:string with get,set
    /// varchar (50) null
    abstract member UserName:string with get,set
    /// varchar (50) not null
    abstract member UserPassword:string with get,set
    /// bit (1) not null
    abstract member UserPreviouslyLoggedIn:bool with get,set

/// 13 properties
[<NoComparison>]
type UserRecord =
    {
    /// bit (1) not null
    IsLockedOut:bool
    /// int (4) not null
    LoginAttempts:int
    /// varchar (50) null
    RcopiaID:string
    /// bit (1) not null
    ResetPassword:bool
    /// int (4) not null
    UserFacilityID:int
    /// varchar (50) not null
    UserFirstName:string
    /// int (4) not null
    UserID:int
    /// varchar (50) not null
    UserLastName:string
    /// int (4) not null
    UserLevel:int
    /// varchar (1) null
    UserMiddleInitial:string
    /// varchar (50) null
    UserName:string
    /// varchar (50) not null
    UserPassword:string
    /// bit (1) not null
    UserPreviouslyLoggedIn:bool
    }
    interface IUser with
        member x.IsLockedOut with get () = x.IsLockedOut
        member x.LoginAttempts with get () = x.LoginAttempts
        member x.RcopiaID with get () = x.RcopiaID
        member x.ResetPassword with get () = x.ResetPassword
        member x.UserFacilityID with get () = x.UserFacilityID
        member x.UserFirstName with get () = x.UserFirstName
        member x.UserID with get () = x.UserID
        member x.UserLastName with get () = x.UserLastName
        member x.UserLevel with get () = x.UserLevel
        member x.UserMiddleInitial with get () = x.UserMiddleInitial
        member x.UserName with get () = x.UserName
        member x.UserPassword with get () = x.UserPassword
        member x.UserPreviouslyLoggedIn with get () = x.UserPreviouslyLoggedIn
    static member Zero () =
        {
        IsLockedOut = false
        LoginAttempts = 0
        RcopiaID = null
        ResetPassword = false
        UserFacilityID = 0
        UserFirstName = null
        UserID = 0
        UserLastName = null
        UserLevel = 0
        UserMiddleInitial = null
        UserName = null
        UserPassword = null
        UserPreviouslyLoggedIn = false
        }

module UserHelpers =
    open Microsoft.FSharp.Core.Operators.Unchecked

    let tableName = "User"
    let ToRecord (iUser:IUser) =
        {
        IsLockedOut = iUser.IsLockedOut
        LoginAttempts = iUser.LoginAttempts
        RcopiaID = iUser.RcopiaID
        ResetPassword = iUser.ResetPassword
        UserFacilityID = iUser.UserFacilityID
        UserFirstName = iUser.UserFirstName
        UserID = iUser.UserID
        UserLastName = iUser.UserLastName
        UserLevel = iUser.UserLevel
        UserMiddleInitial = iUser.UserMiddleInitial
        UserName = iUser.UserName
        UserPassword = iUser.UserPassword
        UserPreviouslyLoggedIn = iUser.UserPreviouslyLoggedIn
        }

    let toRecord (user:IUser) =
        {
        IsLockedOut = user.IsLockedOut
        LoginAttempts = user.LoginAttempts
        RcopiaID = user.RcopiaID
        ResetPassword = user.ResetPassword
        UserFacilityID = user.UserFacilityID
        UserFirstName = user.UserFirstName
        UserID = user.UserID
        UserLastName = user.UserLastName
        UserLevel = user.UserLevel
        UserMiddleInitial = user.UserMiddleInitial
        UserName = user.UserName
        UserPassword = user.UserPassword
        UserPreviouslyLoggedIn = user.UserPreviouslyLoggedIn
        }

    let FromF (camelTypeF:Func<string,obj option>) =
        {
        IsLockedOut =
            match camelTypeF.Invoke "IsLockedOut" with
            |Some x -> Convert.ToBoolean x
            |None -> Unchecked.defaultof<_>
        LoginAttempts =
            match camelTypeF.Invoke "LoginAttempts" with
            |Some x -> Convert.ToInt32 x
            |None -> Unchecked.defaultof<_>
        RcopiaID =
            match camelTypeF.Invoke "RcopiaID" with
            |Some x -> Convert.ToString x
            |None -> Unchecked.defaultof<_>
        ResetPassword =
            match camelTypeF.Invoke "ResetPassword" with
            |Some x -> Convert.ToBoolean x
            |None -> Unchecked.defaultof<_>
        UserFacilityID =
            match camelTypeF.Invoke "UserFacilityID" with
            |Some x -> Convert.ToInt32 x
            |None -> Unchecked.defaultof<_>
        UserFirstName =
            match camelTypeF.Invoke "UserFirstName" with
            |Some x -> Convert.ToString x
            |None -> Unchecked.defaultof<_>
        UserID =
            match camelTypeF.Invoke "UserID" with
            |Some x -> Convert.ToInt32 x
            |None -> Unchecked.defaultof<_>
        UserLastName =
            match camelTypeF.Invoke "UserLastName" with
            |Some x -> Convert.ToString x
            |None -> Unchecked.defaultof<_>
        UserLevel =
            match camelTypeF.Invoke "UserLevel" with
            |Some x -> Convert.ToInt32 x
            |None -> Unchecked.defaultof<_>
        UserMiddleInitial =
            match camelTypeF.Invoke "UserMiddleInitial" with
            |Some x -> Convert.ToString x
            |None -> Unchecked.defaultof<_>
        UserName =
            match camelTypeF.Invoke "UserName" with
            |Some x -> Convert.ToString x
            |None -> Unchecked.defaultof<_>
        UserPassword =
            match camelTypeF.Invoke "UserPassword" with
            |Some x -> Convert.ToString x
            |None -> Unchecked.defaultof<_>
        UserPreviouslyLoggedIn =
            match camelTypeF.Invoke "UserPreviouslyLoggedIn" with
            |Some x -> Convert.ToBoolean x
            |None -> Unchecked.defaultof<_>
        }

    let inline toRecordStp (user: ^a) =
        {
        IsLockedOut = (^a: (member IsLockedOut: _) user)
        LoginAttempts = (^a: (member LoginAttempts: _) user)
        RcopiaID = (^a: (member RcopiaID: _) user)
        ResetPassword = (^a: (member ResetPassword: _) user)
        UserFacilityID = (^a: (member UserFacilityID: _) user)
        UserFirstName = (^a: (member UserFirstName: _) user)
        UserID = (^a: (member UserID: _) user)
        UserLastName = (^a: (member UserLastName: _) user)
        UserLevel = (^a: (member UserLevel: _) user)
        UserMiddleInitial = (^a: (member UserMiddleInitial: _) user)
        UserName = (^a: (member UserName: _) user)
        UserPassword = (^a: (member UserPassword: _) user)
        UserPreviouslyLoggedIn = (^a: (member UserPreviouslyLoggedIn: _) user)
        }

    let createInsert (r:IUser) =
        let quoted s = "'" + s + "'"
        [
            "IsLockedOut", r.IsLockedOut |> string |> quoted
            "LoginAttempts", r.LoginAttempts |> string
            "RcopiaID", if String.IsNullOrEmpty r.RcopiaID then "null" else quoted r.RcopiaID
            "ResetPassword", r.ResetPassword |> string |> quoted
            "UserFacilityID", r.UserFacilityID |> string
            "UserFirstName", if String.IsNullOrEmpty r.UserFirstName then "null" else quoted r.UserFirstName
            "UserLastName", if String.IsNullOrEmpty r.UserLastName then "null" else quoted r.UserLastName
            "UserLevel", r.UserLevel |> string
            "UserMiddleInitial", if String.IsNullOrEmpty r.UserMiddleInitial then "null" else quoted r.UserMiddleInitial
            "UserName", if String.IsNullOrEmpty r.UserName then "null" else quoted r.UserName
            "UserPassword", if String.IsNullOrEmpty r.UserPassword then "null" else quoted r.UserPassword
            "UserPreviouslyLoggedIn", r.UserPreviouslyLoggedIn |> string |> quoted
        ]
        |> fun pairs -> sprintf "insert into dbo.Users(%s) values (%s)" (String.Join(",", pairs |> Seq.map fst )) (String.Join(",", pairs |> Seq.map snd))

/// 13 properties
type UserN (model:UserRecord) =

    let propertyChanged = new Event<_, _>()


    let mutable isLockedOut = model.IsLockedOut
    let mutable loginAttempts = model.LoginAttempts
    let mutable rcopiaID = model.RcopiaID
    let mutable resetPassword = model.ResetPassword
    let mutable userFacilityID = model.UserFacilityID
    let mutable userFirstName = model.UserFirstName
    let mutable userID = model.UserID
    let mutable userLastName = model.UserLastName
    let mutable userLevel = model.UserLevel
    let mutable userMiddleInitial = model.UserMiddleInitial
    let mutable userName = model.UserName
    let mutable userPassword = model.UserPassword
    let mutable userPreviouslyLoggedIn = model.UserPreviouslyLoggedIn

    interface IUser with
        /// bit (1) not null
        member x.IsLockedOut with get () = x.IsLockedOut
        /// int (4) not null
        member x.LoginAttempts with get () = x.LoginAttempts
        /// varchar (50) null
        member x.RcopiaID with get () = x.RcopiaID
        /// bit (1) not null
        member x.ResetPassword with get () = x.ResetPassword
        /// int (4) not null
        member x.UserFacilityID with get () = x.UserFacilityID
        /// varchar (50) not null
        member x.UserFirstName with get () = x.UserFirstName
        /// int (4) not null
        member x.UserID with get () = x.UserID
        /// varchar (50) not null
        member x.UserLastName with get () = x.UserLastName
        /// int (4) not null
        member x.UserLevel with get () = x.UserLevel
        /// varchar (1) null
        member x.UserMiddleInitial with get () = x.UserMiddleInitial
        /// varchar (50) null
        member x.UserName with get () = x.UserName
        /// varchar (50) not null
        member x.UserPassword with get () = x.UserPassword
        /// bit (1) not null
        member x.UserPreviouslyLoggedIn with get () = x.UserPreviouslyLoggedIn
    interface IUserRW with
        /// bit (1) not null
        member x.IsLockedOut with get () = x.IsLockedOut and set v = x.IsLockedOut <- v
        /// int (4) not null
        member x.LoginAttempts with get () = x.LoginAttempts and set v = x.LoginAttempts <- v
        /// varchar (50) null
        member x.RcopiaID with get () = x.RcopiaID and set v = x.RcopiaID <- v
        /// bit (1) not null
        member x.ResetPassword with get () = x.ResetPassword and set v = x.ResetPassword <- v
        /// int (4) not null
        member x.UserFacilityID with get () = x.UserFacilityID and set v = x.UserFacilityID <- v
        /// varchar (50) not null
        member x.UserFirstName with get () = x.UserFirstName and set v = x.UserFirstName <- v
        /// int (4) not null
        member x.UserID with get () = x.UserID and set v = x.UserID <- v
        /// varchar (50) not null
        member x.UserLastName with get () = x.UserLastName and set v = x.UserLastName <- v
        /// int (4) not null
        member x.UserLevel with get () = x.UserLevel and set v = x.UserLevel <- v
        /// varchar (1) null
        member x.UserMiddleInitial with get () = x.UserMiddleInitial and set v = x.UserMiddleInitial <- v
        /// varchar (50) null
        member x.UserName with get () = x.UserName and set v = x.UserName <- v
        /// varchar (50) not null
        member x.UserPassword with get () = x.UserPassword and set v = x.UserPassword <- v
        /// bit (1) not null
        member x.UserPreviouslyLoggedIn with get () = x.UserPreviouslyLoggedIn and set v = x.UserPreviouslyLoggedIn <- v

    member x.MakeRecord () =
        {
        IsLockedOut = x.IsLockedOut
        LoginAttempts = x.LoginAttempts
        RcopiaID = x.RcopiaID
        ResetPassword = x.ResetPassword
        UserFacilityID = x.UserFacilityID
        UserFirstName = x.UserFirstName
        UserID = x.UserID
        UserLastName = x.UserLastName
        UserLevel = x.UserLevel
        UserMiddleInitial = x.UserMiddleInitial
        UserName = x.UserName
        UserPassword = x.UserPassword
        UserPreviouslyLoggedIn = x.UserPreviouslyLoggedIn
        }

    interface INotifyPropertyChanged with
        [<CLIEvent>]
        member x.PropertyChanged = propertyChanged.Publish
    abstract member RaisePropertyChanged : string -> unit
    default x.RaisePropertyChanged(propertyName : string) = propertyChanged.Trigger(x, PropertyChangedEventArgs(propertyName))

    abstract member SetAndNotify<'t> : string * 't byref * 't -> bool
    default x.SetAndNotify<'t> (propertyName, field: 't byref, value:'t) =
        if obj.ReferenceEquals(box field,box value) then false
        else
            field <- value
            x.RaisePropertyChanged(propertyNam)
            true

    abstract member SetAndNotify<'t,'b> : string * 'b * 't Action * 't -> bool
    default x.SetAndNotify<'t,'b> (propertyName, baseValue:'b, baseSetter: 't Action, value:'t) =
        if obj.ReferenceEquals(box baseValue,box value) then false
        else
            baseSetter.Invoke value
            x.RaisePropertyChanged(propertyName)
            true

    /// bit (1) not null
    member x.IsLockedOut
        with get() = isLockedOut
        and set v =
            isLockedOut <- v
            x.RaisePropertyChanged "IsLockedOut"

    /// int (4) not null
    member x.LoginAttempts
        with get() = loginAttempts
        and set v =
            loginAttempts <- v
            x.RaisePropertyChanged "LoginAttempts"

    /// varchar (50) null
    member x.RcopiaID
        with get() = rcopiaID
        and set v =
            rcopiaID <- v
            x.RaisePropertyChanged "RcopiaID"

    /// bit (1) not null
    member x.ResetPassword
        with get() = resetPassword
        and set v =
            resetPassword <- v
            x.RaisePropertyChanged "ResetPassword"

    /// int (4) not null
    member x.UserFacilityID
        with get() = userFacilityID
        and set v =
            userFacilityID <- v
            x.RaisePropertyChanged "UserFacilityID"

    /// varchar (50) not null
    member x.UserFirstName
        with get() = userFirstName
        and set v =
            userFirstName <- v
            x.RaisePropertyChanged "UserFirstName"

    /// int (4) not null
    member x.UserID
        with get() = userID
        and set v =
            userID <- v
            x.RaisePropertyChanged "UserID"

    /// varchar (50) not null
    member x.UserLastName
        with get() = userLastName
        and set v =
            userLastName <- v
            x.RaisePropertyChanged "UserLastName"

    /// int (4) not null
    member x.UserLevel
        with get() = userLevel
        and set v =
            userLevel <- v
            x.RaisePropertyChanged "UserLevel"

    /// varchar (1) null
    member x.UserMiddleInitial
        with get() = userMiddleInitial
        and set v =
            userMiddleInitial <- v
            x.RaisePropertyChanged "UserMiddleInitial"

    /// varchar (50) null
    member x.UserName
        with get() = userName
        and set v =
            userName <- v
            x.RaisePropertyChanged "UserName"

    /// varchar (50) not null
    member x.UserPassword
        with get() = userPassword
        and set v =
            userPassword <- v
            x.RaisePropertyChanged "UserPassword"

    /// bit (1) not null
    member x.UserPreviouslyLoggedIn
        with get() = userPreviouslyLoggedIn
        and set v =
            userPreviouslyLoggedIn <- v
            x.RaisePropertyChanged "UserPreviouslyLoggedIn"
	<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
	<PropertyGroup>
	<!-- for build server primarily -->
	<FSharpTargetsPath Condition="'$(FSharpTargetsPath)' == '' And Exists('C:\Program Files (x86)\Microsoft SDKs\F#\4.0\Framework\v4.0\Microsoft.FSharp.Targets')">C:\Program Files (x86)\Microsoft SDKs\F#\4.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
	<FSharpTargetsPath Condition="'$(FSharpTargetsPath)' == '' And Exists('C:\Program Files (x86)\Microsoft SDKs\F#\3.1\Framework\v4.0')">C:\Program Files (x86)\Microsoft SDKs\F#\3.1\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
	<FSharpTargetsPath Condition="'$(FSharpTargetsPath)' == '' ">..\3rdParty\Microsoft.FSharp.Targets</FSharpTargetsPath>
	<!-- love these option settings, but not required -->
	<WarningLevel>5</WarningLevel>
	<OtherFlags>--warnon:1182 --warnaserror-:0052</OtherFlags>
	<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
	</PropertyGroup>
	<Choose>
	<When Condition="'$(VisualStudioVersion)' == '11.0'">
	<PropertyGroup Condition="'$(FSharpTargetsPath)' == '' And Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')">
	<FSharpTargetsPath>$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets</FSharpTargetsPath>
	</PropertyGroup>
	</When>
	<Otherwise>
	<PropertyGroup Condition="'$(FSharpTargetsPath)' == '' And Exists('$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets')">
	<FSharpTargetsPath>$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets</FSharpTargetsPath>
	</PropertyGroup>
	</Otherwise>
	</Choose>
	<Target Name="FDiagnostics" BeforeTargets="Build">
	<Message Importance="high" Text="MSBuildExtensionsPath32:$(MSBuildExtensionsPath32)" />
	<Message Importance="high" Text="FSharpTargetsPath:$(FSharpTargetsPath)" />
	<Message Importance="high" Condition="Exists('$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\FSharp\Microsoft.FSharp.Targets')" Text="FSharpTargetsPath:Exists" />
	</Target>
	<Import Project="$(FSharpTargetsPath)" />
	</Project>
	<!-- relevant changes to the fsproj here, not the entire fsproj file -->

	<None Include="Template.ttus" />
	<Content Include="template.txt" />

	<!-- may not be relevant, but was helpful for build server -->
	<Import Project="$(MSBuildProjectDirectory)\..\FTargets.proj" />
	<!-- used if the templatus package starts working, otherwise not useful -->
	<PropertyGroup>
	<PackagesFolder>$([System.IO.Path]::GetFullPath('$(MSBuildProjectDirectory)\..\packages'))</PackagesFolder>
	</PropertyGroup>
	<!-- required for templatus, hard coded to point at my local build of templatus that seems to work locally in VS2015 SP1 -->
	<!-- could stand to be updated to pull in all .ttus files in the project via msbuild item group -->
	<Target Name="Templates" BeforeTargets="Compile;Build" Inputs="Template.ttus" Outputs="output.txt">
	<Exec Command="C:\projects\Templatus\bin\Templatus.exe -t "$(MSBuildProjectDirectory)\Template.ttus" -p name=Timmy;age=3" Outputs="output.txt" />
	<!-- <Exec Command="$(PackagesFolder)\Templatus.0.2.0\tools\Templatus.exe -t "$(MSBuildProjectDirectory)\Template.ttus" -p name=Timmy;age=3" Outputs="output.txt" /> -->
	</Target>
	<#@ assembly name="C:\Windows\Microsoft.NET\Framework\v4.0.30319\System.Data.Entity.Design.dll" #>
	<#@ output filename="template.txt" #>
	<#
	// really only handles the sql, pluralizer, and creating a string builder with all the generated code content (doesn't break up into individual files, or check out automagically)
	#>
	Params: <#= sprintf "Name: %s, Age: %s" name age #>

	Indented numbers:
	<#
	[1 .. 10]
	\|> Seq.iter (fun num -> pushIndent " "; tprintfn "%d" num)

	[9 .. -1 .. 1]
	\|> Seq.iter (fun num -> popIndent (); sprintf "%d" num \|> tprintn)

	clearIndent ()
	tprintn "----"

	open System
	open System.Collections.Generic
	open System.Linq

	type CultureInfo = System.Globalization.CultureInfo
	type StringBuilder = System.Text.StringBuilder
	type PluralizationService = System.Data.Entity.Design.PluralizationServices.PluralizationService
	type ColumnDescription = {ColumnName:string; Type:string; Length:int; Nullable:bool; IsIdentity:bool}

	let cString = "Data Source=<redacted>;Initial Catalog=ApplicationDatabase;App=Templatus;User Id=<redacted>;Password=<redacted>;"
	let generateTypeComment columnCount = sprintf "/// %i properties" columnCount

	let mapNullableType(targetType:string , nullable:bool, useOptions:bool ) = targetType + (if nullable then (if useOptions then " option" else " Nullable") else String.Empty)

	let mapSqlType(type' : string, nullable:bool , useOptions:bool ) =
	match type'.ToLower() with
	\|"char"
	\|"nchar"
	\|"nvarchar"
	\|"varchar" -> "string"
	\|"bit" -> mapNullableType("bool", nullable, useOptions)
	\|"date"
	\|"datetime"
	\|"smalldatetime" -> mapNullableType("DateTime", nullable, useOptions)
	\|"uniqueidentifier" -> mapNullableType("Guid",nullable, useOptions)
	\|"int" -> mapNullableType("int", nullable, useOptions)
	\|"decimal" -> mapNullableType("decimal", nullable, useOptions)
	\|"float" -> mapNullableType("float", nullable, useOptions)
	\|_ -> if isNull type' then String.Empty else type'

	let generateColumnComment (cd:ColumnDescription) = sprintf "/// %s (%i) %s" (if isNull cd.Type then "null" else cd.Type) cd.Length (if cd.Nullable then "null" else "not null")

	let generateInterface (typeName:string , columns:IEnumerable<ColumnDescription> , appendLine:int * string -> unit, writeable:bool , useOptions:bool ) =
	appendLine(0, generateTypeComment (columns.Count()))
	appendLine(0,"type I" + typeName + (if writeable then "RW" else String.Empty) + " =")
	if writeable then
	appendLine(1,"inherit I" + typeName)

	for cd in columns do
	appendLine(1, generateColumnComment cd)
	appendLine(1, "abstract member " + cd.ColumnName + ":" + mapSqlType(cd.Type, cd.Nullable, useOptions) + " with get" + (if writeable then ",set" else String.Empty))

	appendLine(0,String.Empty)

	let getDefaultValue(mappedType:string ) =
	if mappedType.EndsWith("Nullable") then
	"Nullable()"
	elif mappedType.EndsWith("option") then
	"None"
	else
	match mappedType.ToLower() with
	\|"int" -> "0"
	\|"bool" -> "false"
	\|"decimal" -> "0m"
	\|"float" -> "0."
	\|"datetime" -> "System.DateTime.MinValue"
	\|"uniqueidentifier" -> "Guid.Empty"
	\|_ -> "null"

	let generateRecord(typeName:string, columns: ColumnDescription seq, appendLine:int * string -> unit, useOptions:bool) =
	appendLine(0, generateTypeComment (columns.Count()))
	if not useOptions then
	appendLine(0,"[<NoComparison>]")

	appendLine(0, "type " + typeName + "Record =")
	appendLine(1, "{")

	for cd in columns do
	appendLine(1, generateColumnComment(cd))
	appendLine(1, cd.ColumnName + ":" + mapSqlType(cd.Type,cd.Nullable,useOptions))

	appendLine(1,"}")
	appendLine(1,"interface I" + typeName + " with")

	for cd in columns do
	appendLine(2, "member x." + cd.ColumnName + " with get () = x." + cd.ColumnName)

	appendLine(1,"static member Zero () = ")
	appendLine(2,"{")

	for cd in columns do
	let mapped = mapSqlType(cd.Type, cd.Nullable, useOptions)
	appendLine(2, cd.ColumnName + " = " + getDefaultValue(mapped))

	appendLine(2,"}")
	appendLine(0,String.Empty)

	let toCamel s = // https://github.com/ayoung/Newtonsoft.Json/blob/master/Newtonsoft.Json/Utilities/StringUtils.cs
	if String.IsNullOrEmpty s then
	s
	elif not <\| Char.IsUpper s.[0] then
	s
	else
	let camelCase = Char.ToLower(s.[0], CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture)
	if (s.Length > 1) then
	camelCase + s.Substring(1)
	else
	camelCase

	let generateModule(typeName:string, columns:IEnumerable<ColumnDescription>, schemaName:string , tableName:string , appendLine:int * string -> unit, useOptions:bool ) =
	let camelType = toCamel typeName
	appendLine(0, "module " + typeName + "Helpers =")
	appendLine(1, "open Microsoft.FSharp.Core.Operators.Unchecked")
	appendLine(1, String.Empty)
	appendLine(1, "let tableName = \"" + typeName + "\"")
	appendLine(1, "let ToRecord (i" + typeName + ":I" + typeName + ") =")
	appendLine(2, "{")

	for cd in columns do
	let mapped = mapSqlType(cd.Type,cd.Nullable,useOptions)
	appendLine(2, cd.ColumnName + " = i" + typeName + "." + cd.ColumnName)

	appendLine(2, "}")
	appendLine(0, String.Empty)

	appendLine(1, "let toRecord (" + camelType + ":I"+ typeName + ") =")
	appendLine(2, "{");

	for cd in columns do
	let mapped = mapSqlType(cd.Type,cd.Nullable,useOptions)
	appendLine(2, cd.ColumnName + " = " + camelType + "." + cd.ColumnName)

	appendLine(2, "}")
	appendLine(0,String.Empty)

	appendLine(1, "let FromF (camelTypeF:Func<string,obj option>) =")
	appendLine(2, "{")

	let mapConverter(type' : string , nullable: bool, useOptions:bool) =
	match type'.ToLower() with
	\|"char"
	\|"nchar"
	\|"nvarchar"
	\|"varchar" -> "ToString"
	\|"bit" -> "ToBoolean"
	\|"date"
	\|"datetime"
	\|"smalldatetime" -> "ToDateTime"
	\|"uniqueidentifier" -> "ToGuid" // invalid
	\|"int" -> "ToInt32"
	\|"decimal" -> "ToDecimal"
	\|"float" -> "ToDouble"
	\|_ -> if isNull type' then String.Empty else type'

	for cd in columns do
	let mapped = mapSqlType(cd.Type,cd.Nullable,useOptions)
	let converter = mapConverter(cd.Type,cd.Nullable,useOptions)
	appendLine(2, cd.ColumnName + " = ")
	appendLine(3, "match camelTypeF.Invoke \"" + cd.ColumnName + "\" with ")

	if cd.Nullable && (mapped <> typeof<string>.Name) && (mapped <> "string") && mapped <> "String" then
	appendLine(3, "\|Some x -> Nullable (Convert." + converter + " x )")
	else
	appendLine(3, "\|Some x -> Convert." + converter + " x ")
	appendLine(3, "\|None -> Unchecked.defaultof<_>")

	appendLine(2, "}")

	appendLine(0,String.Empty)

	appendLine(1, "let inline toRecordStp (" + camelType + ": ^a) =")
	appendLine(2, "{")

	for cd in columns do
	let mapped = mapSqlType(cd.Type,cd.Nullable,useOptions)
	appendLine(2, cd.ColumnName + " = (^a: (member " + cd.ColumnName + ": _) " + camelType + ")")

	appendLine(2, "}")

	appendLine(0, String.Empty)
	appendLine(1,"let createInsert (r:I" + typeName + ") =")
	appendLine(2,"let quoted s = \"'\" + s + \"'\"")
	let mapValue (cd:ColumnDescription, prefix:string) :string =
	match cd.Type.ToLower() with
	\|"varchar" -> "if String.IsNullOrEmpty " + prefix + cd.ColumnName+ " then \"null\" else quoted " + prefix + cd.ColumnName
	\|"int" -> if cd.Nullable then "if isNull (box " + prefix + cd.ColumnName + ") then \"null\" else " + prefix + cd.ColumnName + " \|> string" else prefix + cd.ColumnName + " \|> string"
	\|_ -> if cd.Nullable then "if isNull (box " + prefix + cd.ColumnName + ") then \"null\" else " + prefix + cd.ColumnName + " \|> string \|> quoted" else prefix + cd.ColumnName + " \|> string \|> quoted"

	appendLine(2,"[")

	for cd in columns.Where(fun c -> not c.IsIdentity) do
	let mapped = "\"" + cd.ColumnName + "\", " + mapValue(cd,"r.")
	appendLine(3,mapped)

	appendLine(2,"]")
	appendLine(2,"\|> fun pairs -> sprintf \"insert into " + schemaName + "." + tableName + "(%s) values (%s)\" (String.Join(\",\", pairs \|> Seq.map fst )) (String.Join(\",\", pairs \|> Seq.map snd))" )
	appendLine(0,String.Empty)

	let mapFieldNameFromType(columnName:string) =
	match toCamel columnName with
	\| "type" -> "type'"
	\| camel -> camel

	let generateClass(typeName:string, columns:IEnumerable<ColumnDescription> , appendLine:int * string -> unit, useOptions:bool ) =
	appendLine(0, generateTypeComment (columns.Count()))
	appendLine(0, "type "+ typeName + "N (model:" + typeName + "Record) = ")
	appendLine(0, String.Empty)
	appendLine(1, "let propertyChanged = new Event<_, _>()");
	appendLine(0, String.Empty)

	appendLine(0, String.Empty)
	for cd in columns do // https://fadsworld.wordpress.com/2011/05/18/f-quotations-for-inotifypropertychanged/
	let camel = mapFieldNameFromType(cd.ColumnName)
	appendLine(1, "let mutable "+ camel + " = model." + cd.ColumnName)

	appendLine(0, String.Empty)

	appendLine(1, "interface I" + typeName + " with")

	for cd in columns do
	appendLine(2,generateColumnComment cd)
	appendLine(2, "member x." + cd.ColumnName + " with get () = x." + cd.ColumnName)

	appendLine(1, "interface I" + typeName + "RW with" )

	for cd in columns do
	appendLine(2,generateColumnComment cd)
	appendLine(2, "member x." + cd.ColumnName + " with get () = x." + cd.ColumnName + " and set v = x." + cd.ColumnName + " <- v")

	appendLine(0, String.Empty)
	appendLine(1, "member x.MakeRecord () =")
	appendLine(2, "{")

	for cd in columns do
	appendLine(2, cd.ColumnName + " = x." + cd.ColumnName)

	appendLine(2, "}")

	appendLine(0, String.Empty)

	appendLine(1, "interface INotifyPropertyChanged with")
	appendLine(2, "[<CLIEvent>]")
	appendLine(2, "member x.PropertyChanged = propertyChanged.Publish")
	appendLine(1, "abstract member RaisePropertyChanged : string -> unit")
	appendLine(1, "default x.RaisePropertyChanged(propertyName : string) = propertyChanged.Trigger(x, PropertyChangedEventArgs(propertyName))")

	appendLine(0, String.Empty)
	appendLine(1, "abstract member SetAndNotify<'t> : string * 't byref * 't -> bool")
	appendLine(1, "default x.SetAndNotify<'t> (propertyName, field: 't byref, value:'t) =")
	appendLine(2, "if obj.ReferenceEquals(box field,box value) then false")
	appendLine(2, "else")
	appendLine(3, "field <- value")
	appendLine(3, "x.RaisePropertyChanged(propertyNam)");
	appendLine(3, "true")

	appendLine(0, String.Empty)
	appendLine(1, "abstract member SetAndNotify<'t,'b> : string * 'b * 't Action * 't -> bool")
	appendLine(1, "default x.SetAndNotify<'t,'b> (propertyName, baseValue:'b, baseSetter: 't Action, value:'t) =")
	appendLine(2, "if obj.ReferenceEquals(box baseValue,box value) then false")
	appendLine(2, "else");
	appendLine(3, "baseSetter.Invoke value")
	appendLine(3, "x.RaisePropertyChanged(propertyName)")
	appendLine(3, "true");

	for cd in columns do
	let camel = mapFieldNameFromType cd.ColumnName
	appendLine(0, String.Empty)
	appendLine(1, generateColumnComment cd)
	appendLine(1, "member x." + cd.ColumnName)
	appendLine(2, "with get() = " + camel)
	appendLine(2, "and set v = ")
	appendLine(3, camel + " <- v")
	appendLine(3, "x.RaisePropertyChanged \"" + cd.ColumnName + "\"")

	let generate (generationEnvironment:StringBuilder, targetProjectName:string, tables:string seq, cString:string) (pluralizer:string -> string) (singularizer:string -> string) useOptions =
	let appendLine text = generationEnvironment.AppendLine(text) \|> ignore
	let appendLine' (indentLevels, text) = generationEnvironment.AppendLine(String.Join(String.Empty,Enumerable.Repeat(" ",indentLevels)) + text) \|> ignore
	use cn = new System.Data.SqlClient.SqlConnection(cString)
	cn.Open()
	for tableName in tables do
	//manager.StartNewFile(Path.Combine(targetProjectFolder,tableName + ".generated.fs"),targetProject)
	let typeName = singularizer tableName
	let columns = List<ColumnDescription>()
	let identities = List<string>()
	use cmd = new System.Data.SqlClient.SqlCommand("sp_help " + tableName,cn)
	use r = cmd.ExecuteReader()
	r.NextResult() \|> ignore // ignore the first table
	while r.Read() do // column info
	// columns and info
	let columnName = r.["Column_name"].ToString()
	let type' = r.["Type"].ToString()
	// var computed = r["Computed"];
	let length = Convert.ToInt32(r.["Length"])
	// var prec = r["Prec"];
	columns.Add {ColumnName=columnName; Type= type'; Length=length; Nullable = r.["Nullable"].ToString() ="yes"; IsIdentity = false}

	r.NextResult() \|> ignore
	while r.Read() do // identities
	if r.["Seed"] <> box System.DBNull.Value then // only valid identities (sql uses the identity column to say there are none defined instead of an empty set)
	identities.Add(r.["Identity"].ToString())
	let columns =
	columns
	\|> Seq.map (fun c -> if identities.Contains(c.ColumnName) then {c with IsIdentity = true} else c)
	\|> fun s -> s.ToList()

	let columns = columns.OrderBy(fun c -> c.ColumnName).ToList()
	appendLine ("namespace Pm.Schema.DataModels." + (pluralizer typeName)) // + " // Generated by item in namespace " + manager.DefaultProjectNamespace )

	appendLine String.Empty
	appendLine "open System"
	appendLine "open System.ComponentModel"
	appendLine "open System.Linq.Expressions"
	appendLine String.Empty
	appendLine "open FSharp.NullHelpers"

	generateInterface (typeName, columns, appendLine', false, useOptions)
	generateInterface (typeName, columns, appendLine', true, useOptions)
	generateRecord(typeName, columns, appendLine', useOptions)
	generateModule(typeName, columns, "dbo", tableName, appendLine', useOptions)
	generateClass(typeName, columns, appendLine', useOptions)

	let sb = StringBuilder()
	let pluralizer = PluralizationService.CreateService(CultureInfo "en") // https://msdn.microsoft.com/en-us/library/system.data.entity.design.pluralizationservices.pluralizationservice(v=vs.110).aspx
	generate (sb, "Pm.Schema", ["Users"], cString) (pluralizer.Pluralize) (pluralizer.Singularize) false
	tprint (sb.ToString())
	#>
	Params: Name: Timmy, Age: 3

	Indented numbers:
	1
	2
	3
	4
	5
	6
	7
	8
	9
	10
	9
	8
	7
	6
	5
	4
	3
	2
	1
	----
	namespace Pm.Schema.DataModels.Users

	open System
	open System.ComponentModel
	open System.Linq.Expressions

	open FSharp.NullHelpers
	/// 13 properties
	type IUser =
	/// bit (1) not null
	abstract member IsLockedOut:bool with get
	/// int (4) not null
	abstract member LoginAttempts:int with get
	/// varchar (50) null
	abstract member RcopiaID:string with get
	/// bit (1) not null
	abstract member ResetPassword:bool with get
	/// int (4) not null
	abstract member UserFacilityID:int with get
	/// varchar (50) not null
	abstract member UserFirstName:string with get
	/// int (4) not null
	abstract member UserID:int with get
	/// varchar (50) not null
	abstract member UserLastName:string with get
	/// int (4) not null
	abstract member UserLevel:int with get
	/// varchar (1) null
	abstract member UserMiddleInitial:string with get
	/// varchar (50) null
	abstract member UserName:string with get
	/// varchar (50) not null
	abstract member UserPassword:string with get
	/// bit (1) not null
	abstract member UserPreviouslyLoggedIn:bool with get

	/// 13 properties
	type IUserRW =
	inherit IUser
	/// bit (1) not null
	abstract member IsLockedOut:bool with get,set
	/// int (4) not null
	abstract member LoginAttempts:int with get,set
	/// varchar (50) null
	abstract member RcopiaID:string with get,set
	/// bit (1) not null
	abstract member ResetPassword:bool with get,set
	/// int (4) not null
	abstract member UserFacilityID:int with get,set
	/// varchar (50) not null
	abstract member UserFirstName:string with get,set
	/// int (4) not null
	abstract member UserID:int with get,set
	/// varchar (50) not null
	abstract member UserLastName:string with get,set
	/// int (4) not null
	abstract member UserLevel:int with get,set
	/// varchar (1) null
	abstract member UserMiddleInitial:string with get,set
	/// varchar (50) null
	abstract member UserName:string with get,set
	/// varchar (50) not null
	abstract member UserPassword:string with get,set
	/// bit (1) not null
	abstract member UserPreviouslyLoggedIn:bool with get,set

	/// 13 properties
	[<NoComparison>]
	type UserRecord =
	{
	/// bit (1) not null
	IsLockedOut:bool
	/// int (4) not null
	LoginAttempts:int
	/// varchar (50) null
	RcopiaID:string
	/// bit (1) not null
	ResetPassword:bool
	/// int (4) not null
	UserFacilityID:int
	/// varchar (50) not null
	UserFirstName:string
	/// int (4) not null
	UserID:int
	/// varchar (50) not null
	UserLastName:string
	/// int (4) not null
	UserLevel:int
	/// varchar (1) null
	UserMiddleInitial:string
	/// varchar (50) null
	UserName:string
	/// varchar (50) not null
	UserPassword:string
	/// bit (1) not null
	UserPreviouslyLoggedIn:bool
	}
	interface IUser with
	member x.IsLockedOut with get () = x.IsLockedOut
	member x.LoginAttempts with get () = x.LoginAttempts
	member x.RcopiaID with get () = x.RcopiaID
	member x.ResetPassword with get () = x.ResetPassword
	member x.UserFacilityID with get () = x.UserFacilityID
	member x.UserFirstName with get () = x.UserFirstName
	member x.UserID with get () = x.UserID
	member x.UserLastName with get () = x.UserLastName
	member x.UserLevel with get () = x.UserLevel
	member x.UserMiddleInitial with get () = x.UserMiddleInitial
	member x.UserName with get () = x.UserName
	member x.UserPassword with get () = x.UserPassword
	member x.UserPreviouslyLoggedIn with get () = x.UserPreviouslyLoggedIn
	static member Zero () =
	{
	IsLockedOut = false
	LoginAttempts = 0
	RcopiaID = null
	ResetPassword = false
	UserFacilityID = 0
	UserFirstName = null
	UserID = 0
	UserLastName = null
	UserLevel = 0
	UserMiddleInitial = null
	UserName = null
	UserPassword = null
	UserPreviouslyLoggedIn = false
	}

	module UserHelpers =
	open Microsoft.FSharp.Core.Operators.Unchecked

	let tableName = "User"
	let ToRecord (iUser:IUser) =
	{
	IsLockedOut = iUser.IsLockedOut
	LoginAttempts = iUser.LoginAttempts
	RcopiaID = iUser.RcopiaID
	ResetPassword = iUser.ResetPassword
	UserFacilityID = iUser.UserFacilityID
	UserFirstName = iUser.UserFirstName
	UserID = iUser.UserID
	UserLastName = iUser.UserLastName
	UserLevel = iUser.UserLevel
	UserMiddleInitial = iUser.UserMiddleInitial
	UserName = iUser.UserName
	UserPassword = iUser.UserPassword
	UserPreviouslyLoggedIn = iUser.UserPreviouslyLoggedIn
	}

	let toRecord (user:IUser) =
	{
	IsLockedOut = user.IsLockedOut
	LoginAttempts = user.LoginAttempts
	RcopiaID = user.RcopiaID
	ResetPassword = user.ResetPassword
	UserFacilityID = user.UserFacilityID
	UserFirstName = user.UserFirstName
	UserID = user.UserID
	UserLastName = user.UserLastName
	UserLevel = user.UserLevel
	UserMiddleInitial = user.UserMiddleInitial
	UserName = user.UserName
	UserPassword = user.UserPassword
	UserPreviouslyLoggedIn = user.UserPreviouslyLoggedIn
	}

	let FromF (camelTypeF:Func<string,obj option>) =
	{
	IsLockedOut =
	match camelTypeF.Invoke "IsLockedOut" with
	\|Some x -> Convert.ToBoolean x
	\|None -> Unchecked.defaultof<_>
	LoginAttempts =
	match camelTypeF.Invoke "LoginAttempts" with
	\|Some x -> Convert.ToInt32 x
	\|None -> Unchecked.defaultof<_>
	RcopiaID =
	match camelTypeF.Invoke "RcopiaID" with
	\|Some x -> Convert.ToString x
	\|None -> Unchecked.defaultof<_>
	ResetPassword =
	match camelTypeF.Invoke "ResetPassword" with
	\|Some x -> Convert.ToBoolean x
	\|None -> Unchecked.defaultof<_>
	UserFacilityID =
	match camelTypeF.Invoke "UserFacilityID" with
	\|Some x -> Convert.ToInt32 x
	\|None -> Unchecked.defaultof<_>
	UserFirstName =
	match camelTypeF.Invoke "UserFirstName" with
	\|Some x -> Convert.ToString x
	\|None -> Unchecked.defaultof<_>
	UserID =
	match camelTypeF.Invoke "UserID" with
	\|Some x -> Convert.ToInt32 x
	\|None -> Unchecked.defaultof<_>
	UserLastName =
	match camelTypeF.Invoke "UserLastName" with
	\|Some x -> Convert.ToString x
	\|None -> Unchecked.defaultof<_>
	UserLevel =
	match camelTypeF.Invoke "UserLevel" with
	\|Some x -> Convert.ToInt32 x
	\|None -> Unchecked.defaultof<_>
	UserMiddleInitial =
	match camelTypeF.Invoke "UserMiddleInitial" with
	\|Some x -> Convert.ToString x
	\|None -> Unchecked.defaultof<_>
	UserName =
	match camelTypeF.Invoke "UserName" with
	\|Some x -> Convert.ToString x
	\|None -> Unchecked.defaultof<_>
	UserPassword =
	match camelTypeF.Invoke "UserPassword" with
	\|Some x -> Convert.ToString x
	\|None -> Unchecked.defaultof<_>
	UserPreviouslyLoggedIn =
	match camelTypeF.Invoke "UserPreviouslyLoggedIn" with
	\|Some x -> Convert.ToBoolean x
	\|None -> Unchecked.defaultof<_>
	}

	let inline toRecordStp (user: ^a) =
	{
	IsLockedOut = (^a: (member IsLockedOut: _) user)
	LoginAttempts = (^a: (member LoginAttempts: _) user)
	RcopiaID = (^a: (member RcopiaID: _) user)
	ResetPassword = (^a: (member ResetPassword: _) user)
	UserFacilityID = (^a: (member UserFacilityID: _) user)
	UserFirstName = (^a: (member UserFirstName: _) user)
	UserID = (^a: (member UserID: _) user)
	UserLastName = (^a: (member UserLastName: _) user)
	UserLevel = (^a: (member UserLevel: _) user)
	UserMiddleInitial = (^a: (member UserMiddleInitial: _) user)
	UserName = (^a: (member UserName: _) user)
	UserPassword = (^a: (member UserPassword: _) user)
	UserPreviouslyLoggedIn = (^a: (member UserPreviouslyLoggedIn: _) user)
	}

	let createInsert (r:IUser) =
	let quoted s = "'" + s + "'"
	[
	"IsLockedOut", r.IsLockedOut \|> string \|> quoted
	"LoginAttempts", r.LoginAttempts \|> string
	"RcopiaID", if String.IsNullOrEmpty r.RcopiaID then "null" else quoted r.RcopiaID
	"ResetPassword", r.ResetPassword \|> string \|> quoted
	"UserFacilityID", r.UserFacilityID \|> string
	"UserFirstName", if String.IsNullOrEmpty r.UserFirstName then "null" else quoted r.UserFirstName
	"UserLastName", if String.IsNullOrEmpty r.UserLastName then "null" else quoted r.UserLastName
	"UserLevel", r.UserLevel \|> string
	"UserMiddleInitial", if String.IsNullOrEmpty r.UserMiddleInitial then "null" else quoted r.UserMiddleInitial
	"UserName", if String.IsNullOrEmpty r.UserName then "null" else quoted r.UserName
	"UserPassword", if String.IsNullOrEmpty r.UserPassword then "null" else quoted r.UserPassword
	"UserPreviouslyLoggedIn", r.UserPreviouslyLoggedIn \|> string \|> quoted
	]
	\|> fun pairs -> sprintf "insert into dbo.Users(%s) values (%s)" (String.Join(",", pairs \|> Seq.map fst )) (String.Join(",", pairs \|> Seq.map snd))

	/// 13 properties
	type UserN (model:UserRecord) =

	let propertyChanged = new Event<_, _>()


	let mutable isLockedOut = model.IsLockedOut
	let mutable loginAttempts = model.LoginAttempts
	let mutable rcopiaID = model.RcopiaID
	let mutable resetPassword = model.ResetPassword
	let mutable userFacilityID = model.UserFacilityID
	let mutable userFirstName = model.UserFirstName
	let mutable userID = model.UserID
	let mutable userLastName = model.UserLastName
	let mutable userLevel = model.UserLevel
	let mutable userMiddleInitial = model.UserMiddleInitial
	let mutable userName = model.UserName
	let mutable userPassword = model.UserPassword
	let mutable userPreviouslyLoggedIn = model.UserPreviouslyLoggedIn

	interface IUser with
	/// bit (1) not null
	member x.IsLockedOut with get () = x.IsLockedOut
	/// int (4) not null
	member x.LoginAttempts with get () = x.LoginAttempts
	/// varchar (50) null
	member x.RcopiaID with get () = x.RcopiaID
	/// bit (1) not null
	member x.ResetPassword with get () = x.ResetPassword
	/// int (4) not null
	member x.UserFacilityID with get () = x.UserFacilityID
	/// varchar (50) not null
	member x.UserFirstName with get () = x.UserFirstName
	/// int (4) not null
	member x.UserID with get () = x.UserID
	/// varchar (50) not null
	member x.UserLastName with get () = x.UserLastName
	/// int (4) not null
	member x.UserLevel with get () = x.UserLevel
	/// varchar (1) null
	member x.UserMiddleInitial with get () = x.UserMiddleInitial
	/// varchar (50) null
	member x.UserName with get () = x.UserName
	/// varchar (50) not null
	member x.UserPassword with get () = x.UserPassword
	/// bit (1) not null
	member x.UserPreviouslyLoggedIn with get () = x.UserPreviouslyLoggedIn
	interface IUserRW with
	/// bit (1) not null
	member x.IsLockedOut with get () = x.IsLockedOut and set v = x.IsLockedOut <- v
	/// int (4) not null
	member x.LoginAttempts with get () = x.LoginAttempts and set v = x.LoginAttempts <- v
	/// varchar (50) null
	member x.RcopiaID with get () = x.RcopiaID and set v = x.RcopiaID <- v
	/// bit (1) not null
	member x.ResetPassword with get () = x.ResetPassword and set v = x.ResetPassword <- v
	/// int (4) not null
	member x.UserFacilityID with get () = x.UserFacilityID and set v = x.UserFacilityID <- v
	/// varchar (50) not null
	member x.UserFirstName with get () = x.UserFirstName and set v = x.UserFirstName <- v
	/// int (4) not null
	member x.UserID with get () = x.UserID and set v = x.UserID <- v
	/// varchar (50) not null
	member x.UserLastName with get () = x.UserLastName and set v = x.UserLastName <- v
	/// int (4) not null
	member x.UserLevel with get () = x.UserLevel and set v = x.UserLevel <- v
	/// varchar (1) null
	member x.UserMiddleInitial with get () = x.UserMiddleInitial and set v = x.UserMiddleInitial <- v
	/// varchar (50) null
	member x.UserName with get () = x.UserName and set v = x.UserName <- v
	/// varchar (50) not null
	member x.UserPassword with get () = x.UserPassword and set v = x.UserPassword <- v
	/// bit (1) not null
	member x.UserPreviouslyLoggedIn with get () = x.UserPreviouslyLoggedIn and set v = x.UserPreviouslyLoggedIn <- v

	member x.MakeRecord () =
	{
	IsLockedOut = x.IsLockedOut
	LoginAttempts = x.LoginAttempts
	RcopiaID = x.RcopiaID
	ResetPassword = x.ResetPassword
	UserFacilityID = x.UserFacilityID
	UserFirstName = x.UserFirstName
	UserID = x.UserID
	UserLastName = x.UserLastName
	UserLevel = x.UserLevel
	UserMiddleInitial = x.UserMiddleInitial
	UserName = x.UserName
	UserPassword = x.UserPassword
	UserPreviouslyLoggedIn = x.UserPreviouslyLoggedIn
	}

	interface INotifyPropertyChanged with
	[<CLIEvent>]
	member x.PropertyChanged = propertyChanged.Publish
	abstract member RaisePropertyChanged : string -> unit
	default x.RaisePropertyChanged(propertyName : string) = propertyChanged.Trigger(x, PropertyChangedEventArgs(propertyName))

	abstract member SetAndNotify<'t> : string * 't byref * 't -> bool
	default x.SetAndNotify<'t> (propertyName, field: 't byref, value:'t) =
	if obj.ReferenceEquals(box field,box value) then false
	else
	field <- value
	x.RaisePropertyChanged(propertyNam)
	true

	abstract member SetAndNotify<'t,'b> : string * 'b * 't Action * 't -> bool
	default x.SetAndNotify<'t,'b> (propertyName, baseValue:'b, baseSetter: 't Action, value:'t) =
	if obj.ReferenceEquals(box baseValue,box value) then false
	else
	baseSetter.Invoke value
	x.RaisePropertyChanged(propertyName)
	true

	/// bit (1) not null
	member x.IsLockedOut
	with get() = isLockedOut
	and set v =
	isLockedOut <- v
	x.RaisePropertyChanged "IsLockedOut"

	/// int (4) not null
	member x.LoginAttempts
	with get() = loginAttempts
	and set v =
	loginAttempts <- v
	x.RaisePropertyChanged "LoginAttempts"

	/// varchar (50) null
	member x.RcopiaID
	with get() = rcopiaID
	and set v =
	rcopiaID <- v
	x.RaisePropertyChanged "RcopiaID"

	/// bit (1) not null
	member x.ResetPassword
	with get() = resetPassword
	and set v =
	resetPassword <- v
	x.RaisePropertyChanged "ResetPassword"

	/// int (4) not null
	member x.UserFacilityID
	with get() = userFacilityID
	and set v =
	userFacilityID <- v
	x.RaisePropertyChanged "UserFacilityID"

	/// varchar (50) not null
	member x.UserFirstName
	with get() = userFirstName
	and set v =
	userFirstName <- v
	x.RaisePropertyChanged "UserFirstName"

	/// int (4) not null
	member x.UserID
	with get() = userID
	and set v =
	userID <- v
	x.RaisePropertyChanged "UserID"

	/// varchar (50) not null
	member x.UserLastName
	with get() = userLastName
	and set v =
	userLastName <- v
	x.RaisePropertyChanged "UserLastName"

	/// int (4) not null
	member x.UserLevel
	with get() = userLevel
	and set v =
	userLevel <- v
	x.RaisePropertyChanged "UserLevel"

	/// varchar (1) null
	member x.UserMiddleInitial
	with get() = userMiddleInitial
	and set v =
	userMiddleInitial <- v
	x.RaisePropertyChanged "UserMiddleInitial"

	/// varchar (50) null
	member x.UserName
	with get() = userName
	and set v =
	userName <- v
	x.RaisePropertyChanged "UserName"

	/// varchar (50) not null
	member x.UserPassword
	with get() = userPassword
	and set v =
	userPassword <- v
	x.RaisePropertyChanged "UserPassword"

	/// bit (1) not null
	member x.UserPreviouslyLoggedIn
	with get() = userPreviouslyLoggedIn
	and set v =
	userPreviouslyLoggedIn <- v
	x.RaisePropertyChanged "UserPreviouslyLoggedIn"