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

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

Updated XQueries (DIF/DC) B->D part 1

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