source: exist/trunk/xquery/mdip2moles.xq @ 3841

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/exist/trunk/xquery/mdip2moles.xq@4326
Revision 3841, 12.1 KB checked in by cbyrom, 11 years ago (diff)

Various updates to the xquery files - to remove usage of invalid specs
and dependency on obsolete function calls. Also add the inputParse_xquery_lib.xquery
file - referenced from the xquery files but not currently included in codebase.
NB, changes made to allow use of Saxon java library to do xqueries - to
remove the need for the discovery service eXist DB.

  • NB, also changes tested by comparing saxon transforms to eXist ones; these

were found to be identical.

Line 
1(: Version for one MDIP per dgMetadata instance :)
2(: Note algoritm for creating non-pre-existing organisations :)
3(: dgPersons are not created as one can't tell automatically which are people and which are orgs, and orgs are simpler :) 
4(: Not producing valid MOLES as still got to work out parameter vocabulary namespaces in the subject field :) 
5import module namespace voclib='http://ndg.nerc.ac.uk/xquery/lib/vocab' at 'xmldb:exist:///db/xqueryLib/Vocabs/vocab_xquery_lib.xquery';
6import module namespace inputParse='http://ndg.nerc.ac.uk/xquery/lib/inputParse' at 'xmldb:exist:///db/xqueryLib/Utilities/inputParse_xquery_lib.xquery';
7
8declare default element namespace 'http://ndg.nerc.ac.uk/moles';
9declare namespace xsi='http://www.w3.org/2001/XMLSchema-instance';
10declare namespace mdip='http://www.oceannet.org/mdip/xml';
11declare namespace gco='http://www.isotc211.org/2005/gco';
12
13declare variable $input_collection as xs:string := 'TargetCollection';
14declare variable $input_repository as xs:string := 'Input_Repository_Code';
15declare variable $input_repository_local as xs:string := 'Input_Repository_LocalID';
16declare variable $input_DatasetIdentifier as xs:string := 'Input_Entry_ID';
17declare variable $output_local_id as xs:string := 'Output_LocalID';
18
19for $MDIP in collection($input_collection)/mdip:Metadata[mdip:DatasetIdentifier=$input_DatasetIdentifier]
20return
21element dgMetadata {
22        element dgMetadataRecord {
23                element dgMetadataID {
24                        element schemeIdentifier {'NDG-B0'},
25                        element repositoryIdentifier {$input_repository},
26                        if ($output_local_id != 'Output_LocalID') then
27                                element localIdentifier {$output_local_id}
28                        else
29                                element localIdentifier {encode-for-uri(data($MDIP/mdip:DatasetIdentifier))}
30                },
31                element dgMetadataDescription {
32                        element metadataDescriptionID {
33                                element schemeIdentifier {'NDG-B0'},
34                                element repositoryIdentifier {$input_repository},
35                                if ($output_local_id != 'Output_LocalID') then
36                                        element localIdentifier {concat('generated_desc-', $output_local_id)}
37                                else
38                                        element localIdentifier {concat('generated_desc-', encode-for-uri(string($MDIP/mdip:DatasetIdentifier)))}
39                        },
40                        element metadataDescriptionLastUpdated {current-date()}                 ,
41                        element abstract {
42                                element abstractText {string($MDIP/mdip:Abstract)}
43                        }
44                },
45                element name {string($MDIP/mdip:Title)},
46                element abbreviation {string($MDIP/mdip:Title)},
47                element dgDataEntity {
48                        element dgDataSetType {''},
49                        element dgDataSummary {
50                                for $parameter in $MDIP/mdip:Subject[SubjectVocab=$voclib:bodc_parameter_discovery_vocab]
51                                return
52                                        element dgParameterSummary {
53                                                element dgParameterValue {
54                                                        element dgValueDataParameter {
55                                                                element Value {''},
56                                                                element dgStandardUnit {
57                                                                        element dgValidTerm {'dummy'},
58                                                                        element dgValidTermID {
59                                                                                element ParentListID {$voclib:unknown_vocab_id},
60                                                                                element TermID {encode-for-uri('dummy unit')}
61                                                                        }
62                                                                }
63                                                        }
64                                                },
65                                                element dgStdParameterMeasured {
66                                                element dgValidTerm {string($parameter/mdip:SubjectName)},
67                                                                element dgValidTermID {
68                                                                        element ParentListID {string($parameter/mdip:SubjectVocab)},
69                                                                        element TermID {string($parameter/mdip:SubjectCode)}
70                                                                }
71                                                },
72                                                element ParameterName {string($parameter/mdip:SubjectName)},
73                                                element ParameterAbbreviation {string($parameter/mdip:SubjectName)}
74                                        },
75                                element dgDataCoverage {
76                                                element dgSpatialCoverage {
77                                                        element BoundingBox {
78                                                        element LimitNorth {data(inputParse:fix-coord($MDIP/mdip:NorthCoOrdinate))},
79                                                        element LimitSouth {data(inputParse:fix-coord($MDIP/mdip:SouthCoOrdinate))},
80                                                        element LimitWest {data(inputParse:fix-coord($MDIP/mdip:WestCoOrdinate))},
81                                                        element LimitEast {data(inputParse:fix-coord($MDIP/mdip:EastCoOrdinate))}
82                                                        },
83                                                        for $location in $MDIP/mdip:Extent
84                                                        return
85                                                                element dgArea {
86                                                                        element dgValidTerm {string($location/mdip:ExtentName)},
87                                                                        element dgValidTermID {
88                                                                                element ParentListID {string($location/mdip:ExtentVocab)},
89                                                                                element TermID {string($location/mdip:ExtentCode)}
90                                                                        }
91                                                                },
92                                                        for $location in $MDIP/mdip:VerticalExtent
93                                                        return
94                                                                element dgVerticalExtent {
95                                                                        element dgVerticalExtentBaseRef {
96                                                                                element dgValidTerm {if (exists($location/VerticalDatum)) then $location/VerticalDatum else 'default'},
97                                                                                element dgValidTermID {
98                                                                                        element ParentListID {'$voclib:unknown_vocab_id'},
99                                                                                        element TermID {encode-for-uri(string($location/mdip:VerticalDatum))}
100                                                                                }
101                                                                        },
102                                                                        if (exists($location/mdip:Minimum) and exists($location/mdip:Maximum)) then
103                                                                                element dgVerticalExtentRange{
104                                                                                        element dgVerticalExtentRangeMin {data($location/mdip:Minimum)},
105                                                                                        element dgVerticalExtentRangeMax {data($location/mdip:Maximum)}
106                                                                                }
107                                                                        else
108                                                                                element dgVerticalExtentLevel{
109                                                                                        if (exists($location/mdip:Minimum)) then element dgVerticalExtentLevelValue {data($location/mdip:Minimum)}
110                                                                                        else element dgVerticalExtentLevelValue {data($location/mdip:Maximum)}
111                                                                                }
112                                                                }
113                                                } (: /dgSpatialCoverage :),
114                                                element dgTemporalCoverage {
115                                                (: didn't bother trying to validate the Dates as the example is naff to start with :)
116                                                        for $date in $MDIP/mdip:Date
117                                                        return
118                                                                if (exists($MDIP/mdip:Date/mdip:DatasetStartDate) and exists($MDIP/mdip:Date/mdip:DatasetEndDate) ) then
119                                                                        element DateRange {
120                                                                                element DateRangeStart {data($MDIP/mdip:Date/mdip:DatasetStartDate)},
121                                                                                element DateRangeEnd {data($MDIP/mdip:Date/mdip:DatasetEndDate)}
122                                                                        }
123                                                                else if (exists($MDIP/mdip:Date/mdip:DatasetStartDate)) then  element DateSingle {data($MDIP/mdip:Date/mdip:DatasetStartDate)}
124                                                                else element DateSingle {data($MDIP/mdip:Date/mdip:DatasetEndDate)}
125                                                                } (: /dgTemporalCoverage :)
126                                                        } (: /dgDataCoverage :),
127                                        if (exists($MDIP/mdip:DatasetRefDate)) then
128                                                element dgDatasetProvenance {element dgDataPublicationDate {data($MDIP/mdip:DatasetRefDate)}}
129                                        else ()
130                        } (: /dgDataSummary :),
131                        element dgDataRoles {
132                                if (exists($MDIP/mdip:Originator)) then
133                                        element dgDataCreator {
134                                                element dgMetadataID {
135                                                        element schemeIdentifier {'NDG-B0'},
136                                                        element repositoryIdentifier {$input_repository},
137                                                        if ($output_local_id != 'Output_LocalID') then
138                                                                element localIdentifier {concat('generated_creator-', $output_local_id)}
139                                                        else
140                                                                element localIdentifier {concat('generated_creator-', encode-for-uri(string($MDIP/mdip:DatasetIdentifier)))}
141                                                },
142                                                element roleName {'Data Creator'},
143                                                element abbreviation {'Creator'},
144                                                for $creator in $MDIP/mdip:Data_Set_Citation/mdip:Dataset_Creator
145                                                return
146                                                element dgRoleHolder {
147                                                        element dgOrganisationID {
148                                                                element schemeIdentifier {'NDG-B0'},
149                                                                element repositoryIdentifier {$input_repository},
150                                                                if ($output_local_id != 'Output_LocalID') then
151                                                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id))}
152                                                                else
153                                                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)))}
154                                                        },
155                                                element startDate {current-date()}
156                                                }
157                                        }
158                                else if (exists($MDIP/mdip:Originating_Center)) then
159                                        element dgDataCreator {
160                                                element dgMetadataID {
161                                                        element schemeIdentifier {'NDG-B0'},
162                                                        element repositoryIdentifier {$input_repository},
163                                                        if ($output_local_id != 'Output_LocalID') then
164                                                                element localIdentifier {concat('generated_creator-', $output_local_id)}
165                                                        else
166                                                                element localIdentifier {concat('generated_creator-', encode-for-uri(string($MDIP/mdip:DatasetIdentifier)))}
167                                                },
168                                                element roleName {'Data Creator'},
169                                                element abbreviation {'Creator'},
170                                                for $creator in $MDIP/mdip:Originating_Center
171                                                return
172                                                element dgRoleHolder {
173                                                        element dgOrganisationID {
174                                                                element schemeIdentifier {'NDG-B0'},
175                                                                element repositoryIdentifier {$input_repository},
176                                                                if ($output_local_id != 'Output_LocalID') then
177                                                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id))}
178                                                                else
179                                                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)))}
180                                                        },
181                                                element startDate {current-date()}
182                                                }
183                                        }
184                                else (),
185                                element dgDataCurator {
186                                        element dgMetadataID {
187                                                element schemeIdentifier {'NDG-B0'},
188                                                element repositoryIdentifier {$input_repository},
189                                                if ($output_local_id != 'Output_LocalID') then
190                                                        element localIdentifier {concat('generated_curator-', $output_local_id)}
191                                                else
192                                                        element localIdentifier {concat('generated_curator-', encode-for-uri(string($MDIP/mdip:DatasetIdentifier)))}
193                                        },
194                                        element roleName {'Data Curator'},
195                                        element abbreviation {'Curator'},
196                                        element dgRoleHolder {
197                                                element dgOrganisationID {
198                                                        element schemeIdentifier {'NDG-B0'},
199                                                        element repositoryIdentifier {$input_repository},
200                                                        element localIdentifier {$input_repository_local}
201                                                },
202                                        element startDate {current-date()}
203                                        }
204                                }
205                        } (: /dgDataRoles :)
206                } (: /dgDataEntity :),
207                element dgStructuredKeyword {
208                        element dgValidTerm {'d2b converted record'},
209                        element dgValidTermID {
210                                element ParentListID {$voclib:unknown_vocab_id},
211                                element TermID {'d2b'}
212                        }
213                },
214                for $structuredKeywords in $MDIP/mdip:TopicCategory
215                return
216                        element dgStructuredKeyword {
217                                element dgValidTerm {string($structuredKeywords/mdip:TopicCategory)},
218                                element dgValidTermID {
219                                        element ParentListID {data($structuredKeywords/mdip:TopicCategoryVocab)},
220                                        element TermID {data($structuredKeywords/mdip:TopicCategoryCode)}
221                                }
222                        },
223                for $structuredKeywords in $MDIP/mdip:Subject
224                return
225                        element dgStructuredKeyword {
226                                element dgValidTerm {string($structuredKeywords/mdip:SubjectName)},
227                                element dgValidTermID {
228                                        element ParentListID {data($structuredKeywords/mdip:SubjectVocab)},
229                                        element TermID {data($structuredKeywords/mdip:SubjectCode)}
230                                }
231                        },
232                for $structuredKeywords in $MDIP/mdip:Target
233                return
234                        element dgStructuredKeyword {
235                        element dgValidTerm {string($structuredKeywords/mdip:TargetName)},
236                        element dgValidTermID {
237                        element ParentListID {data($structuredKeywords/mdip:TargetVocab)},
238                        element TermID {data($structuredKeywords/mdip:TargetCode)}
239                        }
240                        },
241                        if (exists($MDIP/mdip:DateOfUpdateOfMetadata)) then
242                        element dgMetadataProvenance {
243                                if (exists($MDIP/mdip:DateOfUpdateOfMetadata)) then
244                                        element RecordCreation {
245                                                element CreatedDate {
246                                                        if (string($MDIP/mdip:DateOfUpdateOfMetadata) castable as xs:date) then
247                                                                string($MDIP/mdip:DateOfUpdateOfMetadata) cast as xs:date
248                                                        else (current-date())
249                                                },
250                                        element CreatedBy {$input_repository}
251                                        }
252                                else
253                                        element RecordCreation {
254                                                element CreatedDate {current-date()},
255                                                element CreatedBy {'MOLES Import'}
256                                        }
257                        } (: dgMetadataProvenance :)
258                else ()
259        } (: </dgMetadataRecord>:),
260        for $creator in $MDIP/mdip:Originator
261        return
262                element dgOrganisation {
263                (: needs expansion... :)
264                        element dgMetadataID {
265                                element schemeIdentifier {'NDG-B0'},
266                                element repositoryIdentifier {$input_repository},
267                                if ($output_local_id != 'Output_LocalID') then
268                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id))}
269                                else
270                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)))}
271                        },
272                        element name {data($creator/mdip:OriginatorName)},
273                        element abbreviation {data($creator/mdip:OriginatorName)},
274                        element contactDetails {''}
275                }
276}
277(:    </dgMetadata> :)
Note: See TracBrowser for help on using the repository browser.