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

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

Second element Address case fixed

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