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

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

Interim MDIP disassembly

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