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

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

Intermediate update

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