simon/adl
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

*** empty log message ***

Browse source
This commit is contained in:
af 2008-01-21 16:38:31 +00:00
parent 9b6fd82110
commit 7429d242cf
20 changed files with 861 additions and 1014 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

84
ADL.NET/ADL.csproj
View file

@ -1,84 +0,0 @@
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.50727</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{7D9E1F28-3F9C-4675-A02C-C9B2E98A839E}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>ADL</RootNamespace>
<AssemblyName>ADL</AssemblyName>
<StartupObject>
</StartupObject>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Exceptions\DataSuitabilityException.cs" />
<Compile Include="Exceptions\DataFormatException.cs" />
<Compile Include="Exceptions\DataRangeException.cs" />
<Compile Include="Exceptions\DataRequiredException.cs" />
<Compile Include="Exceptions\DomainKnowledgeViolationException.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Properties\Resources.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
</ItemGroup>
<ItemGroup>
<None Include="j2adl.dtd" />
</ItemGroup>
<ItemGroup>
<Content Include="Trans\adl2controllerclasses.xsl" />
<Content Include="Trans\adl2entityclass.xsl" />
<Content Include="Trans\adl2hibernate.xsl" />
<Content Include="Trans\adl2views.xsl" />
<Content Include="Trans\adl2mssql.xsl" />
<Content Include="Trans\adl2psql.xsl" />
<Content Include="Trans\datadescriber.xsl" />
<Content Include="Trans\hibernate2adl.xsl" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\CygnetToolkit\CygnetToolkit.csproj">
<Project>{77FB7DE5-1F33-4DDC-8A2E-79EF4728705E}</Project>
<Name>CygnetToolkit</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="Properties\Resources.resx">
<SubType>Designer</SubType>
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

23
ADL.NET/Exceptions/DataFormatException.cs
View file

@ -1,23 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
/*
* Application Description Framework
* DataRangeException.cs
*
* (c) 2007 Cygnet Solutions Ltd
*
* $Author: af $
* $Revision: 1.1 $
*/
namespace ADL.Exceptions {
/// <summary>
/// An exception to be thrown if an attempt is made to set a property to a
/// value which is unsuitably formatted for the data type
/// </summary>
public class DataFormatException : DataSuitabilityException {
public DataFormatException(String message) : base(message) {}
}
}

23
ADL.NET/Exceptions/DataRangeException.cs
View file

@ -1,23 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
/*
* Application Description Framework
* DataRangeException.cs
*
* (c) 2007 Cygnet Solutions Ltd
*
* $Author: af $
* $Revision: 1.1 $
*/
namespace ADL.Exceptions {
/// <summary>
/// An exception to be thrown if an attempt is made to set a scalar property with a
/// defined range to a value which is outside that range
/// </summary>
public class DataRangeException : DataSuitabilityException {
public DataRangeException(String message) : base(message) {}
}
}

21
ADL.NET/Exceptions/DataRequiredException.cs
View file

@ -1,21 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
/*
* Application Description Framework
* DataRequiredException.cs
*
* (c) 2007 Cygnet Solutions Ltd
*
* $Author: af $
* $Revision: 1.1 $
*/
namespace ADL.Exceptions {
/// <summary>
/// An exception to be thrown if an attempt is made to set a required property to null
/// </summary>
public class DataRequiredException : DataSuitabilityException {
public DataRequiredException(String message) : base(message){}
}
}

23
ADL.NET/Exceptions/DataSuitabilityException.cs
View file

@ -1,23 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
/*
* Application Description Framework
* DataRangeException.cs
*
* (c) 2007 Cygnet Solutions Ltd
*
* $Author: af $
* $Revision: 1.1 $
*/
namespace ADL.Exceptions {
/// <summary>
/// An exception to be thrown if an attempt is made to set a property
/// to a value which is unsuitable
/// </summary>
public abstract class DataSuitabilityException : Exception {
public DataSuitabilityException(String message) : base(message) {}
}
}

24
ADL.NET/Exceptions/DomainKnowledgeViolationException.cs
View file

@ -1,24 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
/*
* Application Description Framework
* DomainKnowledgeViolationException.cs
*
* (c) 2007 Cygnet Solutions Ltd
*
* $Author: af $
* $Revision: 1.1 $
*/
namespace ADL.Exceptions {
/// <summary>
/// An exception to be thrown if a state arises which violates
/// some specific knowledge about the application domain (i.e.
/// a 'business rule' violation)
/// </summary>
public class DomainKnowledgeViolationException : Exception {
public DomainKnowledgeViolationException(String message) : base(message) { }
}
}

33
ADL.NET/Properties/AssemblyInfo.cs
View file

@ -1,33 +0,0 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ADL")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ADL")]
[assembly: AssemblyCopyright("Copyright © 2007 Cygnet Solutions Ltd")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("6be1b0e7-f012-44ee-a35f-892f53b627ad")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

247
ADL.NET/Trans/adl2hibernate.xsl
View file

@ -1,247 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns="urn:nhibernate-mapping-2.2">
<!--
Application Description Framework
adl2hibernate.xsl
(c) 2007 Cygnet Solutions Ltd
Transform ADL to Hibernate
$Author: af $
$Revision: 1.1 $
-->
<xsl:output indent="no" method="xml" encoding="utf-8"/>
<!-- NOTE! indent="no" because hibernate falls over if there is whitespace inside
a 'key' or 'one-to-many' element, and the printer used by the NAnt 'style' task
does not tag-minimize on output. If you change this the build will break, you
have been warned! -->
<xsl:variable name="namespace">SRU.Hospitality.Entities</xsl:variable>
<xsl:variable name="assembly">SRU.Hospitality.DataModel</xsl:variable>
<xsl:template match="application">
<hibernate-mapping>
<xsl:attribute name="namespace">
<xsl:value-of select="$namespace"/>
</xsl:attribute>
<xsl:attribute name="assembly">
<xsl:value-of select="$assembly"/>
</xsl:attribute>
<xsl:comment>
***************************************************************************
*
* C1873: C1873-SUS-Hospitality.auto.hbm.xml
*
* ©2007 Cygnet Solutions Ltd
*
* THIS FILE IS AUTOMATICALLY GENERATED AND SHOULD NOT
* BE MANUALLY EDITED.
*
* Generated using adl2hibernate-mapping.xsl revision <xsl:value-of select="substring('$Revision: 1.1 $', 12)"/>
*
***************************************************************************
</xsl:comment>
<xsl:apply-templates select="entity"/>
</hibernate-mapping>
</xsl:template>
<xsl:template match="entity">
<class>
<xsl:attribute name="name">
<xsl:value-of select="@name"/>
</xsl:attribute>
<xsl:attribute name="table">
<xsl:value-of select="@name"/>
</xsl:attribute>
<id type="Int32">
<!-- ADL does not encode the primary key explicitly; instead it is
implicit and its name is always the name of the entity followed by
'Id' -->
<xsl:attribute name="name">
<xsl:value-of select="normalize-space( concat( @name, 'Id'))"/>
</xsl:attribute>
<generator class="native"/>
</id>
<xsl:apply-templates select="property"/>
</class>
</xsl:template>
<xsl:template match="property[@concrete='false']">
<!-- properties which are not concrete are by definition not
stored in the database -->
</xsl:template>
<xsl:template match="property[@type='entity']">
<!-- a property of type entity translates to a Hibernate many-to-one -->
<many-to-one>
<xsl:attribute name="name">
<xsl:value-of select="@name"/>
</xsl:attribute>
<xsl:attribute name="class">
<xsl:value-of select="@entity"/>
</xsl:attribute>
</many-to-one>
</xsl:template>
<xsl:template match="property[@type='list']">
<xsl:variable name="farent" select="@entity"/>
<xsl:variable name="nearent" select="ancestor::entity/@name"/>
<xsl:variable name="farkey">
<xsl:choose>
<xsl:when test="@farkey">
<xsl:value-of select="@farkey"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="ancestor::entity/@name"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable>
<set>
<xsl:attribute name="name">
<xsl:value-of select="@name"/>
</xsl:attribute>
<xsl:attribute name="inverse">
<!-- true if the other end of the link is described in the ADL (which it normally will be) -->
<xsl:choose>
<xsl:when test="//entity[@name=$farent]/property[@name=$farkey and @entity=$nearent]">true</xsl:when>
<xsl:otherwise>false</xsl:otherwise>
</xsl:choose>
</xsl:attribute>
<!-- careful with reformatting here:
'The element cannot contain white space. Content model is empty.' -->
<key><xsl:attribute name="column">
<!-- this is the name of the farside foreign key field which points to me -->
<xsl:value-of select="$farkey"/>
</xsl:attribute></key>
<one-to-many><xsl:attribute name="class">
<xsl:value-of select="@entity"/>
</xsl:attribute></one-to-many>
</set>
</xsl:template>
<xsl:template match="property[@type='link']">
<!-- a property of type 'link' maps on to a Hibernate set -->
<xsl:variable name="comparison">
<xsl:call-template name="stringcompare">
<xsl:with-param name="node1" select="../@name"/>
<xsl:with-param name="node2" select="@entity"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable name="tablename">
<xsl:choose>
<xsl:when test="$comparison =-1">
<xsl:value-of select="concat( 'ln_', ../@name, '_', @entity)"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="concat( 'ln_', @entity, '_', ../@name)"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable>
<set>
<xsl:attribute name="name">
<xsl:value-of select="@name"/>
</xsl:attribute>
<xsl:attribute name="table">
<xsl:value-of select="$tablename"/>
</xsl:attribute>
<key>
<xsl:attribute name="column">
<xsl:value-of select="concat( ../@name, 'Id')"/>
</xsl:attribute>
</key>
<many-to-many>
<xsl:attribute name="column">
<xsl:choose>
<xsl:when test="../@name = @entity">
<xsl:value-of select="concat( @entity, '_1Id')"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="concat( @entity, 'Id')"/>
</xsl:otherwise>
</xsl:choose>
</xsl:attribute>
<xsl:attribute name="class">
<xsl:value-of select="@entity"/>
</xsl:attribute>
</many-to-many>
</set>
</xsl:template>
<xsl:template match="property">
<!-- tricky, this, because we're translating between ADL properties and
Hibernate properties, which are (slightly) different. There's potential
for confusion -->
<property>
<xsl:attribute name="name">
<xsl:value-of select="@name"/>
</xsl:attribute>
<xsl:attribute name="type">
<xsl:variable name="type">
<xsl:choose>
<xsl:when test="@type = 'defined'">
<xsl:variable name="definition">
<xsl:value-of select="@definition"/>
</xsl:variable>
<xsl:value-of select="/application/definition[@name=$definition]/@type"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="@type"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable>
<xsl:choose>
<xsl:when test="$type = 'date'">DateTime</xsl:when>
<xsl:when test="$type = 'time'">DateTime</xsl:when>
<xsl:when test="$type = 'string'">String</xsl:when>
<xsl:when test="$type = 'text'">String</xsl:when>
<xsl:when test="$type = 'boolean'">Boolean</xsl:when>
<xsl:when test="$type = 'timestamp'">TimeStamp</xsl:when>
<xsl:when test="$type = 'integer'">Int32</xsl:when>
<xsl:when test="$type = 'real'">Double</xsl:when>
<xsl:when test="$type = 'money'">Decimal</xsl:when>
<xsl:otherwise>[unknown?]</xsl:otherwise>
</xsl:choose>
</xsl:attribute>
</property>
</xsl:template>
<!--
horrible, horrible hackery. Compare two strings and return
* 0 if they are identical,
* -1 if the first is earlier in the default collating sequence,
* 1 if the first is later.
In XSL 2.0 this could be done using the compare(string, string) function.
TODO: probably should be an include file
-->
<xsl:template name="stringcompare">
<xsl:param name="node1"/>
<xsl:param name="node2"/>
<xsl:choose>
<xsl:when test="string($node1)=string($node2)">
<xsl:text>0</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:for-each select="$node1 | $node2">
<xsl:sort select="."/>
<xsl:if test="position()=1">
<xsl:choose>
<xsl:when test="string(.) = string($node1)">
<xsl:text>-1</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text>1</xsl:text>
</xsl:otherwise>
</xsl:choose>
</xsl:if>
</xsl:for-each>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>

10
ADL.NET/Trans/types.xml
View file

@ -1,10 +0,0 @@
<types>
<type name="integer" dotnet="Int32" sql="INTEGER" dotnet-kind="value" default="0" />
<type name="real" dotnet="Double" sql="REAL" dotnet-kind="value" default="0.0"/>
<type name="boolean" dotnet="Boolean" sql="BIT" dotnet-kind="value" default="false"/>
<type name="date" dotnet="DateTime" sql="DATETIME" dotnet-kind="value" />
<type name="time" dotnet="TimeSpan" sql="DECIMAL" dotnet-kind="value" />
<type name="money" dotnet="Decimal" sql="MONEY" dotnet-kind="value" />
<type name="string" dotnet="String" sql="NVARCHAR" dotnet-kind="reference" />
</types>

132
transforms/adl2adl.xslt Executable file
View file

@ -0,0 +1,132 @@
<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns="http://cygnets.co.uk/schemas/adl-1.2"
xmlns:a="http://cygnets.co.uk/schemas/adl-1.2"
exclude-result-prefixes="a">
<!--
Application Description Framework
adl2adl.xsl
(c) 2008 Cygnet Solutions Ltd
Transform ADL to Verbose (or canonical) ADL
Most defaults are replaced with their actual values.
$Author: af $
$Revision: 1.1 $
-->
<xsl:import href="types.xslt"/>
<xsl:output indent="yes" method="xml" encoding="utf-8"/>
<xsl:template match="a:application">
<xsl:copy>
<xsl:apply-templates select="@*" />
<xsl:comment>
***************************************************************************
*
* ©2007 Cygnet Solutions Ltd
*
* THIS FILE IS AUTOMATICALLY GENERATED AND SHOULD NOT
* BE MANUALLY EDITED.
*
* Generated using adl2adl.xsl revision <xsl:value-of select="substring('$Revision: 1.1 $', 12)"/>
*
***************************************************************************
</xsl:comment>
<xsl:apply-templates select="a:type | a:typedef | a:entity | comment()"/>
</xsl:copy>
</xsl:template>
<xsl:template match="a:entity">
<xsl:copy>
<xsl:apply-templates select="@*"/>
<xsl:if test="not(a:key)">
<xsl:if test=".//a:property[@name='Id']">
<xsl:message terminate="yes">Class "<xsl:value-of select="@name"/>" has an 'Id' field, but no key. This is not allowed.</xsl:message>
</xsl:if>
<key>
<property name="Id" type="Integer-32" access="field.pascalcase-underscore">
<generator class="identity"/>
</property>
</key>
</xsl:if>
<xsl:apply-templates select="*"/>
</xsl:copy>
</xsl:template>
<!-- Expand any 'default' forms -->
<xsl:template match="a:form[not(@properties)]">
<form properties="listed">
<xsl:apply-templates select="@*" />
<xsl:for-each select="../a:key/a:property|../a:property">
<field>
<xsl:attribute name="property">
<xsl:value-of select="@name"/>
</xsl:attribute>
</field>
</xsl:for-each>
</form>
</xsl:template>
<!-- Expand any 'default' lists -->
<xsl:template match="a:list[not(@properties)]">
<list properties="listed">
<xsl:apply-templates select="@*" />
<pragma name="with-pagination-control" value="true"/>
<pragma name="with-can-add" value="true"/>
<xsl:for-each select="../a:key/a:property|../a:property">
<field>
<xsl:attribute name="property">
<xsl:value-of select="@name"/>
</xsl:attribute>
</field>
</xsl:for-each>
</list>
</xsl:template>
<xsl:template match="a:property">
<property>
<xsl:choose>
<xsl:when test="@type='entity' or @type='list' or @type='link'">
<xsl:attribute name="type"><xsl:value-of select="@type" /></xsl:attribute>
</xsl:when>
<xsl:otherwise>
<xsl:variable name="typename">
<xsl:call-template name="type-name" />
</xsl:variable>
<xsl:if test="$typename">
<xsl:attribute name="type">
<xsl:value-of select="$typename"/>
</xsl:attribute>
</xsl:if>
<!--xsl:call-template name="add-type-attr-if-avail">
<xsl:with-param name="attr" select="'name'" />
</xsl:call-template-->
</xsl:otherwise>
</xsl:choose>
<xsl:apply-templates select="@*[name()!='type']|*" />
</property>
</xsl:template>
<xsl:template name="add-type-attr-if-avail">
<xsl:param name="attr"/>
<xsl:variable name="val">
<xsl:call-template name="type-attr">
<xsl:with-param name="attr" select="$attr" />
</xsl:call-template>
</xsl:variable>
<xsl:if test="$val">
<xsl:attribute name="{$attr}">
<xsl:value-of select="$val"/>
</xsl:attribute>
</xsl:if>
</xsl:template>
<xsl:template match="@*|node()">
<xsl:copy>
<xsl:apply-templates select="@*|node()"/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>

337
ADL.NET/Trans/adl2controllerclasses.xsl → transforms/adl2controllerclasses.xslt
View file

@ -9,13 +9,17 @@
Transform ADL into (partial) controller classes Transform ADL into (partial) controller classes
$Author: af $ $Author: af $
$Revision: 1.2 $ $Revision: 1.1 $
$Date: 2008-01-14 16:53:31 $ $Date: 2008-01-21 16:38:31 $
--> -->
<!-- WARNING WARNING WARNING: Do NOT reformat this file! <!-- WARNING WARNING WARNING: Do NOT reformat this file!
Whitespace (or lack of it) is significant! --> Whitespace (or lack of it) is significant! -->
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:a="http://cygnets.co.uk/schemas/adl-1.2"
exclude-result-prefixes="a">
<xsl:output encoding="UTF-8" method="text"/> <xsl:output encoding="UTF-8" method="text"/>
<!-- The locale for which these controllers are generated <!-- The locale for which these controllers are generated
@ -24,28 +28,29 @@
client's locale. However, there may still need to be a concept of a client's locale. However, there may still need to be a concept of a
'default locale', for when we don't have messages which suit the 'default locale', for when we don't have messages which suit the
client's locale --> client's locale -->
<xsl:param name="locale" select="en-UK"/> <xsl:param name="lang" select="en-UK"/>
<!-- The C# namespace within which I shall generate controllers --> <!-- The C# namespace within which I shall generate controllers -->
<xsl:param name="controllerns" select="Unset"/> <xsl:param name="controllerns" select="Unset"/>
<!-- The C# namespace used by the entities for this project --> <!-- The C# namespace used by the entities for this project -->
<xsl:param name="entityns" select="Unset"/> <xsl:param name="entityns" select="Unset"/>
<xsl:template match="application">
<xsl:apply-templates select="entity"/> <xsl:template match="a:application">
<xsl:apply-templates select="a:entity"/>
</xsl:template> </xsl:template>
<xsl:template match="entity[count(property/@distinct)!=1]"> <xsl:template match="a:entity[count(a:key/a:property) != 1]">
<!-- Ignore entities withot a simple (non-composite) key. --> <!-- Ignore entities without a simple (non-composite) key. -->
</xsl:template> </xsl:template>
<xsl:template match="entity"> <xsl:template match="a:entity">
<!-- what's all this about? the objective is to get the revision number of the <!-- what's all this about? the objective is to get the revision number of the
transform into the output, /without/ getting that revision number overwritten transform into the output, /without/ getting that revision number overwritten
with the revision number of the generated file if the generated file is with the revision number of the generated file if the generated file is
stored to CVS --> stored to CVS -->
<xsl:variable name="transform-rev1" <xsl:variable name="transform-rev1"
select="substring( '$Revision: 1.2 $', 11)"/> select="substring( '$Revision: 1.1 $', 11)"/>
<xsl:variable name="transform-revision" <xsl:variable name="transform-revision"
select="substring( $transform-rev1, 0, string-length( $transform-rev1) - 1)"/> select="substring( $transform-rev1, 0, string-length( $transform-rev1) - 1)"/>
@ -81,8 +86,8 @@ using System.Web.Security;
using NHibernate; using NHibernate;
using NHibernate.Expression; using NHibernate.Expression;
using Castle.MonoRail.Framework; using Castle.MonoRail.Framework;
using ADL.Entities; using Cygnet.Entities;
using ADL.Exceptions; using Cygnet.Entities.Exceptions;
using Iesi.Collections.Generic; using Iesi.Collections.Generic;
using <xsl:value-of select="$entityns" />; using <xsl:value-of select="$entityns" />;
@ -114,176 +119,165 @@ namespace <xsl:value-of select="$controllerns"/> {
<xsl:value-of select="@name"/> record; <xsl:value-of select="@name"/> record;
<xsl:apply-templates select="property"/> <xsl:apply-templates select="a:property"/>
string id = Form["<xsl:value-of select="concat( 'instance.', $key)"/>"]; string id = Form["<xsl:value-of select="concat( 'instance.', $key)"/>"];
if ( String.IsNullOrEmpty( id)) if ( String.IsNullOrEmpty( id)) {
{
/* it's new, create persistent object */ /* it's new, create persistent object */
record = new <xsl:value-of select="@name"/>(); record = new <xsl:value-of select="@name"/>();
/* perform any domain knowledge behaviour on the new record /* perform any domain knowledge behaviour on the new record
* after instantiation */ * after instantiation */
record.AfterCreationHook( hibernator); record.AfterCreationHook( hibernator);
messages.Add( "New <xsl:value-of select="@name"/> record created"); messages.Add( "Created new <xsl:value-of select="@name"/>");
}
else } else {
{
/* it's existing, retrieve it */ /* it's existing, retrieve it */
record = record =
hibernator.CreateCriteria(typeof(<xsl:value-of select="@name"/>)) hibernator.CreateCriteria(typeof(<xsl:value-of select="@name"/>))
.Add(Expression.Eq("<xsl:value-of select="$key"/>", Int32.Parse(id))) .Add(Expression.Eq("<xsl:value-of select="$key"/>", Int32.Parse(id)))
.UniqueResult&lt;<xsl:value-of select="@name"/>&gt;(); .UniqueResult&lt;<xsl:value-of select="@name"/>&gt;();
if ( record != null)
throw new Exception( String.Format( "No record of type <xsl:value-of select="@name"/> with key value {0} found", id));
} }
if ( record != null) try {
{ /* actually update the record */
try BindObjectInstance( record, ParamStore.Form, "instance");
<xsl:for-each select="a:property[@type='entity']">
/* for properties of type 'entity', it should not be necessary to do anything
* special - BindObjectInstance /should/ do it all. Unfortunately it sometimes
* doesn't, and I haven't yet characterised why not. TODO: Fix this! */
record.<xsl:value-of select="@name"/> =
hibernator.CreateCriteria(typeof(<xsl:value-of select="@entity"/>))
.Add(Expression.Eq("<xsl:call-template name="primary-key">
<xsl:with-param name="entityname" select="@entity"/>
</xsl:call-template>", Int32.Parse(Form["<xsl:value-of select="concat( 'instance.', @name)"/>"])))
.UniqueResult&lt;<xsl:value-of select="@entity"/>&gt;();
</xsl:for-each>
<xsl:for-each select="a:property[@type='link']">
/* to update a link table which has no other data than the near and far keys, it is
* sufficient to smash the existing values and create new ones. It's also a lot easier! */
string[] <xsl:value-of select="concat(@name, 'Values')"/> = Form.GetValues( "<xsl:value-of select="concat( 'instance.', @name)"/>");
if ( <xsl:value-of select="concat(@name, 'Values')"/> != null)
{ {
/* actually update the record */ /* update the linking table for my <xsl:value-of select="@name"/>; first smash the old values */
BindObjectInstance( record, ParamStore.Form, "instance"); if ( <xsl:value-of select="concat( 'record.', @name)"/> != null) {
<xsl:value-of select="concat( 'record.', @name)"/>.Clear();
} else {
<xsl:value-of select="concat( 'record.', @name)"/> = new HashedSet&lt;<xsl:value-of select="@entity"/>&gt;();
}
<xsl:for-each select="property[@type='entity']"> /* then reinstate the values from the indexes passed */
/* for properties of type 'entity', it should not be necessary to do anything foreach ( string index in <xsl:value-of select="concat(@name, 'Values')"/>)
* special - BindObjectInstance /should/ do it all. Unfortunately it sometimes {
* doesn't, and I haven't yet characterised why not. TODO: Fix this! */ <xsl:variable name="entity-key">
record.<xsl:value-of select="@name"/> = <xsl:call-template name="primary-key">
hibernator.CreateCriteria(typeof(<xsl:value-of select="@entity"/>))
.Add(Expression.Eq("<xsl:call-template name="primary-key">
<xsl:with-param name="entityname" select="@entity"/> <xsl:with-param name="entityname" select="@entity"/>
</xsl:call-template>", Int32.Parse(Form["<xsl:value-of select="concat( 'instance.', @name)"/>"]))) </xsl:call-template>
.UniqueResult&lt;<xsl:value-of select="@entity"/>&gt;(); </xsl:variable>
</xsl:for-each> <xsl:value-of select="concat( 'record.', @name)"/>.Add(
hibernator.CreateCriteria(typeof(<xsl:value-of select="@entity"/>))
<xsl:for-each select="property[@type='link']"> .Add(Expression.Eq(<xsl:value-of select="$entity-key"/>, Int32.Parse(index)))
/* to update a link table which has no other data than the near and far keys, it is .UniqueResult&lt;<xsl:value-of select="@entity"/>&gt;());
* sufficient to smash the existing values and create new ones. It's also a lot easier! */ }
}
</xsl:for-each>
<xsl:for-each select="a:property[@type='list']">
/* with a list we cannot just smash the old values! Instead we need to check
* each one and exclude it if no longer required */
if ( Form.GetValues( "<xsl:value-of select="concat( 'instance.', @name)"/>") != null)
{
string[] <xsl:value-of select="concat(@name, 'Values')"/> = Form.GetValues( "<xsl:value-of select="concat( 'instance.', @name)"/>"); string[] <xsl:value-of select="concat(@name, 'Values')"/> = Form.GetValues( "<xsl:value-of select="concat( 'instance.', @name)"/>");
if ( <xsl:value-of select="concat(@name, 'Values')"/> != null) /* updating <xsl:value-of select="@name"/> child records; first remove any not on the submitted list */
{ foreach ( <xsl:value-of select="@entity"/> item in record.<xsl:value-of select="@name"/>){
/* update the linking table for my <xsl:value-of select="@name"/>; first smash the old values */ String itemId = item.KeyString;
if ( <xsl:value-of select="concat( 'record.', @name)"/> != null) bool found = false;
{
<xsl:value-of select="concat( 'record.', @name)"/>.Clear(); foreach ( string index in <xsl:value-of select="concat(@name, 'Values')"/>){
} <!-- TODO: this could definitely be made more efficient -->
else if ( index.Equals( itemId)){
{ found = true;
<xsl:value-of select="concat( 'record.', @name)"/> = new HashedSet&lt;<xsl:value-of select="@entity"/>&gt;(); }
} }
/* then reinstate the values from the indexes passed */ if ( ! found){
foreach ( string index in <xsl:value-of select="concat(@name, 'Values')"/>) record.<xsl:value-of select="@name"/>.Remove( item);
{
<!-- todo: won't work for entities having natural keys -->
<xsl:value-of select="concat( 'record.', @name)"/>.Add(
hibernator.CreateCriteria(typeof(<xsl:value-of select="@entity"/>))
.Add(Expression.Eq("Id", Int32.Parse(index)))
.UniqueResult&lt;<xsl:value-of select="@entity"/>&gt;());
} }
} }
</xsl:for-each>
<xsl:for-each select="property[@type='list']"> /* then add any on the included list which are not already members */
/* with a list we cannot just smash the old values! Instead we need to check foreach ( string index in <xsl:value-of select="concat(@name, 'Values')"/>){
* each one and exclude it if no longer required */ <xsl:variable name="entity-key">
if ( Form.GetValues( "<xsl:value-of select="concat( 'instance.', @name)"/>") != null) <xsl:call-template name="primary-key">
{ <xsl:with-param name="entityname" select="@entity"/>
string[] <xsl:value-of select="concat(@name, 'Values')"/> = Form.GetValues( "<xsl:value-of select="concat( 'instance.', @name)"/>"); </xsl:call-template>
</xsl:variable>
<xsl:value-of select="@entity"/> item =
hibernator.CreateCriteria(typeof(<xsl:value-of select="@entity"/>))
.Add(Expression.Eq("<xsl:value-of select="$entity-key"/>", Int32.Parse(index)))
.UniqueResult&lt;<xsl:value-of select="@entity"/>&gt;();
/* updating <xsl:value-of select="@name"/> child records; first remove any not on the submitted list */ if ( ! record.<xsl:value-of select="@name"/>.Contains( item)){
foreach ( <xsl:value-of select="@entity"/> item in record.<xsl:value-of select="@name"/>) record.<xsl:value-of select="@name"/>.Add( item);
{
String itemId = item.KeyString;
bool found = false;
foreach ( string index in <xsl:value-of select="concat(@name, 'Values')"/>)
{
<!-- TODO: this could definitely be made more efficient -->
if ( index.Equals( itemId))
{
found = true;
}
}
if ( ! found)
{
record.<xsl:value-of select="@name"/>.Remove( item);
}
}
/* then add any on the included list which are not already members */
foreach ( string index in <xsl:value-of select="concat(@name, 'Values')"/>)
{
<xsl:value-of select="@entity"/> item =
hibernator.CreateCriteria(typeof(<xsl:value-of select="@entity"/>))
.Add(Expression.Eq("Id", Int32.Parse(index)))
.UniqueResult&lt;<xsl:value-of select="@entity"/>&gt;();
if ( ! record.<xsl:value-of select="@name"/>.Contains( item))
{
record.<xsl:value-of select="@name"/>.Add( item);
}
} }
} }
</xsl:for-each>
/* perform any domain knowledge behaviour on the record prior to updating */
record.BeforeUpdateHook( hibernator);
/* write the record to the database, in order to guarantee we have a valid key */
hibernator.Save(record);
hibernator.Flush();
/* perform any domain knowledge behaviour on the record after updating */
record.AfterUpdateHook( hibernator);
messages.Add( "Record saved successfully");
}
catch ( DataSuitabilityException dse)
{
AddError( dse.Message);
}
catch ( ApplicationException axe)
{
AddError( axe.Message);
} }
</xsl:for-each>
PropertyBag["messages"] = messages; /* perform any domain knowledge behaviour on the record prior to updating */
PropertyBag["instance"] = record; record.BeforeUpdateHook( hibernator);
<xsl:call-template name="menus"> /* write the record to the database, in order to guarantee we have a valid key */
<xsl:with-param name="entity" select="."/> hibernator.Save(record);
</xsl:call-template> hibernator.Flush();
RenderViewWithFailover("<xsl:value-of select="form[position()=1]/@name"/>");
} /* perform any domain knowledge behaviour on the record after updating */
else record.AfterUpdateHook( hibernator);
{
throw new Exception( String.Format( "No record of type <xsl:value-of select="@name"/> with key value {0} found", id)); messages.Add( "Record saved successfully");
}catch ( DataSuitabilityException dse){
AddError( dse.Message);
}catch ( ApplicationException axe){
AddError( axe.Message);
} }
PropertyBag["messages"] = messages;
PropertyBag["instance"] = record;
<xsl:call-template name="menus">
<xsl:with-param name="entity" select="."/>
</xsl:call-template>
RenderViewWithFailover("<xsl:value-of select="a:form[position()=1]/@name"/>");
} }
/// &lt;summary&gt; /// &lt;summary&gt;
/// Actually delete the selected record /// Actually delete the selected record
/// &lt;/summary&gt; /// &lt;/summary&gt;
[AccessibleThrough(Verb.Get)] [AccessibleThrough(Verb.Get)]
public void Delete() public void Delete() {
{
ISession hibernator = NHibernateHelper.GetCurrentSession(); ISession hibernator = NHibernateHelper.GetCurrentSession();
string id = Params["<xsl:value-of select="concat( 'instance.', $key)"/>"]; string id = Params["<xsl:value-of select="concat( 'instance.', $key)"/>"];
string reallydelete = Params["reallydelete"]; string reallydelete = Params["reallydelete"];
if ( "true".Equals( reallydelete)) if ( "true".Equals( reallydelete)){
{
<xsl:value-of select="@name"/> record = <xsl:value-of select="@name"/> record =
hibernator.CreateCriteria(typeof(<xsl:value-of select="@name"/>)) hibernator.CreateCriteria(typeof(<xsl:value-of select="@name"/>))
.Add(Expression.Eq("<xsl:value-of select="$key"/>", Int32.Parse(id))) .Add(Expression.Eq("<xsl:value-of select="$key"/>", Int32.Parse(id)))
.UniqueResult&lt;<xsl:value-of select="@name"/>&gt;(); .UniqueResult&lt;<xsl:value-of select="@name"/>&gt;();
if ( record != null) if ( record != null){
{
record.BeforeDeleteHook( hibernator); record.BeforeDeleteHook( hibernator);
hibernator.Delete( hibernator.Delete(
@ -292,14 +286,13 @@ namespace <xsl:value-of select="$controllerns"/> {
.UniqueResult&lt;<xsl:value-of select="@name"/>&gt;()); .UniqueResult&lt;<xsl:value-of select="@name"/>&gt;());
hibernator.Flush(); hibernator.Flush();
}
else }else{
{
throw new ApplicationException( "No such record?"); throw new ApplicationException( "No such record?");
} }
} }
<xsl:choose> <xsl:choose>
<xsl:when test="list"> <xsl:when test="a:list">
InternalShowList(); InternalShowList();
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
@ -308,18 +301,17 @@ namespace <xsl:value-of select="$controllerns"/> {
</xsl:choose> </xsl:choose>
} }
<xsl:apply-templates select="form"/> <xsl:apply-templates select="a:form"/>
<xsl:if test="list"> <xsl:if test="a:list">
<xsl:variable name="listname" select="list[position()=1]/@name"/> <xsl:variable name="listname" select="a:list[position()=1]/@name"/>
<xsl:apply-templates select="list"/> <xsl:apply-templates select="a:list"/>
/// &lt;summary&gt; /// &lt;summary&gt;
/// list all instances of this entity to allow the user to select one for editing /// list all instances of this entity to allow the user to select one for editing
/// this method invokes the default list view - which is probably what you want unless /// this method invokes the default list view - which is probably what you want unless
/// you've a special reason for doing something different /// you've a special reason for doing something different
/// &lt;/summary&gt; /// &lt;/summary&gt;
public void InternalShowList() public void InternalShowList(){
{
InternalShowList( "<xsl:value-of select="$listname"/>"); InternalShowList( "<xsl:value-of select="$listname"/>");
} }
@ -327,11 +319,10 @@ namespace <xsl:value-of select="$controllerns"/> {
/// list all instances of this entity to allow the user to select one for editing /// list all instances of this entity to allow the user to select one for editing
/// &lt;/summary&gt; /// &lt;/summary&gt;
/// &lt;param name="view"&gt;The name of the list view to show&lt;/param&gt; /// &lt;param name="view"&gt;The name of the list view to show&lt;/param&gt;
public void InternalShowList( String view) public void InternalShowList( String view){
{
ISession hibernator = NHibernateHelper.GetCurrentSession(); ISession hibernator = NHibernateHelper.GetCurrentSession();
IList&lt;<xsl:value-of select="@name"/>&gt; instances = IList&lt;<xsl:value-of select="@name"/>&gt; instances =
hibernator.CreateCriteria(typeof(<xsl:value-of select="@name"/>))<xsl:for-each select="property[@distinct='user']"> hibernator.CreateCriteria(typeof(<xsl:value-of select="@name"/>))<xsl:for-each select=".//a:property[@distinct='user']">
<xsl:value-of select="concat( '.AddOrder( new Order( &#34;', @name, '&#34;, true))')"/> <xsl:value-of select="concat( '.AddOrder( new Order( &#34;', @name, '&#34;, true))')"/>
</xsl:for-each>.List&lt;<xsl:value-of select="@name"/>&gt;(); </xsl:for-each>.List&lt;<xsl:value-of select="@name"/>&gt;();
@ -345,12 +336,11 @@ namespace <xsl:value-of select="$controllerns"/> {
} }
</xsl:template> </xsl:template>
<xsl:template match="property[@required='true']"> <xsl:template match="a:property[@required='true']">
if ( Form[ "<xsl:value-of select="concat( 'instance.', @name)"/>" ] == null) if ( Form[ "<xsl:value-of select="concat( 'instance.', @name)"/>" ] == null) {
{
AddError( <xsl:choose> AddError( <xsl:choose>
<xsl:when test="ifmissing[@locale=$locale]"> <xsl:when test="ifmissing[@lang=$lang]">
<xsl:apply-templates select="ifmissing[@locale=$locale]"/> <xsl:apply-templates select="ifmissing[@lang=$lang]"/>
</xsl:when> </xsl:when>
<xsl:otherwise>"You must supply a value for <xsl:value-of select="@name"/>"</xsl:otherwise> <xsl:otherwise>"You must supply a value for <xsl:value-of select="@name"/>"</xsl:otherwise>
</xsl:choose>); </xsl:choose>);
@ -359,22 +349,17 @@ namespace <xsl:value-of select="$controllerns"/> {
</xsl:template> </xsl:template>
<!-- suppress properties otherwise --> <!-- suppress properties otherwise -->
<xsl:template match="property"/> <xsl:template match="a:property"/>
<xsl:template match="ifmissing"> <xsl:template match="a:ifmissing">
"<xsl:value-of select="normalize-space(.)"/>" "<xsl:value-of select="normalize-space(.)"/>"
</xsl:template> </xsl:template>
<xsl:template match="form"> <xsl:template match="a:form">
<xsl:variable name="key"> <xsl:variable name="key">
<xsl:choose> <xsl:call-template name="primary-key">
<xsl:when test="../@natural-key"> <xsl:with-param name="entityname" select="../@name"/>
<xsl:value-of select="../@natural-key"/> </xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="concat( '', 'Id')"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable> </xsl:variable>
/// &lt;summary&gt; /// &lt;summary&gt;
/// Handle the submission of the form named <xsl:value-of select="@name"/> /// Handle the submission of the form named <xsl:value-of select="@name"/>
@ -456,7 +441,7 @@ namespace <xsl:value-of select="$controllerns"/> {
</xsl:template> </xsl:template>
<xsl:template match="list"> <xsl:template match="a:list">
/// &lt;summary&gt; /// &lt;summary&gt;
/// list all instances of this entity to allow the user to select one /// list all instances of this entity to allow the user to select one
/// this method invokes the named view. /// this method invokes the named view.
@ -470,20 +455,20 @@ namespace <xsl:value-of select="$controllerns"/> {
<xsl:template name="menus"> <xsl:template name="menus">
<xsl:param name="entity"/> <xsl:param name="entity"/>
<xsl:for-each select="$entity/property[@type='entity']"> <xsl:for-each select="$entity/a:property[@type='entity']">
/* produce a list of <xsl:value-of select="@entity"/> to populate the menu for <xsl:value-of select="@name"/> */ /* produce a list of <xsl:value-of select="@entity"/> to populate the menu for <xsl:value-of select="@name"/> */
<xsl:call-template name="menu"> <xsl:call-template name="menu">
<xsl:with-param name="property" select="."/> <xsl:with-param name="property" select="."/>
</xsl:call-template> </xsl:call-template>
</xsl:for-each> </xsl:for-each>
<xsl:for-each select="$entity/property[@type='link']"> <xsl:for-each select="$entity/a:property[@type='link']">
/* produce a list of <xsl:value-of select="@entity"/> to populate the LHS of the shuffle for <xsl:value-of select="@name"/> */ /* produce a list of <xsl:value-of select="@entity"/> to populate the LHS of the shuffle for <xsl:value-of select="@name"/> */
<xsl:call-template name="menu"> <xsl:call-template name="menu">
<xsl:with-param name="property" select="."/> <xsl:with-param name="property" select="."/>
</xsl:call-template> </xsl:call-template>
</xsl:for-each> </xsl:for-each>
<xsl:for-each select="$entity/property[@type='list']"> <xsl:for-each select="$entity/a:property[@type='list']">
/* produce a list of <xsl:value-of select="@entity"/> to populate the multi-select for <xsl:value-of select="@name"/> */ /* produce a list of <xsl:value-of select="@entity"/> to populate the multi-select for <xsl:value-of select="@name"/> */
<xsl:call-template name="menu"> <xsl:call-template name="menu">
<xsl:with-param name="property" select="."/> <xsl:with-param name="property" select="."/>
@ -495,9 +480,9 @@ namespace <xsl:value-of select="$controllerns"/> {
<xsl:template name="menu"> <xsl:template name="menu">
<xsl:param name="property"/> <xsl:param name="property"/>
<xsl:variable name="ename" select="$property/@entity"/> <xsl:variable name="ename" select="$property/@entity"/>
<xsl:variable name="entity" select="//entity[@name=$ename]"/> <xsl:variable name="entity" select="//a:entity[@name=$ename]"/>
PropertyBag["<xsl:value-of select="concat('all_', $property/@name)"/>"] = PropertyBag["<xsl:value-of select="concat('all_', $property/@name)"/>"] =
hibernator.CreateCriteria(typeof(<xsl:value-of select="$property/@entity"/>))<xsl:for-each select="$entity/property[@distinct='user']"> hibernator.CreateCriteria(typeof(<xsl:value-of select="$property/@entity"/>))<xsl:for-each select="$entity//a:property[@distinct='user']">
<xsl:value-of select="concat('.AddOrder( new Order( &#34;', @name, '&#34;, true))')"/> <xsl:value-of select="concat('.AddOrder( new Order( &#34;', @name, '&#34;, true))')"/>
</xsl:for-each>.List&lt;<xsl:value-of select="$property/@entity"/>&gt;(); </xsl:for-each>.List&lt;<xsl:value-of select="$property/@entity"/>&gt;();
</xsl:template> </xsl:template>
@ -505,13 +490,13 @@ namespace <xsl:value-of select="$controllerns"/> {
<xsl:template name="primary-key"> <xsl:template name="primary-key">
<!-- return the name of the primary key of the entity with this name --> <!-- return the name of the primary key of the entity with this name -->
<xsl:param name="entityname"/> <xsl:param name="entityname"/>
<xsl:choose> <xsl:variable name="entity" select="//a:entity[@name=$entityname]" />
<xsl:when test="//entity[@name=$entityname]/@natural-key"> <xsl:if test="not($entity)">
<xsl:value-of select="//entity[@name=$entityname]/@natural-key"/> <xsl:message terminate="yes">Cannot find entity "<xsl:value-of select="$entityname"/>".</xsl:message>
</xsl:when> </xsl:if>
<xsl:otherwise> <xsl:if test="count($entity/a:key/a:property)!=1">
<xsl:value-of select="'Id'" /> <xsl:message terminate="yes">Entity "<xsl:value-of select="$entityname"/>" does not have a single-property primary key.</xsl:message>
</xsl:otherwise> </xsl:if>
</xsl:choose> <xsl:value-of select="$entity/a:key/a:property/@name"/>
</xsl:template> </xsl:template>
</xsl:stylesheet> </xsl:stylesheet>

300
ADL.NET/Trans/adl2entityclass.xsl → transforms/adl2entityclasses.xslt
View file

@ -8,50 +8,51 @@
Transform ADL into entity classes Transform ADL into entity classes
$Author: af $ $Author: af $
$Revision: 1.2 $ $Revision: 1.1 $
$Date: 2008-01-14 16:53:31 $ $Date: 2008-01-21 16:38:31 $
--> -->
<!-- WARNING WARNING WARNING: Do NOT reformat this file! <!-- WARNING WARNING WARNING: Do NOT reformat this file!
Whitespace (or lack of it) is significant! --> Whitespace (or lack of it) is significant! -->
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:exsl="http://exslt.org/common" xmlns:msxsl="urn:schemas-microsoft-com:xslt"> <xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:exsl="http://exslt.org/common"
xmlns:a="http://cygnets.co.uk/schemas/adl-1.2"
xmlns:msxsl="urn:schemas-microsoft-com:xslt">
<xsl:import href="types.xslt"/>
<xsl:output encoding="UTF-8" method="text"/> <xsl:output encoding="UTF-8" method="text"/>
<!-- The locale for which these entities are generated <!-- The locale for which these entities are generated
TODO: Entities should NOT be locale specific. Instead, the TODO: Entities should NOT be locale specific. Instead, the
entity should generate messages based on the entity should generate messages based on the
client's locale. However, there may still need to be a concept of a client's locale. However, there may still need to be a concept of a
'default locale', for when we don't have messages which suit the 'default locale', for when we don't have messages which suit the
client's locale --> client's locale -->
<xsl:param name="locale" select="en-UK"/> <xsl:param name="lang" select="en-UK"/>
<!-- The C# namespace within which I shall generate controllers --> <!-- The C# namespace within which I shall generate controllers -->
<xsl:param name="controllerns" select="Unset"/> <xsl:param name="controllerns" select="Unset"/>
<!-- The C# namespace within which I shall generate entities --> <!-- The C# namespace within which I shall generate entities -->
<xsl:param name="entityns" select="Unset"/> <xsl:param name="entityns" select="Unset"/>
<xsl:template match="application"> <xsl:template match="a:application">
<xsl:apply-templates select="entity"/> <xsl:apply-templates select="a:entity"/>
</xsl:template> </xsl:template>
<xsl:template match="application"> <xsl:template match="a:entity">
<xsl:apply-templates select="entity"/>
</xsl:template>
<xsl:template match="entity">
<!-- what's all this about? the objective is to get the revision number of the <!-- what's all this about? the objective is to get the revision number of the
transform into the output, /without/ getting that revision number overwritten transform into the output, /without/ getting that revision number overwritten
with the revision number of the generated file if the generated file is with the revision number of the generated file if the generated file is
stored to CVS --> stored to CVS -->
<xsl:variable name="transform-rev1" <xsl:variable name="transform-rev1"
select="substring( '$Revision: 1.2 $', 11)"/> select="substring( '$Revision: 1.1 $', 11)"/>
<xsl:variable name="transform-revision" <xsl:variable name="transform-revision"
select="substring( $transform-rev1, 0, string-length( $transform-rev1) - 1)"/> select="substring( $transform-rev1, 0, string-length( $transform-rev1) - 1)"/>
<xsl:variable name="keynames" select="property[@distinct='system']" /> <xsl:variable name="keynames" select="a:key/a:property" />
/* ---- [ cut here: next file '<xsl:value-of select="@name"/>.auto.cs'] ---------------- */ /* ---- [ cut here: next file '<xsl:value-of select="@name"/>.auto.cs'] ---------------- */
@ -74,8 +75,8 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using ADL.Entities; using Cygnet.Entities;
using ADL.Exceptions; using Cygnet.Entities.Exceptions;
using Iesi.Collections.Generic; using Iesi.Collections.Generic;
/// &lt;summary&gt; /// &lt;summary&gt;
@ -95,52 +96,6 @@
<xsl:call-template name="initialise-lists"/> <xsl:call-template name="initialise-lists"/>
} }
/*
/// &lt;summary&gt;
/// Auto-generated one-arg constructor; initialises Id slot and also all
/// one-to-many slots
/// &lt;/summary&gt;
public <xsl:value-of select="@name"/>( int key)
{
<xsl:call-template name="initialise-lists"/>
<!--xsl:choose>
<xsl:when test="@natural-key">
/* natural primary key exists - not initialising abstract key */
</xsl:when>
<xsl:otherwise>
_Id = key;
</xsl:otherwise>
</xsl:choose-->
}
*/
<!--xsl:choose>
<xsl:when test="@natural-key">
/* natural primary key exists - not generating abstract key */
</xsl:when>
<xsl:otherwise>
/// &lt;summary&gt;
/// Auto-generated iv/property for Id slot
/// &lt;/summary&gt;
private int _Id = -1;
public virtual int Id
{
get { return _Id; }
set { _Id = value; }
}
/// &lt;summary&gt;
/// Auto-generated overridden property for the Key slot, maps onto
/// _Id
/// &lt;/summary&gt;
public override int Key
{
get { return _Id; }
}
</xsl:otherwise>
</xsl:choose-->
/// &lt;summary&gt; /// &lt;summary&gt;
/// Auto-generated overridden property for the Key slot, maps onto /// Auto-generated overridden property for the Key slot, maps onto
/// &lt;/summary&gt; /// &lt;/summary&gt;
@ -154,10 +109,12 @@
return <xsl:value-of select="$keynames[1]/@name"/>.ToString(); // Single key. return <xsl:value-of select="$keynames[1]/@name"/>.ToString(); // Single key.
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
StringBuilder result = new StringBuilder(<xsl:value-of select="$keynames[1]/@name"/>); StringBuilder result = new StringBuilder();
<xsl:for-each select="$keynames[position() != 1]"> <xsl:for-each select="$keynames">
result.Append('|'); result.Append(<xsl:value-of select="@name"/><xsl:if test="@type='entity'">.KeyString</xsl:if>);
result.Append(<xsl:value-of select="@name"/>); <xsl:if test="position()!=last()">
result.Append('|');
</xsl:if>
</xsl:for-each> </xsl:for-each>
return result.ToString(); return result.ToString();
</xsl:otherwise> </xsl:otherwise>
@ -168,49 +125,37 @@
/// &lt;summary&gt; /// &lt;summary&gt;
/// A user readable distinct identifying string /// A user readable distinct identifying string
/// &lt;/summary&gt; /// &lt;/summary&gt;
public override string UserIdentifier public override string UserIdentifier {
{ get {
get { StringBuilder result = new StringBuilder();
StringBuilder result = new StringBuilder(); <xsl:choose>
<xsl:choose> <xsl:when test="a:key/a:property">
<xsl:when test="property[@distinct='user']"> <xsl:for-each select="a:key/a:property">
<xsl:for-each select="property[@distinct='user']"> result.Append(<xsl:value-of select="@name"/><xsl:if test="@type='entity'">.UserIdentifier</xsl:if>);
<xsl:choose> <xsl:if test="position() != last()">
<xsl:when test="@type='entity'"> result.Append( ", ");
<!-- TODO: this is dangerous and could potentially give rise to </xsl:if>
infinite loops; find a way of stopping it running away! --> </xsl:for-each>
result.Append( <xsl:value-of select="concat( @name, '.UserIdentifier')"/>); </xsl:when>
</xsl:when> <xsl:otherwise>
<xsl:otherwise> result.AppendFormat( "<xsl:value-of select="@name"/>#{0}", <xsl:call-template name="list-properties"/>);
result.Append(<xsl:value-of select="concat( '_', @name)"/>); </xsl:otherwise>
</xsl:otherwise> </xsl:choose>
</xsl:choose>
<xsl:choose>
<xsl:when test="position() = last()"/>
<xsl:otherwise>
result.Append( ", ");
</xsl:otherwise>
</xsl:choose>
</xsl:for-each>
</xsl:when>
<xsl:otherwise>
result.AppendFormat( "<xsl:value-of select="@name"/>#{0}", <xsl:call-template name="list-properties"/>);
</xsl:otherwise>
</xsl:choose>
return result.ToString(); return result.ToString();
} }
} }
<xsl:apply-templates select="property"/> <xsl:apply-templates select="a:key/a:property|a:property|a:set"/>
} }
} }
</xsl:template> </xsl:template>
<!-- Creates a comma-separated list of all the properties passed in, or all the key properties by default. -->
<xsl:template name="list-properties"> <xsl:template name="list-properties">
<xsl:param name="props" select="property[@distinct='system']"/> <xsl:param name="props" select="a:key/a:property"/>
<xsl:if test="count($props)!=0"> <xsl:if test="count($props)!=0">
<xsl:value-of select="$props[1]/@name"/> <xsl:value-of select="$props[1]/@name"/>
<xsl:if test="count($props)!=1">, </xsl:if> <xsl:if test="count($props)!=1">, </xsl:if>
@ -220,49 +165,26 @@
</xsl:if> </xsl:if>
</xsl:template> </xsl:template>
<xsl:template match="property[@concrete='false']"> <xsl:template match="a:property[@concrete='false']">
<!-- generate nothing for non-concrete properties --> <!-- generate nothing for non-concrete properties -->
</xsl:template> </xsl:template>
<xsl:template match="property"> <xsl:template match="a:property">
// auto generating iv/property pair for slot with name <xsl:value-of select="@name"/> // auto generating iv/property pair for slot with name <xsl:value-of select="@name"/>
<xsl:apply-templates select="help"/> <xsl:apply-templates select="a:help"/>
<xsl:variable name="defined-type">
<xsl:choose>
<xsl:when test="@type='defined'">
<xsl:variable name="definition">
<xsl:value-of select="@definition"/>
</xsl:variable>
<xsl:value-of select="/application/definition[@name=$definition]/@type"/>
</xsl:when>
</xsl:choose>
</xsl:variable>
<xsl:variable name="type-nullable"> <xsl:variable name="type-nullable">
<xsl:choose> <xsl:choose>
<xsl:when test="@type='defined'"> <xsl:when test="@type='link' or @type='list' or @type='entity'">true</xsl:when>
<xsl:otherwise>
<xsl:call-template name="type-nullable"> <xsl:call-template name="type-nullable">
<xsl:with-param name="typename" select="$defined-type"/>
</xsl:call-template> </xsl:call-template>
</xsl:when> </xsl:otherwise>
<xsl:when test="@type!='link' and @type!='list' and @type!='entity'">
<xsl:call-template name="type-nullable">
<xsl:with-param name="typename" select="@type"/>
</xsl:call-template>
</xsl:when>
<xsl:otherwise>true</xsl:otherwise>
</xsl:choose> </xsl:choose>
</xsl:variable> </xsl:variable>
<xsl:variable name="type"> <xsl:variable name="type">
<xsl:choose> <xsl:choose>
<xsl:when test="@type='defined'">
<!-- Find the right definition, then map its type onto a C# type -->
<xsl:call-template name="type-declarator">
<xsl:with-param name="typename" select="$defined-type"/>
</xsl:call-template>
</xsl:when>
<xsl:when test="@type = 'link'"> <xsl:when test="@type = 'link'">
ICollection&lt;<xsl:value-of select="@entity"/>&gt; ICollection&lt;<xsl:value-of select="@entity"/>&gt;
</xsl:when> </xsl:when>
@ -274,8 +196,7 @@
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:call-template name="type-declarator"> <xsl:call-template name="type-declarator">
<xsl:with-param name="typename" select="@type"/> <xsl:with-param name="nullable" select="@not-null!='true'"/>
<xsl:with-param name="nullable" select="@required!='true'"/>
</xsl:call-template> </xsl:call-template>
</xsl:otherwise> </xsl:otherwise>
</xsl:choose> </xsl:choose>
@ -296,14 +217,11 @@
</xsl:variable> </xsl:variable>
<xsl:variable name="validationpattern"> <xsl:variable name="validationpattern">
<xsl:choose> <xsl:if test="not(@type='link' or @type='list' or @type='entity')">
<xsl:when test="@type='defined'"> <xsl:call-template name="type-attr">
<xsl:variable name="definition"> <xsl:with-param name="attr" select="'pattern'" />
<xsl:value-of select="@definition"/> </xsl:call-template>
</xsl:variable> </xsl:if>
<xsl:value-of select="/application/definition[@name=$definition]/@pattern"/>
</xsl:when>
</xsl:choose>
</xsl:variable> </xsl:variable>
<xsl:if test="string-length( $validationpattern) &gt; 0"> <xsl:if test="string-length( $validationpattern) &gt; 0">
private Regex <xsl:value-of select="@name"/>Validator = new Regex( "<xsl:value-of select="$validationpattern"/>"); private Regex <xsl:value-of select="@name"/>Validator = new Regex( "<xsl:value-of select="$validationpattern"/>");
@ -315,7 +233,7 @@
{ {
get { return _<xsl:value-of select="@name"/>; } get { return _<xsl:value-of select="@name"/>; }
set { set {
<xsl:if test="@required='true' and $type-nullable='true'"> <xsl:if test="@not-null='true' and $type-nullable='true'">
if ( value == null) if ( value == null)
{ {
throw new DataRequiredException( <xsl:choose> throw new DataRequiredException( <xsl:choose>
@ -329,15 +247,16 @@
); );
} }
</xsl:if> </xsl:if>
<xsl:if test="@type='defined'"> <xsl:if test="not(@type='link' or @type='list' or @type='entity')">
<xsl:variable name="definition">
<xsl:value-of select="@definition"/>
</xsl:variable>
<xsl:variable name="maximum"> <xsl:variable name="maximum">
<xsl:value-of select="/application/definition[@name=$definition]/@maximum"/> <xsl:call-template name="type-attr">
<xsl:with-param name="attr" select="'maximum'" />
</xsl:call-template>
</xsl:variable> </xsl:variable>
<xsl:variable name="minimum"> <xsl:variable name="minimum">
<xsl:value-of select="/application/definition[@name=$definition]/@minimum"/> <xsl:call-template name="type-attr">
<xsl:with-param name="attr" select="'minimum'" />
</xsl:call-template>
</xsl:variable> </xsl:variable>
<xsl:if test="string-length( $maximum) &gt; 0"> <xsl:if test="string-length( $maximum) &gt; 0">
if ( value &gt; <xsl:value-of select="$maximum"/>) if ( value &gt; <xsl:value-of select="$maximum"/>)
@ -370,63 +289,60 @@
</xsl:template> </xsl:template>
<xsl:template match="a:set[a:many-to-many]">
// auto generating for set with name <xsl:value-of select="@name"/>, having many-to-many child
private ICollection&lt;<xsl:value-of
select="a:many-to-many/@entity"/>&gt;<xsl:text> </xsl:text>_<xsl:value-of select="@name"/>;
public virtual ICollection&lt;<xsl:value-of select="a:many-to-many/@entity"/>&gt; <xsl:value-of select="@name"/>
{
get { return _<xsl:value-of select="@name"/>; }
set { _<xsl:value-of select="@name"/> = value; }
}
</xsl:template>
<xsl:template match="a:set[a:one-to-many]">
// auto generating for set with name <xsl:value-of select="@name"/>, having one-to-many child
private ICollection&lt;<xsl:value-of
select="a:one-to-many/@entity"/>&gt;<xsl:text> </xsl:text>_<xsl:value-of select="@name"/>;
public virtual ICollection&lt;<xsl:value-of select="a:one-to-many/@entity"/>&gt; <xsl:value-of select="@name"/>
{
get { return _<xsl:value-of select="@name"/>; }
set { _<xsl:value-of select="@name"/> = value; }
}
</xsl:template>
<xsl:template name="type-declarator"> <xsl:template name="type-declarator">
<xsl:param name="typename"/>
<xsl:param name="nullable" select="false()"/> <xsl:param name="nullable" select="false()"/>
<xsl:variable name="override-type" select="document('types.xml',/application)/types/type[@name=$typename]"/> <xsl:call-template name="type-attr">
<xsl:variable name="type0"> <xsl:with-param name="attr" select="'dotnet'"/>
<xsl:choose> </xsl:call-template>
<xsl:when test="$override-type"> <xsl:variable name="kind">
<xsl:copy-of select="$override-type"/> <xsl:call-template name="type-attr">
</xsl:when> <xsl:with-param name="attr" select="'dotnet-kind'"/>
<xsl:otherwise> </xsl:call-template>
<xsl:copy-of select="document('types.xml')/types/type[@name=$typename]"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable> </xsl:variable>
<xsl:variable name="type" select="msxsl:node-set($type0)/type"/> <xsl:if test="$nullable and $kind='value'">?</xsl:if>
<xsl:choose>
<xsl:when test="$type">
<xsl:value-of select="$type/@dotnet" />
<xsl:if test="$nullable and $type/@dotnet-kind='value'">?</xsl:if>
</xsl:when>
<xsl:otherwise>
<xsl:message terminate="yes">
Error! <xsl:value-of select="$typename"/> not found.
</xsl:message>
</xsl:otherwise>
</xsl:choose>
</xsl:template> </xsl:template>
<xsl:template name="type-nullable"> <xsl:template name="type-nullable">
<xsl:param name="typename"/> <xsl:variable name="kind">
<xsl:variable name="override-type" select="document('types.xml',/application)/types/type[@name=$typename]"/> <xsl:call-template name="type-attr">
<xsl:variable name="type0"> <xsl:with-param name="attr" select="'dotnet-kind'"/>
<xsl:choose> </xsl:call-template>
<xsl:when test="$override-type">
<xsl:copy-of select="$override-type"/>
</xsl:when>
<xsl:otherwise>
<xsl:copy-of select="document('types.xml')/types/type[@name=$typename]"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable> </xsl:variable>
<xsl:variable name="type" select="msxsl:node-set($type0)/type"/> <xsl:if test="$kind!='value'">true</xsl:if>
<xsl:choose>
<xsl:when test="$type">
<xsl:if test="$type/@dotnet-kind!='value'">true</xsl:if>
</xsl:when>
<xsl:otherwise>
<xsl:message terminate="yes">
Error! <xsl:value-of select="$typename"/> not found.
</xsl:message>
</xsl:otherwise>
</xsl:choose>
</xsl:template> </xsl:template>
<xsl:template match="help"> <xsl:template match="help">
<xsl:if test="@locale=$locale"> <xsl:if test="@lang=$lang">
<!-- might conceivably be more than one line --> <!-- might conceivably be more than one line -->
<xsl:text> <xsl:text>
/* </xsl:text><xsl:apply-templates/> */ /* </xsl:text><xsl:apply-templates/> */
@ -434,7 +350,7 @@
</xsl:template> </xsl:template>
<xsl:template match="ifmissing"> <xsl:template match="ifmissing">
<xsl:if test="@locale=$locale"> <xsl:if test="@lang=$lang">
"<xsl:value-of select="normalize-space(.)"/>" "<xsl:value-of select="normalize-space(.)"/>"
</xsl:if> </xsl:if>
</xsl:template> </xsl:template>

204
transforms/adl2hibernate.xslt Executable file
View file

@ -0,0 +1,204 @@
<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns="urn:nhibernate-mapping-2.2"
xmlns:a="http://cygnets.co.uk/schemas/adl-1.2"
exclude-result-prefixes="a">
<!--
Application Description Framework
adl2hibernate.xsl
(c) 2007 Cygnet Solutions Ltd
Transform ADL to Verbose (or canonical) ADL
Most defaults are replaced with their actual values.
$Author: af $
$Revision: 1.1 $
-->
<xsl:output indent="no" method="xml" encoding="utf-8"/>
<xsl:template match="a:application">
<hibernate-mapping>
<xsl:apply-templates select="@namespace|@assembly" />
<xsl:comment>
***************************************************************************
*
* ©2007 Cygnet Solutions Ltd
*
* THIS FILE IS AUTOMATICALLY GENERATED AND SHOULD NOT
* BE MANUALLY EDITED.
*
* Generated using adl2hibernate-mapping.xsl revision <xsl:value-of select="substring('$Revision: 1.1 $', 12)"/>
*
***************************************************************************
</xsl:comment>
<xsl:apply-templates select="a:entity|comment()"/>
</hibernate-mapping>
</xsl:template>
<xsl:template match="a:entity">
<class>
<xsl:apply-templates select="@name|@table" />
<xsl:apply-templates select="a:key" />
<xsl:apply-templates select="a:property|a:set|a:bag|a:subclass|a:component|a:discriminator" />
</class>
</xsl:template>
<xsl:template match="a:key">
<xsl:choose>
<xsl:when test="count(a:property)=0">
<xsl:message terminate="yes">
Class '<xsl:value-of select="ancestor::a:entity/@name"/>' has no properties in its key
</xsl:message>
</xsl:when>
<xsl:when test="count(a:property)=1">
<id>
<xsl:apply-templates select="a:property/@*|a:property/node()" />
</id>
</xsl:when>
<xsl:otherwise>
<composite-id>
<xsl:apply-templates select="a:property" mode="key" />
</composite-id>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="a:property" mode="key">
<xsl:choose>
<xsl:when test="@type='entity'">
<key-many-to-one>
<xsl:apply-templates select="@name|@column|@entity|node()"/>
</key-many-to-one>
</xsl:when>
<xsl:when test="true()">
<key-property>
<xsl:apply-templates select="@*|node()"/>
</key-property>
</xsl:when>
</xsl:choose>
</xsl:template>
<xsl:template match="a:property">
<xsl:choose>
<xsl:when test="@type='entity'">
<many-to-one>
<xsl:apply-templates select="@name|@column|@entity|node()"/>
</many-to-one>
</xsl:when>
<xsl:when test="true()">
<property><xsl:apply-templates select="@*|node()"/></property>
</xsl:when>
</xsl:choose>
</xsl:template>
<xsl:template match="a:property/@type">
<xsl:attribute name="type">
<xsl:call-template name="type-spec">
<xsl:with-param name="typename" select="../@type"/>
</xsl:call-template>
<xsl:if test="../@size">(<xsl:value-of select="../@size"/>)</xsl:if>
</xsl:attribute>
</xsl:template>
<xsl:template match="a:property/@size"><!--Remove--></xsl:template>
<xsl:template match="a:property/@required">
<xsl:if test="string(.)='true'">
<xsl:attribute name="not-null">true</xsl:attribute>
</xsl:if>
</xsl:template>
<xsl:template match="@entity">
<xsl:attribute name="class">
<xsl:value-of select="."/></xsl:attribute>
</xsl:template>
<xsl:template match="a:set">
<set>
<xsl:apply-templates select="@*|node()" />
</set>
</xsl:template>
<xsl:template match="a:bag">
<bag>
<xsl:apply-templates select="@*|node()" />
</bag>
</xsl:template>
<xsl:template match="a:subclass">
<subclass>
<xsl:apply-templates select="@*"/>
<xsl:apply-templates select="node()"/>
</subclass>
</xsl:template>
<xsl:template match="a:discriminator">
<discriminator>
<xsl:apply-templates select="@*|node()" />
</discriminator>
</xsl:template>
<xsl:template match="a:component">
<component>
<xsl:apply-templates select="@*|node()" />
</component>
</xsl:template>
<xsl:template match="a:foreign-key">
<key>
<xsl:apply-templates select="@*|node()" />
</key>
</xsl:template>
<xsl:template match="a:one-to-many">
<one-to-many>
<xsl:apply-templates select="@*|node()" />
</one-to-many>
</xsl:template>
<xsl:template match="a:many-to-many">
<many-to-many>
<xsl:apply-templates select="@*|node()" />
</many-to-many>
</xsl:template>
<xsl:template match="a:generator">
<generator>
<xsl:apply-templates select="@*|node()" />
</generator>
</xsl:template>
<xsl:template name="type-spec">
<xsl:param name="typename"/>
<xsl:param name="nullable" select="false()"/>
<xsl:variable name="type0" select="/a:application/a:type[@name=$typename]|document('types.xml')/types/type[@name=$typename]"/>
<xsl:variable name="type" select="$type0[1]"/>
<xsl:choose>
<xsl:when test="$type/@hibernate">
<xsl:value-of select="$type/@hibernate" />
</xsl:when>
<xsl:when test="$type/@dotnet">
<xsl:value-of select="$type/@dotnet" />
</xsl:when>
<xsl:when test="$type">
<xsl:message terminate="yes">Error! Found type "<xsl:value-of select="$typename"/>" but cannot find 'dotnet' or 'hibernate' attributes.</xsl:message>
</xsl:when>
<xsl:otherwise>
<xsl:message terminate="yes">Error! Type "<xsl:value-of select="$typename"/>" not found.</xsl:message>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="@*|node()">
<xsl:copy>
<xsl:apply-templates select="@*|node()"/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>

0
ADL.NET/Trans/adl2mssql.xsl → transforms/adl2mssql.xslt
View file

0
ADL.NET/Trans/adl2psql.xsl → transforms/adl2psql.xslt
View file

260
ADL.NET/Trans/adl2views.xsl → transforms/adl2views.xslt
View file

@ -1,5 +1,9 @@
<?xml version="1.0" encoding="UTF-8" ?> <?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:a="http://cygnets.co.uk/schemas/adl-1.2"
exclude-result-prefixes="a">
<!-- <!--
C1873 SRU Hospitality C1873 SRU Hospitality
adl2views.xsl adl2views.xsl
@ -9,8 +13,8 @@
Transform ADL into velocity view templates Transform ADL into velocity view templates
$Author: af $ $Author: af $
$Revision: 1.2 $ $Revision: 1.1 $
$Date: 2008-01-14 16:53:31 $ $Date: 2008-01-21 16:38:31 $
--> -->
<!-- WARNING WARNING WARNING: Do NOT reformat this file! <!-- WARNING WARNING WARNING: Do NOT reformat this file!
Whitespace (or lack of it) is significant! --> Whitespace (or lack of it) is significant! -->
@ -23,7 +27,7 @@
<!-- The locale for which these views are generated <!-- The locale for which these views are generated
TODO: we need to generate views for each available locale, but this is not TODO: we need to generate views for each available locale, but this is not
yet implemented. When it is we will almost certainly still need a 'default locale' --> yet implemented. When it is we will almost certainly still need a 'default locale' -->
<xsl:param name="locale" select="en-UK"/> <xsl:param name="lang" select="'en-UK'"/>
<!-- what's all this about? the objective is to get the revision number of the <!-- what's all this about? the objective is to get the revision number of the
transform into the output, /without/ getting that revision number overwritten transform into the output, /without/ getting that revision number overwritten
@ -31,23 +35,23 @@
stored to CVS --> stored to CVS -->
<xsl:variable name="transform-rev1" <xsl:variable name="transform-rev1"
select="substring( '$Revision: 1.2 $', 11)"/> select="substring( '$Revision: 1.1 $', 11)"/>
<xsl:variable name="transform-revision" <xsl:variable name="transform-revision"
select="substring( $transform-rev1, 0, string-length( $transform-rev1) - 1)"/> select="substring( $transform-rev1, 0, string-length( $transform-rev1) - 1)"/>
<xsl:template match="application"> <xsl:template match="a:application">
<output> <output>
<xsl:apply-templates select="entity"/> <xsl:apply-templates select="a:entity"/>
<!-- make sure extraneous junk doesn't get into the last file generated, <!-- make sure extraneous junk doesn't get into the last file generated,
by putting it into a separate file --> by putting it into a separate file -->
<xsl:comment> [ cut here: next file 'tail.txt' ] </xsl:comment> <xsl:comment> [ cut here: next file 'tail.txt' ] </xsl:comment>
</output> </output>
</xsl:template> </xsl:template>
<xsl:template match="entity"> <xsl:template match="a:entity">
<xsl:apply-templates select="form"/> <xsl:apply-templates select="a:form"/>
<xsl:apply-templates select="list"/> <xsl:apply-templates select="a:list"/>
<xsl:text> <xsl:text>
</xsl:text> </xsl:text>
<xsl:comment> [ cut here: next file '<xsl:value-of select="concat( @name, '/maybedelete.auto.vm')"/>' ] </xsl:comment> <xsl:comment> [ cut here: next file '<xsl:value-of select="concat( @name, '/maybedelete.auto.vm')"/>' ] </xsl:comment>
@ -108,10 +112,10 @@
<!-- layout of forms --> <!-- layout of forms -->
<xsl:template match="form"> <xsl:template match="a:form">
<xsl:variable name="formname" select="@name"/> <xsl:variable name="formname" select="@name"/>
<xsl:variable name="aoran"> <xsl:variable name="aoran">
<xsl:variable name="initial" select="substring( ancestor::entity/@name, 1, 1)"/> <xsl:variable name="initial" select="substring( ancestor::a:entity/@name, 1, 1)"/>
<xsl:choose> <xsl:choose>
<xsl:when test="$initial = 'A'">an</xsl:when> <xsl:when test="$initial = 'A'">an</xsl:when>
<xsl:when test="$initial = 'E'">an</xsl:when> <xsl:when test="$initial = 'E'">an</xsl:when>
@ -123,15 +127,15 @@
</xsl:variable> </xsl:variable>
<xsl:text> <xsl:text>
</xsl:text> </xsl:text>
<xsl:comment> [ cut here: next file '<xsl:value-of select="concat( ancestor::entity/@name, '/', @name)"/>.auto.vm' ] </xsl:comment> <xsl:comment> [ cut here: next file '<xsl:value-of select="concat( ancestor::a:entity/@name, '/', @name)"/>.auto.vm' ] </xsl:comment>
<xsl:text> <xsl:text>
</xsl:text> </xsl:text>
<html> <html>
<xsl:comment> <xsl:comment>
#if ( $instance) #if ( $instance)
#set( $title = "<xsl:value-of select="concat( 'Edit ', ' ', ancestor::entity/@name)"/> $instance.UserIdentifier") #set( $title = "<xsl:value-of select="concat( 'Edit ', ' ', ancestor::a:entity/@name)"/> $instance.UserIdentifier")
#else #else
#set( $title = "Add a new <xsl:value-of select="ancestor::entity/@name"/>") #set( $title = "Add a new <xsl:value-of select="ancestor::a:entity/@name"/>")
#end #end
</xsl:comment> </xsl:comment>
<head> <head>
@ -150,7 +154,7 @@
<script type="text/javascript" language='JavaScript1.2' src="../script/panes.js"></script> <script type="text/javascript" language='JavaScript1.2' src="../script/panes.js"></script>
<script type='text/javascript' language='JavaScript1.2'> <script type='text/javascript' language='JavaScript1.2'>
var panes = new Array( <xsl:for-each select='fieldgroup'> var panes = new Array( <xsl:for-each select='a:fieldgroup'>
"<xsl:value-of select='@name'/>"<xsl:choose> "<xsl:value-of select='@name'/>"<xsl:choose>
<xsl:when test="position() = last()"/> <xsl:when test="position() = last()"/>
<xsl:otherwise>,</xsl:otherwise> <xsl:otherwise>,</xsl:otherwise>
@ -158,18 +162,18 @@
function performInitialisation() function performInitialisation()
{ {
<xsl:for-each select="../property[@type='link']"> <xsl:for-each select="../a:property[@type='link']">
document.<xsl:value-of select="$formname"/>.<xsl:value-of select="@name"/>.submitHandler = shuffleSubmitHandler; document.<xsl:value-of select="$formname"/>.<xsl:value-of select="@name"/>.submitHandler = shuffleSubmitHandler;
</xsl:for-each> </xsl:for-each>
var validator = new Validation('<xsl:value-of select="$formname"/>', {immediate : true, useTitles : true}); var validator = new Validation('<xsl:value-of select="$formname"/>', {immediate : true, useTitles : true});
<xsl:if test="fieldgroup"> <xsl:if test="a:fieldgroup">
switchtab( '<xsl:value-of select="fieldgroup[1]/@name"/>'); switchtab( '<xsl:value-of select="a:fieldgroup[1]/@name"/>');
</xsl:if> </xsl:if>
} }
</script> </script>
<style type="text/css"> <style type="text/css">
<xsl:for-each select="../property[@required='true']"> <xsl:for-each select="../a:property[@required='true']">
#<xsl:value-of select="concat( 'advice-required-instance_', @name)"/> #<xsl:value-of select="concat( 'advice-required-instance_', @name)"/>
{ {
color: white; color: white;
@ -218,14 +222,14 @@
<xsl:value-of select="$formname"/> <xsl:value-of select="$formname"/>
</xsl:attribute> </xsl:attribute>
<xsl:choose> <xsl:choose>
<xsl:when test="ancestor::entity/@natural-key"> <xsl:when test="ancestor::a:entity/@natural-key">
<xsl:variable name="keyfield" select="ancestor::entity/@natural-key"/> <xsl:variable name="keyfield" select="ancestor::a:entity/@natural-key"/>
<xsl:choose> <xsl:choose>
<xsl:when test="@properties='all'"> <xsl:when test="@properties='all'">
<!-- no need to emit a hidden widget for the natural key, as there will be a <!-- no need to emit a hidden widget for the natural key, as there will be a
non-hidden one anyway --> non-hidden one anyway -->
</xsl:when> </xsl:when>
<xsl:when test="field[@name=$keyfield]"> <xsl:when test="a:field[@name=$keyfield]">
<!-- no need to emit a hidden widget for the natural key, as there will be a <!-- no need to emit a hidden widget for the natural key, as there will be a
non-hidden one anyway --> non-hidden one anyway -->
</xsl:when> </xsl:when>
@ -241,9 +245,9 @@
${FormHelper.HiddenField( "instance.Id")} ${FormHelper.HiddenField( "instance.Id")}
</xsl:otherwise> </xsl:otherwise>
</xsl:choose> </xsl:choose>
<xsl:if test="fieldgroup"> <xsl:if test="a:fieldgroup">
<div id="tabbar"> <div id="tabbar">
<xsl:for-each select="fieldgroup"> <xsl:for-each select="a:fieldgroup">
<span class="tab"> <span class="tab">
<xsl:attribute name="id"> <xsl:attribute name="id">
<xsl:value-of select="concat( @name, 'tab')"/> <xsl:value-of select="concat( @name, 'tab')"/>
@ -261,15 +265,15 @@
</xsl:for-each> </xsl:for-each>
</div> </div>
</xsl:if> </xsl:if>
<xsl:apply-templates select="fieldgroup"/> <xsl:apply-templates select="a:fieldgroup"/>
<div class="pane"> <div class="pane">
<table> <table>
<xsl:choose> <xsl:choose>
<xsl:when test="@properties='listed'"> <xsl:when test="@properties='listed'">
<xsl:apply-templates select="field|auxlist|verb"/> <xsl:apply-templates select="a:field|a:auxlist|a:verb"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:apply-templates select="ancestor::entity/property"/> <xsl:apply-templates select="ancestor::a:entity/a:property"/>
</xsl:otherwise> </xsl:otherwise>
</xsl:choose> </xsl:choose>
<tr class="actionSafe"> <tr class="actionSafe">
@ -298,7 +302,7 @@
</html> </html>
</xsl:template> </xsl:template>
<xsl:template match="fieldgroup"> <xsl:template match="a:fieldgroup">
<div class="pane"> <div class="pane">
<xsl:attribute name="id"> <xsl:attribute name="id">
<xsl:value-of select="concat( @name, 'pane')"/> <xsl:value-of select="concat( @name, 'pane')"/>
@ -320,19 +324,19 @@
</h3> </h3>
</a> </a>
<table> <table>
<xsl:apply-templates select="field|verb|auxlist"/> <xsl:apply-templates select="a:field|a:verb|a:auxlist"/>
</table> </table>
</div> </div>
</xsl:template> </xsl:template>
<xsl:template match="auxlist"> <xsl:template match="a:auxlist">
<xsl:variable name="listprop" select="@property"/> <xsl:variable name="listprop" select="@property"/>
<xsl:variable name="farent" select="ancestor::entity/property[@name=$listprop]/@entity"/> <xsl:variable name="farent" select="ancestor::a:entity/a:property[@name=$listprop]/@entity"/>
<xsl:variable name="nearent" select="ancestor::entity/@name"/> <xsl:variable name="nearent" select="ancestor::a:entity/@name"/>
<xsl:variable name="farid"> <xsl:variable name="farid">
<xsl:choose> <xsl:choose>
<xsl:when test="//entity[@name=$farent]/@natural-key"> <xsl:when test="//a:entity[@name=$farent]/@natural-key">
<xsl:value-of select="//entity[@name=$farent]/@natural-key"/> <xsl:value-of select="//a:entity[@name=$farent]/@natural-key"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:value-of select="concat( '', 'Id')"/> <xsl:value-of select="concat( '', 'Id')"/>
@ -340,12 +344,12 @@
</xsl:choose> </xsl:choose>
</xsl:variable> </xsl:variable>
<xsl:variable name="farkey"> <xsl:variable name="farkey">
<xsl:value-of select="//entity[@name=$farent]/property[@entity=$nearent]/@name"/> <xsl:value-of select="//a:entity[@name=$farent]/a:property[@entity=$nearent]/@name"/>
</xsl:variable> </xsl:variable>
<xsl:variable name="nearkey"> <xsl:variable name="nearkey">
<xsl:choose> <xsl:choose>
<xsl:when test="ancestor::entity[@natural-key]"> <xsl:when test="ancestor::a:entity[@natural-key]">
<xsl:value-of select="ancestor::entity[@natural-key]"/> <xsl:value-of select="ancestor::a:entity[@natural-key]"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:value-of select="concat( '', 'Id')"/> <xsl:value-of select="concat( '', 'Id')"/>
@ -371,13 +375,13 @@
<xsl:choose> <xsl:choose>
<xsl:when test="@properties='listed'"> <xsl:when test="@properties='listed'">
<tr> <tr>
<xsl:for-each select="field"> <xsl:for-each select="a:field">
<xsl:variable name="fieldprop" select="@property"/> <xsl:variable name="fieldprop" select="@property"/>
<th> <th>
<!-- Getting the prompt for the field from a property of another entity is a bit <!-- Getting the prompt for the field from a property of another entity is a bit
complex... --> complex... -->
<xsl:call-template name="showprompt"> <xsl:call-template name="showprompt">
<xsl:with-param name="node" select="//entity[@name=$farent]/property[@name=$fieldprop]"/> <xsl:with-param name="node" select="//a:entity[@name=$farent]/a:property[@name=$fieldprop]"/>
<xsl:with-param name="fallback" select="@property"/> <xsl:with-param name="fallback" select="@property"/>
</xsl:call-template> </xsl:call-template>
</th> </th>
@ -393,19 +397,19 @@
#set( $oddity = "odd") #set( $oddity = "odd")
#end #end
<tr class="$oddity"> <tr class="$oddity">
<xsl:for-each select="field"> <xsl:for-each select="a:field">
<xsl:variable name="fieldprop" select="@property"/> <xsl:variable name="fieldprop" select="@property"/>
<td> <td>
<xsl:choose> <xsl:choose>
<xsl:when test="//entity[@name=$farent]/property[@name=$fieldprop]/@type='entity'"> <xsl:when test="//a:entity[@name=$farent]/a:property[@name=$fieldprop]/@type='entity'">
#if ( $item.<xsl:value-of select="@property"/>) #if ( $item.<xsl:value-of select="@property"/>)
$item.<xsl:value-of select="@property"/>.UserIdentifier $item.<xsl:value-of select="@property"/>.UserIdentifier
#end #end
</xsl:when> </xsl:when>
<xsl:when test="//entity[@name=$farent]/property[@name=$fieldprop]/option"> <xsl:when test="//a:entity[@name=$farent]/a:property[@name=$fieldprop]/option">
<!-- if we can get a prompt value for the option, it would be better to <!-- if we can get a prompt value for the option, it would be better to
show it than the raw value--> show it than the raw value-->
<xsl:for-each select="//entity[@name=$farent]/property[@name=$fieldprop]/option"> <xsl:for-each select="//a:entity[@name=$farent]/a:property[@name=$fieldprop]/a:option">
#if ( $item.<xsl:value-of select="$fieldprop"/> == '<xsl:value-of select="@value"/>') #if ( $item.<xsl:value-of select="$fieldprop"/> == '<xsl:value-of select="@value"/>')
<xsl:call-template name="showprompt"> <xsl:call-template name="showprompt">
<xsl:with-param name="fallback" select="@value"/> <xsl:with-param name="fallback" select="@value"/>
@ -434,11 +438,11 @@
<!-- properties not listed, so therefore presumably all. TODO: This won't work, rewrite. Need to <!-- properties not listed, so therefore presumably all. TODO: This won't work, rewrite. Need to
find the entity of the property this auxlist depends on, and then interrogate that --> find the entity of the property this auxlist depends on, and then interrogate that -->
<tr> <tr>
<xsl:for-each select="ancestor::entity/property[@distinct='user']"> <xsl:for-each select="ancestor::a:entity/a:property[@distinct='user']">
<th> <th>
<xsl:choose> <xsl:choose>
<xsl:when test="prompt[@locale=$locale]"> <xsl:when test="a:prompt[@lang=$lang]">
<xsl:value-of select="prompt[@locale=$locale]/@prompt"/> <xsl:value-of select="a:prompt[@lang=$lang]/@prompt"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:value-of select="@name"/> <xsl:value-of select="@name"/>
@ -455,7 +459,7 @@
#set( $oddity = "odd") #set( $oddity = "odd")
#end #end
<tr class="$oddity"> <tr class="$oddity">
<xsl:for-each select="ancestor::entity/property[@distinct='user']"> <xsl:for-each select="ancestor::a:entity/a:property[@distinct='user']">
<td> <td>
$!instance.<xsl:value-of select="@name"/> $!instance.<xsl:value-of select="@name"/>
</td> </td>
@ -474,7 +478,7 @@
</xsl:choose> </xsl:choose>
</xsl:template> </xsl:template>
<xsl:template match="verb"> <xsl:template match="a:verb">
<xsl:variable name="class"> <xsl:variable name="class">
<xsl:choose> <xsl:choose>
<xsl:when test="@dangerous='true'">actionDangerous</xsl:when> <xsl:when test="@dangerous='true'">actionDangerous</xsl:when>
@ -487,7 +491,7 @@
<xsl:attribute name="class"> <xsl:attribute name="class">
<xsl:value-of select="$class"/> <xsl:value-of select="$class"/>
</xsl:attribute> </xsl:attribute>
<xsl:apply-templates select="help[@locale = $locale]"/> <xsl:apply-templates select="a:help[@lang = $lang]"/>
</td> </td>
<td style="text-align:right"> <td style="text-align:right">
<xsl:attribute name="class"> <xsl:attribute name="class">
@ -505,14 +509,14 @@
</tr> </tr>
</xsl:template> </xsl:template>
<xsl:template match="field"> <xsl:template match="a:field">
<xsl:variable name="propname"> <xsl:variable name="propname">
<xsl:value-of select="@property"/> <xsl:value-of select="@property"/>
</xsl:variable> </xsl:variable>
<xsl:choose> <xsl:choose>
<xsl:when test="ancestor::entity/property[@name=$propname]"> <xsl:when test="ancestor::a:entity/a:property[@name=$propname]">
<!-- there is a real property --> <!-- there is a real property -->
<xsl:apply-templates select="ancestor::entity/property[@name=$propname]"> <xsl:apply-templates select="ancestor::a:entity/a:property[@name=$propname]">
<xsl:with-param name="oddness"> <xsl:with-param name="oddness">
<xsl:choose> <xsl:choose>
<xsl:when test="position() mod 2 = 0">even</xsl:when> <xsl:when test="position() mod 2 = 0">even</xsl:when>
@ -528,12 +532,12 @@
</xsl:choose> </xsl:choose>
</xsl:template> </xsl:template>
<xsl:template match="property[@type='link']"> <xsl:template match="a:property[@type='link']">
<!-- note! this template is only intended to match properties in the context of a form: <!-- note! this template is only intended to match properties in the context of a form:
it may be we need to add a mode to indicate this! --> it may be we need to add a mode to indicate this! -->
<!-- for links we implement a shuffle widget, which extends over both columns --> <!-- for links we implement a shuffle widget, which extends over both columns -->
<!-- TODO: Permissions! --> <!-- TODO: Permissions! -->
<xsl:param name="oddness" select="odd"/> <xsl:param name="oddness" select="a:odd"/>
<tr> <tr>
<xsl:attribute name="class"> <xsl:attribute name="class">
<xsl:value-of select="$oddness"/> <xsl:value-of select="$oddness"/>
@ -580,24 +584,24 @@
</xsl:choose> </xsl:choose>
</xsl:attribute> </xsl:attribute>
<td class="help" colspan="2"> <td class="help" colspan="2">
<xsl:apply-templates select="help[@locale = $locale]"/> <xsl:apply-templates select="a:help[@lang = $lang]"/>
</td> </td>
</tr> </tr>
</xsl:template> </xsl:template>
<xsl:template match="property[@type='text']"> <xsl:template match="a:property[@type='text']">
<!-- note! this template is only intended to match properties in the context of a form: <!-- note! this template is only intended to match properties in the context of a form:
it may be we need to add a mode to indicate this! --> it may be we need to add a mode to indicate this! -->
<!-- text box widgets, like shuffle widgets, extend over both columns --> <!-- text box widgets, like shuffle widgets, extend over both columns -->
<!-- TODO: Permissions! --> <!-- TODO: Permissions! -->
<xsl:param name="oddness" select="odd"/> <xsl:param name="oddness" select="a:odd"/>
<xsl:variable name="if-missing"> <xsl:variable name="if-missing">
<xsl:choose> <xsl:choose>
<xsl:when test="if-missing[@locale = $locale]"> <xsl:when test="a:if-missing[@lang = $lang]">
<xsl:value-of select="if-missing[@locale = $locale]"/> <xsl:value-of select="a:if-missing[@lang = $lang]"/>
</xsl:when> </xsl:when>
<xsl:when test="required='true'">You must provide a value for <xsl:value-of select="@name"/></xsl:when> <xsl:when test="@required='true'">You must provide a value for <xsl:value-of select="@name"/></xsl:when>
<xsl:otherwise>Enter a value for <xsl:value-of select="@name"/></xsl:otherwise> <xsl:otherwise>Enter a value for <xsl:value-of select="@name"/></xsl:otherwise>
</xsl:choose> </xsl:choose>
</xsl:variable> </xsl:variable>
@ -607,8 +611,8 @@
</xsl:attribute> </xsl:attribute>
<td class="label" rowspan="2"> <td class="label" rowspan="2">
${FormHelper.LabelFor( "instance.<xsl:value-of select="@name"/>", "<xsl:choose> ${FormHelper.LabelFor( "instance.<xsl:value-of select="@name"/>", "<xsl:choose>
<xsl:when test="prompt[@locale = $locale]"> <xsl:when test="a:prompt[@lang = $lang]">
<xsl:apply-templates select="prompt[@locale = $locale]"/> <xsl:apply-templates select="a:prompt[@lang = $lang]"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:value-of select="@name"/> <xsl:value-of select="@name"/>
@ -627,13 +631,13 @@
</xsl:choose> </xsl:choose>
</xsl:attribute> </xsl:attribute>
<td class="help" colspan="2"> <td class="help" colspan="2">
<xsl:apply-templates select="help[@locale = $locale]"/> <xsl:apply-templates select="a:help[@lang = $lang]"/>
</td> </td>
</tr> </tr>
</xsl:template> </xsl:template>
<xsl:template match="property"> <xsl:template match="a:property">
<xsl:param name="oddness" select="odd"/> <xsl:param name="oddness" select="a:odd"/>
<!-- note! this template is only intended to match properties in the context of a form: <!-- note! this template is only intended to match properties in the context of a form:
it may be we need to add a mode to indicate this! --> it may be we need to add a mode to indicate this! -->
<!-- TODO: This really needs to be refactored --> <!-- TODO: This really needs to be refactored -->
@ -645,8 +649,8 @@
important! --> important! -->
<xsl:variable name="if-missing"> <xsl:variable name="if-missing">
<xsl:choose> <xsl:choose>
<xsl:when test="if-missing[@locale = $locale]"> <xsl:when test="a:if-missing[@lang = $lang]">
<xsl:value-of select="if-missing[@locale = $locale]"/> <xsl:value-of select="a:if-missing[@lang = $lang]"/>
</xsl:when> </xsl:when>
<xsl:when test="@required='true'"> <xsl:when test="@required='true'">
You must provide a value for <xsl:value-of select="@name"/> You must provide a value for <xsl:value-of select="@name"/>
@ -668,11 +672,11 @@
Helper class? --> Helper class? -->
<xsl:variable name="permission"> <xsl:variable name="permission">
<xsl:choose> <xsl:choose>
<xsl:when test="permission"> <xsl:when test="a:permission">
<xsl:value-of select="permission[position()=1]/@permission"/> <xsl:value-of select="a:permission[position()=1]/@permission"/>
</xsl:when> </xsl:when>
<xsl:when test="../permission"> <xsl:when test="../a:permission">
<xsl:value-of select="../permission[position()=1]/@permission"/> <xsl:value-of select="../a:permission[position()=1]/@permission"/>
</xsl:when> </xsl:when>
<xsl:otherwise>edit</xsl:otherwise> <xsl:otherwise>edit</xsl:otherwise>
</xsl:choose> </xsl:choose>
@ -720,25 +724,26 @@
<!-- a multi-select menu of the appropriate entity --> <!-- a multi-select menu of the appropriate entity -->
${FormHelper.Select( "instance.<xsl:value-of select="@name"/>", $instance.<xsl:value-of select="@name"/>, <xsl:value-of select="concat( '$all_', @name)"/>, "%{multiple='multiple' size='8' text='UserIdentifier' value='<xsl:value-of select="concat( '', 'Id')"/>' title='<xsl:value-of select="normalize-space( $if-missing)"/>'}" )} ${FormHelper.Select( "instance.<xsl:value-of select="@name"/>", $instance.<xsl:value-of select="@name"/>, <xsl:value-of select="concat( '$all_', @name)"/>, "%{multiple='multiple' size='8' text='UserIdentifier' value='<xsl:value-of select="concat( '', 'Id')"/>' title='<xsl:value-of select="normalize-space( $if-missing)"/>'}" )}
</xsl:when> </xsl:when>
<!-- **** Change all this to use type-attr template. -->
<xsl:when test="@type='defined'"> <xsl:when test="@type='defined'">
<!-- likely to be hardest of all... --> <!-- likely to be hardest of all... -->
<xsl:variable name="definition"> <xsl:variable name="definition">
<xsl:value-of select="@definition"/> <xsl:value-of select="@definition"/>
</xsl:variable> </xsl:variable>
<xsl:variable name="maximum"> <xsl:variable name="maximum">
<xsl:value-of select="/application/definition[@name=$definition]/@maximum"/> <xsl:value-of select="/a:application/a:definition[@name=$definition]/@maximum"/>
</xsl:variable> </xsl:variable>
<xsl:variable name="minimum"> <xsl:variable name="minimum">
<xsl:value-of select="/application/definition[@name=$definition]/@minimum"/> <xsl:value-of select="/a:application/a:definition[@name=$definition]/@minimum"/>
</xsl:variable> </xsl:variable>
<xsl:variable name="validationpattern"> <xsl:variable name="validationpattern">
<xsl:value-of select="/application/definition[@name=$definition]/@pattern"/> <xsl:value-of select="/a:application/a:definition[@name=$definition]/@pattern"/>
</xsl:variable> </xsl:variable>
<xsl:variable name="definedtype"> <xsl:variable name="definedtype">
<xsl:value-of select="/application/definition[@name=$definition]/@type"/> <xsl:value-of select="/a:application/a:definition[@name=$definition]/@type"/>
</xsl:variable> </xsl:variable>
<xsl:variable name="definedsize"> <xsl:variable name="definedsize">
<xsl:value-of select="/application/definition[@name=$definition]/@size"/> <xsl:value-of select="/a:application/a:definition[@name=$definition]/@size"/>
</xsl:variable> </xsl:variable>
<input type="text"> <input type="text">
<xsl:attribute name="class"> <xsl:attribute name="class">
@ -756,25 +761,18 @@
<xsl:attribute name="name"> <xsl:attribute name="name">
<xsl:value-of select="concat( 'instance.', @name)"/> <xsl:value-of select="concat( 'instance.', @name)"/>
</xsl:attribute> </xsl:attribute>
<xsl:choose> <xsl:attribute name="size">
<xsl:when test="$definedsize &lt; 60"> <xsl:choose>
<xsl:attribute name="size"> <xsl:when test="$definedsize &lt; 60"><xsl:value-of select="$definedsize"/></xsl:when>
<xsl:value-of select="$definedsize"/> <xsl:otherwise>60</xsl:otherwise>
</xsl:attribute> </xsl:choose>
<xsl:attribute name="maxlength"> </xsl:attribute>
<xsl:value-of select="$definedsize"/> <xsl:attribute name="maxlength">
</xsl:attribute> <xsl:value-of select="$definedsize"/>
</xsl:when> </xsl:attribute>
<xsl:when test="$definedsize &gt;= 60"> <xsl:attribute name="value">
<xsl:attribute name="size"> $!instance.<xsl:value-of select="@name"/>
<xsl:value-of select="60"/> </xsl:attribute>
</xsl:attribute>
<xsl:attribute name="maxlength">
<xsl:value-of select="$definedsize"/>
</xsl:attribute>
</xsl:when>
</xsl:choose>
<xsl:attribute name="value">$!instance.<xsl:value-of select="@name"/></xsl:attribute>
<xsl:attribute name="title"> <xsl:attribute name="title">
<xsl:value-of select="normalize-space( $if-missing)"/> <xsl:value-of select="normalize-space( $if-missing)"/>
</xsl:attribute> </xsl:attribute>
@ -799,14 +797,14 @@
<script type="text/javascript" language="javascript"> <script type="text/javascript" language="javascript">
// &lt;![CDATA[ // &lt;![CDATA[
new Control.Slider('<xsl:value-of select="@name"/>-slider','<xsl:value-of select="@name"/>-track',{ new Control.Slider('<xsl:value-of select="@name"/>-slider','<xsl:value-of select="@name"/>-track',{
onSlide:function(v){$('<xsl:value-of select="concat( 'instance_', @name)"/>').value = <xsl:value-of select="$minimum"/>+ Math.floor(v*(<xsl:value-of select="$maximum - $minimum"/>))} onSlide:function(v){$('<xsl:value-of select="concat( 'instance_', @name)"/>').value = <xsl:value-of select="$minimum"/>+ Math.floor(v*(<xsl:value-of select="$maximum - $minimum"/>))}
}) })
// ]]&gt; // ]]&gt;
</script> </script>
</xsl:if> </xsl:if>
<!-- TODO: generate javascript to do client-side validation --> <!-- TODO: generate javascript to do client-side validation -->
</xsl:when> </xsl:when>
<xsl:when test="option"> <xsl:when test="a:option">
<!-- if a property has options, we definitely want a select widget--> <!-- if a property has options, we definitely want a select widget-->
<select> <select>
<xsl:attribute name="id"> <xsl:attribute name="id">
@ -818,7 +816,7 @@
<xsl:attribute name="title"> <xsl:attribute name="title">
<xsl:value-of select="normalize-space( $if-missing)"/> <xsl:value-of select="normalize-space( $if-missing)"/>
</xsl:attribute> </xsl:attribute>
<xsl:apply-templates select="option"/> <xsl:apply-templates select="a:option"/>
</select> </select>
<script type="text/javascript" language="javascript"> <script type="text/javascript" language="javascript">
#set ( <xsl:value-of select="concat( '$', @name, '_sel_opt')"/>="<xsl:value-of select="concat( @name, '-$instance.', @name)"/>") #set ( <xsl:value-of select="concat( '$', @name, '_sel_opt')"/>="<xsl:value-of select="concat( @name, '-$instance.', @name)"/>")
@ -861,28 +859,28 @@
</xsl:choose> </xsl:choose>
</td> </td>
<td class="help"> <td class="help">
<xsl:apply-templates select="help[@locale = $locale]"/> <xsl:apply-templates select="a:help[@lang = $lang]"/>
</td> </td>
</tr> </tr>
</xsl:template> </xsl:template>
<xsl:template match="prompt"> <xsl:template match="a:prompt">
<xsl:value-of select="@prompt"/> <xsl:value-of select="@prompt"/>
</xsl:template> </xsl:template>
<xsl:template match="help"> <xsl:template match="a:help">
<xsl:apply-templates/> <xsl:apply-templates/>
</xsl:template> </xsl:template>
<xsl:template match="option"> <xsl:template match="a:option">
<option> <option>
<xsl:attribute name="id"><xsl:value-of select="../@name"/>-<xsl:value-of select="@value"/></xsl:attribute> <xsl:attribute name="id"><xsl:value-of select="../@name"/>-<xsl:value-of select="@value"/></xsl:attribute>
<xsl:attribute name="value"> <xsl:attribute name="value">
<xsl:value-of select="@value"/> <xsl:value-of select="@value"/>
</xsl:attribute> </xsl:attribute>
<xsl:choose> <xsl:choose>
<xsl:when test="prompt[@locale=$locale]"> <xsl:when test="a:prompt[@lang=$lang]">
<xsl:value-of select="prompt[@locale=$locale]/@prompt"/> <xsl:value-of select="a:prompt[@lang=$lang]/@prompt"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:value-of select="@value"/> <xsl:value-of select="@value"/>
@ -893,7 +891,7 @@
<!-- layout of lists --> <!-- layout of lists -->
<xsl:template match="list"> <xsl:template match="a:list">
<xsl:variable name="action" select="@onselect"/> <xsl:variable name="action" select="@onselect"/>
<xsl:text> <xsl:text>
</xsl:text> </xsl:text>
@ -958,11 +956,11 @@
#if($instances.HasLast) $PaginationHelper.CreatePageLink( $instances.LastIndex, "&gt;&gt;" ) #end #if($instances.HasLast) $PaginationHelper.CreatePageLink( $instances.LastIndex, "&gt;&gt;" ) #end
#if(!$instances.HasLast) &gt;&gt; #end #if(!$instances.HasLast) &gt;&gt; #end
</span> </span>
<xsl:if test="../form"> <xsl:if test="../a:form">
<span class="add"> <span class="add">
<a> <a>
<xsl:attribute name="href"> <xsl:attribute name="href">
<xsl:value-of select="concat( ../form[position() = 1]/@name, '.rails')"/> <xsl:value-of select="concat( ../a:form[position() = 1]/@name, '.rails')"/>
</xsl:attribute> </xsl:attribute>
Add a new <xsl:value-of select="../@name"/> Add a new <xsl:value-of select="../@name"/>
</a> </a>
@ -983,13 +981,13 @@
<xsl:choose> <xsl:choose>
<xsl:when test="@properties='listed'"> <xsl:when test="@properties='listed'">
<tr> <tr>
<xsl:for-each select="field"> <xsl:for-each select="a:field">
<th> <th>
<xsl:variable name="pname" select="@property"/> <xsl:variable name="pname" select="@property"/>
<xsl:variable name="property" select="ancestor::entity/property[@name=$pname]"/> <xsl:variable name="property" select="ancestor::a:entity/a:property[@name=$pname]"/>
<xsl:choose> <xsl:choose>
<xsl:when test="$property/prompt[@locale=$locale]"> <xsl:when test="$property/a:prompt[@lang=$lang]">
<xsl:value-of select="$property/prompt[@locale=$locale]/@prompt"/> <xsl:value-of select="$property/a:prompt[@lang=$lang]/@prompt"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:value-of select="@property"/> <xsl:value-of select="@property"/>
@ -1006,7 +1004,7 @@
#set( $oddity = "odd") #set( $oddity = "odd")
#end #end
<tr class="$oddity"> <tr class="$oddity">
<xsl:for-each select="field"> <xsl:for-each select="a:field">
<td> <td>
$!instance.<xsl:value-of select="@property"/> $!instance.<xsl:value-of select="@property"/>
</td> </td>
@ -1024,11 +1022,11 @@
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<tr> <tr>
<xsl:for-each select="ancestor::entity/property[@distinct='user']"> <xsl:for-each select="ancestor::a:entity/a:property[@distinct='user']">
<th> <th>
<xsl:choose> <xsl:choose>
<xsl:when test="prompt[@locale=$locale]"> <xsl:when test="a:prompt[@lang=$lang]">
<xsl:value-of select="prompt[@locale=$locale]/@prompt"/> <xsl:value-of select="a:prompt[@lang=$lang]/@prompt"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:value-of select="@name"/> <xsl:value-of select="@name"/>
@ -1045,7 +1043,7 @@
#set( $oddity = "odd") #set( $oddity = "odd")
#end #end
<tr class="$oddity"> <tr class="$oddity">
<xsl:for-each select="ancestor::entity/property[@distinct='user']"> <xsl:for-each select="ancestor::a:entity/a:property[@distinct='user']">
<td> <td>
$!instance.<xsl:value-of select="@name"/> $!instance.<xsl:value-of select="@name"/>
</td> </td>
@ -1073,49 +1071,49 @@
<xsl:template name="head"> <xsl:template name="head">
<xsl:choose> <xsl:choose>
<xsl:when test="head"> <xsl:when test="a:head">
<xsl:apply-templates select="head/*"/> <xsl:apply-templates select="a:head/*"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:apply-templates select="/application/content/head/*"/> <xsl:apply-templates select="/a:application/a:content/a:head/*"/>
</xsl:otherwise> </xsl:otherwise>
</xsl:choose> </xsl:choose>
</xsl:template> </xsl:template>
<xsl:template name="top"> <xsl:template name="top">
<xsl:choose> <xsl:choose>
<xsl:when test="top"> <xsl:when test="a:top">
<xsl:apply-templates select="top/*"/> <xsl:apply-templates select="a:top/*"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:apply-templates select="/application/content/top/*"/> <xsl:apply-templates select="/a:application/a:content/a:top/*"/>
</xsl:otherwise> </xsl:otherwise>
</xsl:choose> </xsl:choose>
</xsl:template> </xsl:template>
<xsl:template name="foot"> <xsl:template name="foot">
<xsl:choose> <xsl:choose>
<xsl:when test="foot"> <xsl:when test="a:foot">
<xsl:apply-templates select="foot/*"/> <xsl:apply-templates select="a:foot/*"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:apply-templates select="/application/content/foot/*"/> <xsl:apply-templates select="/a:application/a:content/a:foot/*"/>
</xsl:otherwise> </xsl:otherwise>
</xsl:choose> </xsl:choose>
</xsl:template> </xsl:template>
<!-- if this node (default to current node) has a child of type prompt for the current locale, <!-- if this node (default to current node) has a child of type prompt for the current locale,
show that prompt; else show the first prompt child with locale='default' if any; show that prompt; else show the first prompt child with lang='default' if any;
else show the value of the fallback param --> else show the value of the fallback param -->
<xsl:template name="showprompt"> <xsl:template name="showprompt">
<xsl:param name="fallback" select="Unknown"/> <xsl:param name="fallback" select="Unknown"/>
<xsl:param name="node" select="."/> <xsl:param name="node" select="."/>
<xsl:choose> <xsl:choose>
<xsl:when test="$node/prompt[@locale=$locale]"> <xsl:when test="$node/a:prompt[@lang=$lang]">
<xsl:value-of select="$node/prompt[@locale=$locale][1]/@prompt"/> <xsl:value-of select="$node/a:prompt[@lang=$lang][1]/@prompt"/>
</xsl:when> </xsl:when>
<xsl:when test="$node/prompt[@locale='default']"> <xsl:when test="$node/a:prompt[@lang='default']">
<xsl:value-of select="$node/prompt[@locale='default'][1]/@prompt"/> <xsl:value-of select="$node/a:prompt[@lang='default'][1]/@prompt"/>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
<xsl:value-of select="$fallback"/> <xsl:value-of select="$fallback"/>

0
ADL.NET/Trans/datadescriber.xsl → transforms/datadescriber.xslt
View file

45
ADL.NET/Trans/hibernate2adl.xsl → transforms/hibernate2adl.xslt
View file

@ -13,7 +13,7 @@
is not sufficiently rich. is not sufficiently rich.
$Author: af $ $Author: af $
$Revision: 1.2 $ $Revision: 1.1 $
--> -->
<xsl:output indent="yes" method="xml" encoding="utf-8" <xsl:output indent="yes" method="xml" encoding="utf-8"
@ -34,9 +34,14 @@
<xsl:with-param name="full" select="@name"/> <xsl:with-param name="full" select="@name"/>
</xsl:call-template> </xsl:call-template>
</xsl:attribute> </xsl:attribute>
<xsl:if test="@table">
<xsl:attribute name="table">
<xsl:value-of select="@table"/>
</xsl:attribute>
</xsl:if>
<xsl:apply-templates/> <xsl:apply-templates/>
<form name="edit" properties="listed"> <form name="edit" properties="listed">
<xsl:for-each select="h:property|h:composite-id/*"> <xsl:for-each select="h:property|h:composite-id/*|h:many-to-one">
<field> <field>
<xsl:attribute name="property"> <xsl:attribute name="property">
<xsl:value-of select="@name"/> <xsl:value-of select="@name"/>
@ -58,6 +63,27 @@
</entity> </entity>
</xsl:template> </xsl:template>
<xsl:template match="h:id">
<key name="primary">
<property distinct="system" required="true">
<xsl:attribute name="name">
<xsl:value-of select="@name"/>
</xsl:attribute>
<xsl:attribute name="type">
<xsl:call-template name="type-attr">
<xsl:with-param name="t" select="@type" />
</xsl:call-template>
</xsl:attribute>
</property>
</key>
</xsl:template>
<xsl:template match="h:composite-id">
<key name="primary">
<xsl:apply-templates select="*"/>
</key>
</xsl:template>
<xsl:template match="h:property|h:key-property"> <xsl:template match="h:property|h:key-property">
<property> <property>
<xsl:attribute name="name"> <xsl:attribute name="name">
@ -70,7 +96,6 @@
</xsl:attribute> </xsl:attribute>
<xsl:choose> <xsl:choose>
<xsl:when test="contains(name(..),'composite-id')"> <xsl:when test="contains(name(..),'composite-id')">
<xsl:attribute name="distinct">system</xsl:attribute>
<xsl:attribute name="required">true</xsl:attribute> <xsl:attribute name="required">true</xsl:attribute>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>
@ -85,19 +110,6 @@
</property> </property>
</xsl:template> </xsl:template>
<xsl:template match="h:id">
<property distinct="system" required="true">
<xsl:attribute name="name">
<xsl:value-of select="@name"/>
</xsl:attribute>
<xsl:attribute name="type">
<xsl:call-template name="type-attr">
<xsl:with-param name="t" select="@type" />
</xsl:call-template>
</xsl:attribute>
</property>
</xsl:template>
<xsl:template name="type-attr"> <xsl:template name="type-attr">
<xsl:param name="t"/> <xsl:param name="t"/>
<xsl:choose> <xsl:choose>
@ -139,7 +151,6 @@
<xsl:choose> <xsl:choose>
<xsl:when test="contains(name(..),'composite-id')"> <xsl:when test="contains(name(..),'composite-id')">
<xsl:attribute name="distinct">system</xsl:attribute>
<xsl:attribute name="required">true</xsl:attribute> <xsl:attribute name="required">true</xsl:attribute>
</xsl:when> </xsl:when>
<xsl:otherwise> <xsl:otherwise>

15
transforms/types.xml Executable file
View file

@ -0,0 +1,15 @@
<types>
<type name="Integer-32" dotnet="Int32" sql="INTEGER" dotnet-kind="value" default="0" />
<type name="Real-64" dotnet="Double" sql="REAL" dotnet-kind="value" default="0.0"/>
<type name="Boolean" dotnet="Boolean" sql="BIT" dotnet-kind="value" default="false"/>
<type name="DateTime" dotnet="DateTime" sql="DATETIME" dotnet-kind="value" />
<type name="Date" dotnet="DateTime" sql="DATETIME" dotnet-kind="value" />
<type name="Time" dotnet="TimeSpan" sql="DECIMAL" dotnet-kind="value" />
<type name="Money" dotnet="Decimal" sql="MONEY" dotnet-kind="value" />
<type name="String" dotnet="String" sql="NVARCHAR" dotnet-kind="reference" />
<typedef name="Integer" type="Integer-32" />
<typedef name="Real" type="Real-64" />
</types>

74
transforms/types.xslt Executable file
View file

@ -0,0 +1,74 @@
<?xml version="1.0" encoding="utf-8" ?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns="http://cygnets.co.uk/schemas/adl-1.2"
xmlns:a="http://cygnets.co.uk/schemas/adl-1.2"
exclude-result-prefixes="a">
<!--
Application Description Framework
types.xslt
(c) 2008 Cygnet Solutions Ltd
Deals with looking up type information.
$Author: af $
$Revision: 1.1 $
-->
<xsl:output indent="yes" method="xml" encoding="utf-8"/>
<!-- Convenience (if you can use that word with XSLT) to obtain a type name. -->
<xsl:template name="type-name">
<xsl:call-template name="type-attr">
<xsl:with-param name="attr" select="'name'" />
</xsl:call-template>
</xsl:template>
<!-- Retrieve a particular attribute from a type, possibly recursively through typedefs. -->
<xsl:template name="type-attr">
<xsl:param name="attr"/>
<!-- The attribute we want-->
<xsl:choose>
<xsl:when test="name()='type'">
<xsl:value-of select="@*[name()=$attr]"/>
</xsl:when>
<!-- Can we can resolve this immediately? -->
<xsl:when test="$attr!='name' and @*[name()=$attr]">
<xsl:value-of select="@*[name()=$attr]"/>
</xsl:when>
<!-- Otherwise look it up in the referred type -->
<xsl:otherwise>
<xsl:variable name="typename" select="@type" />
<xsl:choose>
<!-- Look up in the source document -->
<xsl:when test="/a:application/a:type[@name=$typename]|/a:application/a:typedef[@name=$typename]">
<xsl:for-each select="/a:application/a:type[@name=$typename]|/a:application/a:typedef[@name=$typename]">
<xsl:call-template name="type-attr">
<xsl:with-param name="attr" select="$attr"/>
</xsl:call-template>
</xsl:for-each>
</xsl:when>
<!-- Look up in global types.xml -->
<xsl:when test="document('types.xml')/types/*[@name=$typename]">
<xsl:for-each select="document('types.xml')/types/*[@name=$typename]">
<xsl:call-template name="type-attr">
<xsl:with-param name="attr" select="$attr"/>
</xsl:call-template>
</xsl:for-each>
</xsl:when>
<!-- Cannot find the type -->
<xsl:otherwise>
<xsl:message terminate="yes">
Cannot find type "<xsl:value-of select="$typename"/>".
</xsl:message>
</xsl:otherwise>
</xsl:choose>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>