D-Net

<!-- 

    (M): Mandatory

    (R): Reccomended

    (M w A): Mandatory when Applicable

-->

<xsl:stylesheet xmlns:dc="http://purl.org/dc/elements/1.1/"

    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

    xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/"

    xmlns:oaf="http://namespace.openaire.eu/oaf" version="2.0" exclude-result-prefixes="oaf">

    <xsl:output method="xml" indent="yes" omit-xml-declaration="yes"/>

    <xsl:variable name="openaireNamespace" select="string('oai:dnet:')"/>

    <xsl:template match="//oaf:entity">

        <oai_dc:dc xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

            xsi:schemaLocation="http://www.openarchives.org/OAI/2.0/oai_dc/ http://www.openarchives.org/OAI/2.0/oai_dc.xsd">

            <xsl:apply-templates/>

        </oai_dc:dc>

    </xsl:template>

    <!-- 

       Titles (M): based on title/@classname

        <dc:title>main title:subtitle</dc:title>

        <dc:title>alternative title</dc:title>

        <dc:title>translated title</dc:title>

        We have only "main title" for now: let's keep it simple here...

   -->

    <xsl:template match="oaf:result/title">

        <dc:title>

            <xsl:value-of select="normalize-space(./text())"/>

        </dc:title>

    </xsl:template>

    <!-- Creators (M) -->

    <xsl:template match="oaf:result//rel[./to/@class='hasAuthor']">

        <dc:creator>

            <xsl:value-of select="./fullname"/>

        </dc:creator>

    </xsl:template>

    <!-- Contributors (R) not currently available-->

    <xsl:template match="oaf:result//rel[./to/@class='hasContributor']">

        <dc:contributor>

            <xsl:value-of select="./fullname"/>

        </dc:contributor>

    </xsl:template>

    <!--

        projectId (M w A)

        <dc:relation>info:eu-repo/grantAgreement/Funder/FundingProgram/ProjectID/[Jurisdiction]/[ProjectName]/[ProjectAcronym]</dc:relation>

        <dc:relation>info:eu-repo/grantAgreement/EC/FP7/12345//The project name/ACRO</dc:relation>

        <dc:relation>info:eu-repo/grantAgreement/EC/FP7/67891/EU/The 2nd project name/ACRO2</dc:relation>

        The rel to project:

         <rel>

            <to scheme="dnet:result_project_relations" class="isProducedBy" type="project">project_openaireid</to>

            <code>249516</code>

            <acronym>VOICE</acronym>

            <title>xxx</title>

            <contracttype schemename="ec:FP7contractTypes" classname="aaa" schemeid="ec:FP7contractTypes" classid="aaa"/>

             <funding>

                <funding_level_0>FP7</funding_level_0>

                <funding_level_1>FP7::SP2</funding_level_1>

                <funding_level_2>FP7::SP2::ERC</funding_level_2>

             </funding>

        </rel>

        The funding program is funding_level_0.

        The funder must be inferred from the contract type - until the Funders won't be added explicitely in the record.

    -->

    <xsl:template match="oaf:result//rel[./to/@class='isProducedBy']">

        <xsl:variable name="funder">

            <xsl:choose>

                <xsl:when test="./contracttype/@schemeid = 'ec:FP7contractTypes'">

                    <xsl:value-of select="string('EC')"/>

                </xsl:when>

                <xsl:when test="./contracttype/@schemeid = 'wt:contractTypes'">

                    <xsl:value-of select="string('WT')"/>

                </xsl:when>

                <xsl:when test="./contracttype/@schemeid = 'fct:contractTypes'">

                    <xsl:value-of select="string('FCT')"/>

                </xsl:when>

            </xsl:choose>

        </xsl:variable>

        <xsl:variable name="fundingProgramme">

            <xsl:choose>

                <xsl:when test="$funder = 'EC'">

                    <xsl:value-of select="./funding/funding_level_0"/>

                </xsl:when>

                <xsl:when test="$funder = 'WT'">

                    <xsl:value-of select="substring-after(./funding_level_1/text(), 'WT::')"/>

                </xsl:when>

                <xsl:when test="$funder = 'FCT'">

                    <xsl:value-of select="substring-after(./funding_level_1/text(), 'FCT::')"/>

                </xsl:when>

            </xsl:choose>

        </xsl:variable>

        <xsl:variable name="jurisdiction">

            <xsl:choose>

                <xsl:when test="$funder = 'EC'">

                    <xsl:value-of select="string('EU')"/>

                </xsl:when>

                <xsl:when test="$funder = 'WT'">

                    <xsl:value-of select="string('')"/>

                </xsl:when>

                <xsl:when test="$funder = 'FCT'">

                    <xsl:value-of select="string('PT')"/>

                </xsl:when>

                <xsl:otherwise/>

            </xsl:choose>

        </xsl:variable>

        <dc:relation>

            <xsl:value-of

                select="concat('info:eu-repo/grantAgreement/', $funder, '/', $fundingProgramme, '/', ./code, '/', $jurisdiction, '/' , ./title, '/', ./acronym)"

            />

        </dc:relation>

    </xsl:template>

    <!-- 

        Access level (M) [from bestlicense@classid] : one of 

        <dc:rights>info:eu-repo/semantics/closedAccess</dc:rights>

        <dc:rights>info:eu-repo/semantics/embargoedAccess</dc:rights>

        <dc:rights>info:eu-repo/semantics/restrictedAccess</dc:rights>

        <dc:rights>info:eu-repo/semantics/openAccess</dc:rights>

    -->

    <xsl:template match="oaf:result/bestlicense">

        <xsl:variable name="license">

            <xsl:choose>

                <xsl:when test="@classid='OPEN'">

                    <xsl:value-of select="string('info:eu-repo/semantics/openAccess')"/>

                </xsl:when>

                <xsl:when test="@classid='CLOSED'">

                    <xsl:value-of select="string('info:eu-repo/semantics/closedAccess')"/>

                </xsl:when>

                <xsl:when test="@classid='RESTRICTED'">

                    <xsl:value-of select="string('info:eu-repo/semantics/restrictedAccess')"/>

                </xsl:when>

                <xsl:when test="@classid='EMBARGO'">

                    <xsl:value-of select="string('info:eu-repo/semantics/embargoedAccess')"/>

                </xsl:when>

                <xsl:otherwise>

                    <xsl:value-of select="string('info:eu-repo/semantics/closedAccess')"/>

                </xsl:otherwise>

            </xsl:choose>

        </xsl:variable>

        <dc:rights>

            <xsl:value-of select="$license"/>

        </dc:rights>

    </xsl:template>

    <!-- EmbargoEnd (M w A)  (only when rights == info:eu-repo/semantics/embargoedAccess), from embargoenddate

    <dc:date>info:eu-repo/date/embargoEnd/1960-01-01</dc:date>

     -->

    <xsl:template match="oaf:result/embargoenddate/text()">

        <dc:date>

            <xsl:value-of select="concat('info:eu-repo/date/embargoEnd/', .)"/>

        </dc:date>

    </xsl:template>

    <!--

    <xsl:template match="oaf:result/originalId/text()">

        <dc:identifier>

            <xsl:value-of select="normalize-space(.)"/>

        </dc:identifier>

    </xsl:template>

    -->

    <!-- Alternative Identifier (R), idType from pid@classid  

    <dc:relation>

        info:eu-repo/semantics/altIdentifier/[idType]/[ID]

    </dc:relation>

    -->

    <xsl:template match="oaf:result/pid[./text()]">

        <dc:relation>

            <xsl:value-of

                select="concat('info:eu-repo/semantics/altIdentifier/', @classid, '/', ./text())"/>

        </dc:relation>

    </xsl:template>

    <xsl:template match="oaf:result/children/instance/webresource/url/text()">

        <dc:identifier>

            <xsl:value-of select="."/>

        </dc:identifier>

    </xsl:template>

    <!--Referenced Publication (R), from extraInfo[@typology='citations']/citation, idType from citation/id/@type, ID from citation/id/@value

    <dc:relation>

        info:eu-repo/semantics/reference/[idType]/[ID]

    </dc:relation>

    <dc:relation>

        info:eu-repo/semantics/reference/doi/10.1234/789.1

    </dc:relation>

    <dc:relation>

        info:eu-repo/semantics/reference/pmid/1234567

    </dc:relation>

     -->

    <xsl:template match="extraInfo[@typology='citations']//citation/id[./@type]">

        <xsl:choose>

            <xsl:when test="@type='openaire'">

                <dc:relation>

                    <xsl:value-of

                        select="concat('info:eu-repo/semantics/reference/', @type, '/', $openaireNamespace, @value)"

                    />

                </dc:relation>

            </xsl:when>

            <xsl:otherwise>

                <dc:relation>

                    <xsl:value-of

                        select="concat('info:eu-repo/semantics/reference/', @type, '/', @value)"/>

                </dc:relation>

            </xsl:otherwise>

        </xsl:choose>

    </xsl:template>

    <!-- Dataset reference (R), from: rel[./resulttyype/@classname='dataset'] 

    <dc:relation>info:eu-repo/semantics/dataset/[idType]/[ID]</dc:relation>

    only available when we'll expand the PIDs in the relationship 

    <dc:relation>info:eu-repo/semantics/dataset/doi/10.1234/789.1</dc:relation>

    For now we can only use openaire ids, from  rel[./resulttyype/@classname='dataset']/to/text()

    <dc:relation>info:eu-repo/semantics/dataset/openaire/oai:dnet:[OPENAIRE_ID]</dc:relation>

    -->

    <xsl:template match="oaf:result//rel[./resulttype/@classid='dataset']">

        <dc:relation>

            <xsl:value-of

                select="concat('info:eu-repo/semantics/dataset/openaire/', $openaireNamespace, ./to/text())"

            />

        </dc:relation>

    </xsl:template>

    <!-- Subjects (M w A)

    <dc:subject>bag of words</dc:subject>

     If subject@classname != keywords, then we have a classification scheme to encode

    <dc:subject>info:eu-repo/classification/[scheme]/[value]</dc:subject>

    <dc:subject>info:eu-repo/classification/dcc/whatever</dc:subject>

    -->

    <xsl:template match="oaf:result/subject[@classname='keyword']">

        <dc:subject>

            <xsl:value-of select="normalize-space(./text())"/>

        </dc:subject>

    </xsl:template>

    <xsl:template match="oaf:result/subject[not(@classname='keyword') and @classid != '']">

        <dc:subject>

            <xsl:value-of

                select="concat('info:eu-repo/classification/', @classid, '/', normalize-space(./text()))"

            />

        </dc:subject>

    </xsl:template>

    <!--description (M w A) from description-->

    <xsl:template match="oaf:result/description/text()">

        <dc:description>

            <xsl:value-of select="normalize-space(.)"/>

        </dc:description>

    </xsl:template>

    <!--publisher (M w A) from publisher -->

    <xsl:template match="oaf:result/publisher/text()">

        <dc:publisher>

            <xsl:value-of select="normalize-space(.)"/>

        </dc:publisher>

    </xsl:template>

    <!-- Publication date (M) from dateofacceptance -->

    <xsl:template match="oaf:result/dateofacceptance/text()">

        <dc:date>

            <xsl:value-of select="normalize-space(.)"/>

        </dc:date>

    </xsl:template>

    <!-- 

        Publication type (M)  where [type] is /instancetype[1]/classname (dnet:publication_resource vocabulary). 

        A second dc:type (uncontrolled) can be used. 

        <dc:type>info:eu-repo/semantics/[type]</dc:type>

    -->

    <xsl:template match="oaf:result/children/instance/instancetype | oaf:result/resourcetype">

        <xsl:variable name="theInstanceType">

            <xsl:choose>

                <xsl:when test="@classname='Unknown'">

                    <xsl:value-of select="string('info:eu-repo/semantics/other')"/>

                </xsl:when>

                <xsl:when test="@classname=''">

                    <xsl:value-of select="string('info:eu-repo/semantics/other')"/>

                </xsl:when>

                <xsl:otherwise>

                    <xsl:call-template name="ConvertWordsToCamelCase">

                        <xsl:with-param name="text">

                            <xsl:value-of select="lower-case(./@classname)"/>

                        </xsl:with-param>

                    </xsl:call-template>

                </xsl:otherwise>

            </xsl:choose>

        </xsl:variable>

        <dc:type>

            <xsl:value-of select="concat('info:eu-repo/semantics/',$theInstanceType)"/>

        </dc:type>

    </xsl:template>

    <!--

    <xsl:template match="oaf:result/resulttype">

        <dc:type>

            <xsl:value-of select="./@classname"/>

        </dc:type>

    </xsl:template>

    -->

    <!-- Format (R), in theory from format, not sure we are filling it

    <dc:format>mediaType of the digital manifestation of the resource</dc:format>

    <dc:format>application/pdf</dc:format>

    -->

    <xsl:template match="oaf:result/format/text()">

        <dc:format>

            <xsl:value-of select="normalize-space(.)"/>

        </dc:format>

    </xsl:template>

    <!-- source (R) from source-->

    <xsl:template match="oaf:result/source/text()">

        <dc:source>

            <xsl:value-of select="normalize-space(.)"/>

        </dc:source>

    </xsl:template>

    <xsl:template match="oaf:result/collectedfrom">

        <dc:source>

            <xsl:value-of select="normalize-space(@name)"/>

        </dc:source>

    </xsl:template>

    <!-- Language (R) from language@classid -->

    <xsl:template match="oaf:result/language">

        <dc:language>

            <xsl:value-of select="./@classid"/>

        </dc:language>

    </xsl:template>

    <!-- Override default template -->

    <xsl:template match="text()|@*"/>

    <!-- =========================================================================== -->

    <!-- === Convert camel case text to cameCaseText  === -->

    <!-- === Modified from http://blog.inventic.eu/2013/08/xslt-snippet-to-convert-string-from-hyphens-to-camelcase/  === -->

    <!-- === (c) Inventic s.r.o. ORM Designer team (http://www.orm-designer.com) === -->

    <!-- =========================================================================== -->

    <xsl:template name="ConvertWordsToCamelCase">

        <xsl:param name="text"/>

        <xsl:param name="firstLower" select="true()"/>

        <xsl:variable name="Upper">ABCDEFGHIJKLMNOPQRSTUVQXYZ</xsl:variable>

        <xsl:variable name="Lower">abcdefghijklmnopqrstuvwxyz</xsl:variable>

        <xsl:for-each select="tokenize($text,' ')">

            <xsl:choose>

                <xsl:when test="position()=1 and $firstLower = true()">

                    <xsl:value-of select="substring(.,1,1)"/>

                </xsl:when>

                <xsl:otherwise>

                    <xsl:value-of select="translate(substring(.,1,1),$Lower,$Upper)"/>

                </xsl:otherwise>

            </xsl:choose>

            <xsl:value-of select="substring(.,2,string-length(.))"/>

        </xsl:for-each>

    </xsl:template>

</xsl:stylesheet>