source: TI07-MOLES/trunk/DIF/XQuery/DIF2MOLES.xquery @ 2026

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

MDIP intermediate

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