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

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

DIF2MOLES interim refactor

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 :) 
4import module namespace voclib='http://ndg.nerc.ac.uk/xquery/lib/vocab' at 'xmldb:exist:///db/xqueryLib/Vocabs/vocab_xquery_lib.xquery';
5import module namespace inputParse='http://ndg.nerc.ac.uk/xquery/lib/inputParse' at 'xmldb:exist:///db/xqueryLib/Utilities/inputParse_xquery_lib.xquery';
6declare default element namespace 'http://ndg.nerc.ac.uk/moles';
7declare namespace dif='http://gcmd.gsfc.nasa.gov/Aboutus/xml/dif/';
8declare namespace xsi='http://www.w3.org/2001/XMLSchema-instance';
9
10(: Replacable parameters :)
11declare variable $targetCollection as xs:string {'TargetCollection'};
12declare variable $input_repository as xs:string {'Input_Repository_Code'};
13declare variable $input_repository_local as xs:string {'Input_Repository_LocalID'};
14declare variable $input_entry_id as xs:string {'Input_Entry_ID'};
15declare variable $output_local_id as xs:string {'Output_LocalID'};
16
17for $DIF in collection($targetCollection)/dif:DIF[dif:Entry_ID=$input_entry_id]
18return
19element dgMetadata {
20        element dgMetadataRecord {
21                element dgMetadataID {
22                        element schemeIdentifier {'NDG-B0'},
23                        element repositoryIdentifier {$input_repository},
24                        if ($output_local_id != 'Output_LocalID') then
25                                element localIdentifier {$output_local_id}
26                        else
27                                element localIdentifier {escape-uri(string($DIF/dif:Entry_ID), true())}
28                },
29                element dgMetadataDescription {
30                        element metadataDescriptionID {
31                                element schemeIdentifier {'NDG-B0'},
32                                element repositoryIdentifier {$input_repository},
33                        if ($output_local_id != 'Output_LocalID') then
34                                element localIdentifier {concat('generated_desc-', $output_local_id)}
35                        else
36                                element localIdentifier {concat('generated_desc-', escape-uri(string($DIF/dif:Entry_ID), true()))}
37                        },
38                        element metadataDescriptionLastUpdated {current-date()}                 ,
39                        element abstract {
40                                element abstractText {string($DIF/dif:Summary)}
41                        }
42                },
43                element name {string($DIF/dif:Entry_Title)},
44                element abbreviation {string($DIF/dif:Entry_Title)},
45                element dgDataEntity {
46                        element dgDataSetType {''},
47                        element dgDataSummary {
48                                for $parameter in $DIF/dif:Parameters
49                                return
50                                        element dgParameterSummary {
51                                                element dgParameterValue {
52                                                        element dgValueDataParameter {
53                                                                element Value {''},
54                                                                element dgStandardUnit {
55                                                                        element dgValidTerm {'dummy'},
56                                                                        element dgValidTermID {
57                                                                                element ParentListID {$voclib:unknown_vocab_id},
58                                                                                element TermID {escape-uri('dummy unit', true())}
59                                                                        }
60                                                                }
61                                                        }
62                                                },
63                                                element dgStdParameterMeasured {
64                                                        element dgValidTerm {
65                                                                concat (string($parameter/dif:Category), ' > ', string($parameter/dif:Topic), ' > ', string($parameter/dif:Term)),
66                                                                if (exists($parameter/dif:Variable)) then
67                                                                        concat(' > ', string($parameter/dif:Variable))
68                                                                else (),
69                                                                if (exists($parameter/dif:Detailed_Variable)) then
70                                                                        concat(' > ', string($parameter/dif:Detailed_Variable))
71                                                                else ()
72                                                        },
73                                                                element dgValidTermID {
74                                                                        element ParentListID {$voclib:gcmd_science_valids},
75                                                                        element TermID {escape-uri($parameter/dif:Category, true())}
76                                                                }
77                                                },
78                                                element ParameterName {
79                                                        concat (string($parameter/dif:Category), ' > ', string($parameter/dif:Topic), ' > ', string($parameter/dif:Term)),
80                                                        if (exists($parameter/dif:Variable)) then
81                                                                concat(' > ', string($parameter/dif:Variable))
82                                                        else (),
83                                                        if (exists($parameter/dif:Detailed_Variable)) then
84                                                                concat(' > ', string($parameter/dif:Detailed_Variable))
85                                                        else ()
86                                                },
87                                                element ParameterAbbreviation {
88                                                        concat (string($parameter/dif:Category), ' > ', string($parameter/dif:Topic), ' > ', string($parameter/dif:Term)),
89                                                        if (exists($parameter/dif:Variable)) then
90                                                                concat(' > ', string($parameter/dif:Variable))
91                                                        else (),
92                                                        if (exists($parameter/dif:Detailed_Variable)) then
93                                                                concat(' > ', string($parameter/dif:Detailed_Variable))
94                                                        else ()
95                                                }
96                                        },
97                                if (exists($DIF/dif:Spatial_Coverage) or exists($DIF/dif:Paleo_Temporal_Coverage) or exists($DIF/dif:Location) or exists($DIF/dif:Temporal_Coverage)) then
98                                        element dgDataCoverage {
99                                                if (exists($DIF/dif:Spatial_Coverage)  or exists($DIF/dif:Location))  then
100                                                        element dgSpatialCoverage {
101                                                                for $boundingbox in $DIF/dif:Spatial_Coverage[exists(dif:Northernmost_Latitude)
102                                                                                                                and exists(dif:Southernmost_Latitude)
103                                                                                                                and exists(dif:Easternmost_Longitude)
104                                                                                                                and exists(dif:Westernmost_Longitude)]
105                                                                return
106                                                                        element BoundingBox {
107                                                                        element LimitNorth {data(inputParse:fix-coord($boundingbox/dif:Northernmost_Latitude))},
108                                                                        element LimitSouth {data(inputParse:fix-coord($boundingbox/dif:Southernmost_Latitude))},
109                                                                        element LimitWest {data(inputParse:fix-coord($boundingbox/dif:Westernmost_Longitude))},
110                                                                        element LimitEast {data(inputParse:fix-coord($boundingbox/dif:Easternmost_Longitude))}
111                                                                        },
112                                                                for $location in $DIF/dif:Location
113                                                                return
114                                                                        element dgArea {
115                                                                                element dgValidTerm {string($location)},
116                                                                                element dgValidTermID {
117                                                                                        element ParentListID {$voclib:gcmd_location_valids},
118                                                                                        element TermID {escape-uri($location, true())}
119                                                                                }
120                                                                        }
121                                                        }
122                                                else (),
123                                                if (exists($DIF/dif:Temporal_Coverage/dif:Start_Date) or exists($DIF/dif:Paleo_Temporal_Coverage/dif:Paleo_Start_Date) or exists($DIF/dif:Chronostratigraphic_Unit)) then
124                                                        element dgTemporalCoverage {
125                                                                for $temporalcoverage in $DIF/dif:Temporal_Coverage[exists(dif:Start_Date)]
126                                                                return
127                                                                        element DateRange {
128                                                                                element DateRangeStart {string($temporalcoverage/dif:Start_Date)},
129                                                                                element DateRangeEnd {string($temporalcoverage/dif:Stop_Date)}
130                                                                        },
131                                                                for $paleotemporalcoverage in $DIF/dif:Paleo_Temporal_Coverage[exists(dif:Paleo_Start_Date)]
132                                                                return
133                                                                        element DateRange {
134                                                                                element DateRangeStart {string($paleotemporalcoverage/dif:Paleo_Start_Date)},
135                                                                                element DateRangeEnd {string($paleotemporalcoverage/dif:Paleo_Stop_Date)}
136                                                                        },
137                                                                for $chronostratigraphic in $DIF/dif:Chronostratigraphic_Unit
138                                                                return
139                                                                        element dgChronostratigraphicTerm {
140                                                                                element dgValidTerm {string($chronostratigraphic)},
141                                                                                element dgValidTermID {
142                                                                                        element ParentListID {$voclib:gcmd_paleotemporal_valids},
143                                                                                        element TermID {escape-uri($chronostratigraphic, true())}
144                                                                                }
145                                                                        }
146                                                        }
147                                                else ()
148                                        }
149                                else ()
150                        },
151                        element dgDataRoles {
152                                if (exists($DIF/dif:Data_Set_Citation/dif:Dataset_Creator)) then
153                                        element dgDataCreator {
154                                                element dgMetadataID {
155                                                        element schemeIdentifier {'NDG-B0'},
156                                                        element repositoryIdentifier {$input_repository},
157                                                        if ($output_local_id != 'Output_LocalID') then
158                                                                element localIdentifier {concat('generated_creator-', $output_local_id)}
159                                                        else
160                                                                element localIdentifier {concat('generated_creator-', escape-uri(string($DIF/dif:Entry_ID), true()))}
161                                                },
162                                                element roleName {'Data Creator'},
163                                                element abbreviation {'Creator'},
164                                                for $creatorID in $DIF/dif:Data_Set_Citation/dif:Dataset_Creator
165                                                return
166                                                element dgRoleHolder {
167                                                        element dgOrganisationID {
168                                                                element schemeIdentifier {'NDG-B0'},
169                                                                element repositoryIdentifier {$input_repository},
170                                                                if ($output_local_id != 'Output_LocalID') then
171                                                                        element localIdentifier  {escape-uri(concat('generated_orgcit-', string($creatorID), '-', $output_local_id), true())}
172                                                                else
173                                                                        element localIdentifier  {escape-uri(concat('generated_orgcit-', string($creatorID), '-', data($DIF/dif:Entry_ID)), true())}
174                                                        },
175                                                element startDate {current-date()}
176                                                }
177                                        }
178                                else if (exists($DIF/dif:Originating_Center)) then
179                                        element dgDataCreator {
180                                                element dgMetadataID {
181                                                        element schemeIdentifier {'NDG-B0'},
182                                                        element repositoryIdentifier {$input_repository},
183                                                        if ($output_local_id != 'Output_LocalID') then
184                                                        element localIdentifier  {escape-uri(concat('generated_creator-', $output_local_id), true())}
185                                                        else
186                                                        element localIdentifier  {escape-uri(concat('generated_creator-', data($DIF/dif:Entry_ID)), true())}
187                                                        },
188                                                element roleName {'Data Creator'},
189                                                element abbreviation {'Creator'},
190                                                for $creatorID in $DIF/dif:Originating_Center
191                                                return
192                                                element dgRoleHolder {
193                                                        element dgOrganisationID {
194                                                                element schemeIdentifier {'NDG-B0'},
195                                                                element repositoryIdentifier {$input_repository},
196                                                                if ($output_local_id != 'Output_LocalID') then
197                                                                        element localIdentifier  {escape-uri(concat('generated_orgcit-', string($creatorID), '-', $output_local_id), true())}
198                                                                else
199                                                                        element localIdentifier  {escape-uri(concat('generated_orgcit-', string($creatorID), '-', data($DIF/dif:Entry_ID)), true())}
200                                                        },
201                                                element startDate {current-date()}
202                                                }
203                                        }
204                                else (),
205                                element dgDataCurator {
206                                        element dgMetadataID {
207                                                element schemeIdentifier {'NDG-B0'},
208                                                element repositoryIdentifier {$input_repository},
209                                                if ($output_local_id != 'Output_LocalID') then
210                                                        element localIdentifier  {escape-uri(concat('generated_curator-', $output_local_id), true())}
211                                                else
212                                                        element localIdentifier  {escape-uri(concat('generated_curator-', data($DIF/dif:Entry_ID)), true())}
213                                        },
214                                        element roleName {'Data Curator'},
215                                        element abbreviation {'Curator'},
216                                        element dgRoleHolder {
217                                                element dgOrganisationID {
218                                                        element schemeIdentifier {'NDG-B0'},
219                                                        element repositoryIdentifier {$input_repository},
220                                                        element localIdentifier {$input_repository_local}
221                                                },
222                                        element startDate {current-date()}
223                                        }
224                                }
225                        }
226                },
227                element dgStructuredKeyword {
228                        element dgValidTerm {'d2b converted record'},
229                        element dgValidTermID {
230                                element ParentListID {$voclib:unknown_vocab_id},
231                                element TermID {'d2b'
232                        }
233                },
234                for $structuredKeywords in $DIF/dif:Keywords
235                return
236                        element dgStructuredKeyword {
237                                element dgValidTerm {$structuredKeywords},
238                                element dgValidTermID {
239                                        element ParentListID {$voclib:unknown_vocab_id},
240                                        element TermID {escape-uri($structuredKeywords, true())}
241                                }
242                        },
243                for $structuredKeywords in $DIF/dif:ISO_Topic_Category
244                return
245                        element dgStructuredKeyword {
246                                element dgValidTerm {string($structuredKeywords)},
247                                element dgValidTermID {
248                                        element ParentListID {$voclib:gcmd_iso_topic_list},
249                                        element TermID {escape-uri($structuredKeywords, true())}
250                                }
251                        },
252                if (exists($DIF/dif:DIF_Creation_Date) or exists($DIF/dif:Last_DIF_Revision_Date)) then
253                        element dgMetadataProvenance {
254                                if (exists($DIF/dif:DIF_Creation_Date)) then
255                                        element RecordCreation {
256                                                element CreatedDate {
257                                                        if (string($DIF/dif:DIF_Creation_Date) castable as xs:date) then
258                                                                string($DIF/dif:DIF_Creation_Date) cast as xs:date
259                                                        else (current-date())
260                                                },
261                                        element CreatedBy {$input_repository}
262                                        }
263                                else
264                                        element RecordCreation {
265                                                element CreatedDate {current-date()},
266                                                element CreatedBy {'MOLES Import'}
267                                        },
268                                if (exists($DIF/dif:Last_DIF_Revision_Date)) then
269                                        element RecordUpdate {
270                                                element UpdateDate {
271                                                        if (string($DIF/dif:Last_DIF_Revision_Date) castable as xs:dateTime) then
272                                                                string($DIF/dif:Last_DIF_Revision_Date) cast as xs:dateTime
273                                                        else (current-dateTime())
274                                                },
275                                                element UpdatedBy {$input_repository}
276                                        }
277                                else ()
278                        }
279                else ()
280        } (: </dgMetadataRecord>:),
281        for $creator in distinct-values($DIF/(dif:Data_Set_Citation/dif:Dataset_Creator | dif:Originating_Center))
282        return
283                element dgOrganisation {
284                        element dgMetadataID {
285                                element schemeIdentifier {'NDG-B0'},
286                                element repositoryIdentifier {$input_repository},
287                                if ($output_local_id != 'Output_LocalID') then
288                                        element localIdentifier  {escape-uri(concat('generated_orgcit-', string($creator), '-', $output_local_id), true())}
289                                else
290                                        element localIdentifier  {escape-uri(concat('generated_orgcit-', string($creator), '-', data($DIF/dif:Entry_ID)), true())}
291                        },
292                        element name {string($creator)},
293                        element abbreviation {string($creator)},
294                        element contactDetails {''}
295                }
296} (:    </dgMetadata> :)
Note: See TracBrowser for help on using the repository browser.