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

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

Establish MDIP xqueries

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