source: TI07-MOLES/trunk/MDIP/XQueries/MDIP2MOLES.xquery @ 2026

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI07-MOLES/trunk/MDIP/XQueries/MDIP2MOLES.xquery@2026
Revision 2026, 14.3 KB checked in by ko23, 14 years ago (diff)

MDIP intermediate

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 :) 
5
6declare default element namespace 'http://ndg.nerc.ac.uk/moles';
7declare namespace xsi='http://www.w3.org/2001/XMLSchema-instance';
8declare namespace mdip='http://www.dassh.ac.uk';
9declare namespace gco='http://www.isotc211.org/2005/gco';
10declare namespace f='http://ndg.nerc.ac.uk/moles/localfunctions';
11declare variable $input_collection as xs:string {'TargetCollection'};
12
13declare variable $input_repository as xs:string {'Input_Repository_Code'};
14declare variable $input_repository_local as xs:string {'Input_Repository_LocalID'};
15declare variable $input_DatasetIdentifier as xs:string {'Input_Entry_ID'};
16declare variable $output_local_id as xs:string {'Output_LocalID'};
17
18declare variable $unknown_vocab_id as xs:string {'http://vocab.ndg.nerc.ac.uk/null'};
19
20declare variable $bodc_parameter_discovery_vocab as xs:string {'http://vocab.ndg.nerc.ac.uk/P021'};
21
22declare variable $cf_standard_names as xs:string {'http://www.cgd.ucar.edu/cms/eaton/cf-metadata/standard_name.html'};
23
24(: declare variable $gcmd_science_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/gcmd_parameters.html'}; :)
25declare variable $gcmd_science_valids as xs:string {'http://vocab.ndg.nerc.ac.uk/P041'};
26declare variable $gcmd_project_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/projects.html'};
27declare variable $gcmd_location_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/locations.html'};
28declare variable $gcmd_paleotemporal_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/paleotemporal.html'};
29declare variable $gcmd_iso_topic_list as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/iso_topic_list.html'};
30
31declare variable $iho_s23_list as xs:string {'http://vocab.ndg.nerc.ac.uk/C161'};
32
33(: declare variable $iso_topic_list as xs:string {'http://www.isotc211.org/2005/resources/Codelist/gmxCodelists.xml#MD_TopicCategoryCode'}; :)
34declare variable $iso_topic_list as xs:string {'http://vocab.ndg.nerc.ac.uk/P051'};
35declare variable $ISO_639-2_ns as xs:string{'UKGemini_Langauge_Categories'};
36declare variable $ISO_3166_ns as xs:string{'UKGemini_Land_Area_Categories'};
37
38declare variable $ndg_data_provider_vocab as xs:string {'http://vocab.ndg.nerc.ac.uk/N010'};
39declare variable $ndg_vertical_extent_base as xs:string {'http://vocab.ndg.nerc.ac.uk/null'};
40
41declare function f:fix-coord($e as element()) as element()
42(: Parse a non-decimal co-ordinate element,  parse to see if it's possible to convert to
43    a decimal co-ordinate, and do so, else return the rubbish provided :)
44{
45if ($e castable as xs:decimal) then 
46        $e
47else
48        let $value := substring(data($e), 1, string-length($e)-1)
49        let $point := lower-case(data($e))
50        return
51        if ($value  castable as xs:decimal) then 
52                if (ends-with($point, 'n')) then
53                        element {name($e)} {$value}
54                else if (ends-with($point, 's')) then
55                        element {name($e)} {concat('-', $value)}
56                else if (ends-with($point, 'e')) then
57                        element {name($e)} {$value}
58                else if (ends-with($point, 'w')) then
59                        element {name($e)} {concat('-', $value)}
60                else $e
61        else  $e
62} ;
63
64for $MDIP in collection($input_collection)/mdip:Metadata[mdip:DatasetIdentifier=$input_DatasetIdentifier]
65return
66element dgMetadata {
67        element dgMetadataRecord {
68                element dgMetadataID {
69                        element schemeIdentifier {'NDG-B0'},
70                        element repositoryIdentifier {$input_repository},
71                        if ($output_local_id != 'Output_LocalID') then
72                                element localIdentifier {$output_local_id}
73                        else
74                                element localIdentifier {escape-uri(data($MDIP/mdip:DatasetIdentifier), true())}
75                },
76                element dgMetadataDescription {
77                        element metadataDescriptionID {
78                                element schemeIdentifier {'NDG-B0'},
79                                element repositoryIdentifier {$input_repository},
80                                if ($output_local_id != 'Output_LocalID') then
81                                        element localIdentifier {concat('generated_desc-', $output_local_id)}
82                                else
83                                        element localIdentifier {concat('generated_desc-', escape-uri(string($MDIP/mdip:DatasetIdentifier), true()))}
84                        },
85                        element metadataDescriptionLastUpdated {current-date()}                 ,
86                        element abstract {
87                                element abstractText {string($MDIP/mdip:Abstract)}
88                        }
89                },
90                element name {string($MDIP/mdip:Title)},
91                element abbreviation {string($MDIP/mdip:Title)},
92                element dgDataEntity {
93                        element dgDataSetType {''},
94                        element dgDataSummary {
95                                for $parameter in $MDIP/mdip:Subject[SubjectVocab=$bodc_parameter_discovery_vocab]
96                                return
97                                        element dgParameterSummary {
98                                                element dgParameterValue {
99                                                        element dgValueDataParameter {
100                                                                element Value {''},
101                                                                element dgStandardUnit {
102                                                                        element dgValidTerm {'dummy'},
103                                                                        element dgValidTermID {
104                                                                                element ParentListID {$unknown_vocab_id},
105                                                                                element TermID {escape-uri('dummy unit', true())}
106                                                                        }
107                                                                }
108                                                        }
109                                                },
110                                                element dgStdParameterMeasured {
111                                                element dgValidTerm {string($parameter/mdip:SubjectName)},
112                                                                element dgValidTermID {
113                                                                        element ParentListID {string($parameter/mdip:SubjectVocab)},
114                                                                        element TermID {string($parameter/mdip:SubjectCode)}
115                                                                }
116                                                },
117                                                element ParameterName {string($parameter/mdip:SubjectName)},
118                                                element ParameterAbbreviation {string($parameter/mdip:SubjectName)}
119                                        },
120                                element dgDataCoverage {
121                                                element dgSpatialCoverage {
122                                                        element BoundingBox {
123                                                                element LimitNorth {data(f:fix-coord($MDIP/mdip:NorthCoOrdinate))},
124                                                                element LimitSouth {data(f:fix-coord($MDIP/mdip:SouthCoOrdinate))},
125                                                                element LimitWest {data(f:fix-coord($MDIP/mdip:WestCoOrdinate))},
126                                                                element LimitEast {data(f:fix-coord($MDIP/mdip:EastCoOrdinate))}
127                                                        },
128                                                        for $location in $MDIP/mdip:Extent
129                                                        return
130                                                                element dgArea {
131                                                                        element dgValidTerm {string($location/mdip:ExtentName)},
132                                                                        element dgValidTermID {
133                                                                                element ParentListID {string($location/mdip:ExtentVocab)},
134                                                                                element TermID {string($location/mdip:ExtentCode)}
135                                                                        }
136                                                                },
137                                                        for $location in $MDIP/mdip:VerticalExtent
138                                                        return
139                                                                element dgVerticalExtent {
140                                                                        element dgVerticalExtentBaseRef {
141                                                                                element dgValidTerm {if (exists($location/VerticalDatum)) then $location/VerticalDatum else 'default'},
142                                                                                element dgValidTermID {
143                                                                                        element ParentListID {'$unknown_vocab_id'},
144                                                                                        element TermID {escape-uri(string($location/mdip:VerticalDatum), true())}
145                                                                                }
146                                                                        },
147                                                                        if (exists($location/mdip:Minimum) and exists($location/mdip:Maximum)) then
148                                                                                element dgVerticalExtentRange{
149                                                                                        element dgVerticalExtentRangeMin {data($location/mdip:Minimum)},
150                                                                                        element dgVerticalExtentRangeMax {data($location/mdip:Maximum)}
151                                                                                }
152                                                                        else
153                                                                                element dgVerticalExtentLevel{
154                                                                                        if (exists($location/mdip:Minimum)) then element dgVerticalExtentLevelValue {data($location/mdip:Minimum)}
155                                                                                        else element dgVerticalExtentLevelValue {data($location/mdip:Maximum)}
156                                                                                }
157                                                                }
158                                                } (: /dgSpatialCoverage :),
159                                                element dgTemporalCoverage { (: didn't bother trying to validate the Dates as the example is naff to start with :)
160                                                        for $date in $MDIP/mdip:Date
161                                                        return
162                                                                if (exists($MDIP/mdip:Date/mdip:DatasetStartDate) and exists($MDIP/mdip:Date/mdip:DatasetEndDate) ) then
163                                                                        element DateRange {
164                                                                                element DateRangeStart {data($MDIP/mdip:Date/mdip:DatasetStartDate)},
165                                                                                element DateRangeEnd {data($MDIP/mdip:Date/mdip:DatasetEndDate)}
166                                                                        }
167                                                                else if (exists($MDIP/mdip:Date/mdip:DatasetStartDate)) then  element DataSingle {data($MDIP/mdip:Date/mdip:DatasetStartDate)}
168                                                                else element DataSingle {data($MDIP/mdip:Date/mdip:DatasetEndDate)}
169                                                }
170                                        } (: /dgDataCoverage :),
171                                        if (exists($MDIP/mdip:DatasetRefDate)) then
172                                                element dgDatasetProvenance {element dgDataPublicationDate {data($MDIP/mdip:DatasetRefDate)}}
173                                        else ()
174                        } (: /dgDataSummary :),
175                        element dgDataRoles {
176                                if (exists($MDIP/mdip:Originator)) then
177                                        element dgDataCreator {
178                                                element dgMetadataID {
179                                                        element schemeIdentifier {'NDG-B0'},
180                                                        element repositoryIdentifier {$input_repository},
181                                                        if ($output_local_id != 'Output_LocalID') then
182                                                                element localIdentifier {concat('generated_creator-', $output_local_id)}
183                                                        else
184                                                                element localIdentifier {concat('generated_creator-', escape-uri(string($MDIP/mdip:DatasetIdentifier), true()))}
185                                                },
186                                                element roleName {'Data Creator'},
187                                                element abbreviation {'Creator'},
188                                                for $creator in $MDIP/mdip:Data_Set_Citation/mdip:Dataset_Creator
189                                                return
190                                                element dgRoleHolder {
191                                                        element dgOrganisationID {
192                                                                element schemeIdentifier {'NDG-B0'},
193                                                                element repositoryIdentifier {$input_repository},
194                                                                if ($output_local_id != 'Output_LocalID') then
195                                                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id), true())}
196                                                                else
197                                                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)), true())}
198                                                        },
199                                                element startDate {current-date()}
200                                                }
201                                        }
202                                else if (exists($MDIP/mdip:Originating_Center)) then
203                                        element dgDataCreator {
204                                                element dgMetadataID {
205                                                        element schemeIdentifier {'NDG-B0'},
206                                                        element repositoryIdentifier {$input_repository},
207                                                        if ($output_local_id != 'Output_LocalID') then
208                                                                element localIdentifier {concat('generated_creator-', $output_local_id)}
209                                                        else
210                                                                element localIdentifier {concat('generated_creator-', escape-uri(string($MDIP/mdip:DatasetIdentifier), true()))}
211                                                },
212                                                element roleName {'Data Creator'},
213                                                element abbreviation {'Creator'},
214                                                for $creator in $MDIP/mdip:Originating_Center
215                                                return
216                                                element dgRoleHolder {
217                                                        element dgOrganisationID {
218                                                                element schemeIdentifier {'NDG-B0'},
219                                                                element repositoryIdentifier {$input_repository},
220                                                                if ($output_local_id != 'Output_LocalID') then
221                                                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id), true())}
222                                                                else
223                                                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)), true())}
224                                                        },
225                                                element startDate {current-date()}
226                                                }
227                                        }
228                                else (),
229                                element dgDataCurator {
230                                        element dgMetadataID {
231                                                element schemeIdentifier {'NDG-B0'},
232                                                element repositoryIdentifier {$input_repository},
233                                                if ($output_local_id != 'Output_LocalID') then
234                                                        element localIdentifier {concat('generated_curator-', $output_local_id)}
235                                                else
236                                                        element localIdentifier {concat('generated_curator-', escape-uri(string($MDIP/mdip:DatasetIdentifier), true()))}
237                                        },
238                                        element roleName {'Data Curator'},
239                                        element abbreviation {'Curator'},
240                                        element dgRoleHolder {
241                                                element dgOrganisationID {
242                                                        element schemeIdentifier {'NDG-B0'},
243                                                        element repositoryIdentifier {$input_repository},
244                                                        element localIdentifier {$input_repository_local}
245                                                },
246                                        element startDate {current-date()}
247                                        }
248                                }
249                        } (: /dgDataRoles :)
250                } (: /dgDataEntity :),
251                element dgStructuredKeyword {
252                        element dgValidTerm {'d2b converted record'},
253                        element dgValidTermID {
254                                element ParentListID {$unknown_vocab_id},
255                                element TermID {'d2b'}
256                        }
257                },
258                for $structuredKeywords in $MDIP/mdip:TopicCategory
259                return
260                        element dgStructuredKeyword {
261                                element dgValidTerm {string($structuredKeywords/mdip:TopicCategory)},
262                                element dgValidTermID {
263                                        element ParentListID {data($structuredKeywords/mdip:TopicCategoryVocab)},
264                                        element TermID {data($structuredKeywords/mdip:TopicCategoryCode)}
265                                }
266                        },
267                for $structuredKeywords in $MDIP/mdip:Subject
268                return
269                        element dgStructuredKeyword {
270                                element dgValidTerm {string($structuredKeywords/mdip:SubjectName)},
271                                element dgValidTermID {
272                                        element ParentListID {data($structuredKeywords/mdip:SubjectVocab)},
273                                        element TermID {data($structuredKeywords/mdip:SubjectCode)}
274                                }
275                        },
276                if (exists($MDIP/mdip:DIF_Creation_Date) or exists($MDIP/mdip:Last_DIF_Revision_Date)) then
277                        element dgMetadataProvenance {
278                                if (exists($MDIP/mdip:DIF_Creation_Date)) then
279                                        element RecordCreation {
280                                                element CreatedDate {
281                                                        if (string($MDIP/mdip:DIF_Creation_Date) castable as xs:date) then
282                                                                string($MDIP/mdip:DIF_Creation_Date) cast as xs:date
283                                                        else (current-date())
284                                                },
285                                        element CreatedBy {$input_repository}
286                                        }
287                                else
288                                        element RecordCreation {
289                                                element CreatedDate {current-date()},
290                                                element CreatedBy {'MOLES Import'}
291                                        },
292                                if (exists($MDIP/mdip:Last_DIF_Revision_Date)) then
293                                        element RecordUpdate {
294                                                element UpdateDate {
295                                                        if (string($MDIP/mdip:Last_DIF_Revision_Date) castable as xs:dateTime) then
296                                                                string($MDIP/mdip:Last_DIF_Revision_Date) cast as xs:dateTime
297                                                        else (current-dateTime())
298                                                },
299                                                element UpdatedBy {$input_repository}
300                                        }
301                                else ()
302                        }
303                else ()
304        } (: </dgMetadataRecord>:),
305        for $creator in $MDIP/mdip:Originator
306        return
307                element dgOrganisation { (: needs expansion... :)
308                        element dgMetadataID {
309                                element schemeIdentifier {'NDG-B0'},
310                                element repositoryIdentifier {$input_repository},
311                                if ($output_local_id != 'Output_LocalID') then
312                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id), true())}
313                                else
314                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)), true())}
315                        },
316                        element name {data($creator/mdip:OriginatorName)},
317                        element abbreviation {data($creator/mdip:OriginatorName)},
318                        element contactDetails {''}
319                }
320} (:    </dgMetadata> :)
Note: See TracBrowser for help on using the repository browser.