| \
\
| \
\
"
} else {
lappend output "| "
}
} else {
lappend output " | "
}
lappend output ""
# set color1 #BCBCBC
# set color2 #CCCCCC
# set color3 #CCBCBC
set color1 #DCDCDC
set color2 #ECECEC
set color3 #ECDCDC
set color $color1
# author
if [info exists metadataArray(${rep-i},author)] {
set author $metadataArray(${rep-i},author)
set creatorListLength [llength $author]
set creatorFieldName author
} elseif {[info exists metadataArray(${rep-i},editor)]} {
set editor $metadataArray(${rep-i},editor)
set creatorListLength [llength $editor]
set creatorFieldName editor
}
# size
ConditionalSet size metadataArray(${rep-i},size) {}
# document stage
if {[info exists currentRepositoryMetadataArray(${rep-i},year)] || \
[string equal {Data} $referenceType] && [info exists currentRepositoryMetadataArray(${rep-i},date)]} {
lappend output2 "| \${Document Stage} | \$completed | "
} else {
lappend output2 "| \${Document Stage} | \${work-in-progress} | "
}
if 0 {
# Is a copy?
if ![string equal {} $size] {
# not just a reference
if [GetDocumentState $rep] {
lappend output2 "| \${Is a Copy?} | \$no | "
} else {
lappend output2 "| \${Is a Copy?} | \$yes | "
}
}
} else {
# Is the master or a copy?
if ![string equal {} $size] {
# not just a reference
if [GetDocumentState $rep] {
lappend output2 "| $translationTable(Is the master or a copy?) | $translationTable(is the master) | "
} else {
lappend output2 "| $translationTable(Is the master or a copy?) | $translationTable(is a copy) | "
}
}
}
# metadataLastUpdate
set metadataLastUpdate $currentRepositoryMetadataArray(${rep-i},metadatalastupdate)
regsub -all { } $metadataLastUpdate {+} metadataLastUpdate2
set metadataLastUpdate2 [EscapeUntrustedData $metadataLastUpdate2] ;# added by GJFB in 2019-04-30 - the date may contain untrusted data
## site
# set site [GetServerAddress]
# wordArray
# lappend output --$keywords--
# return [list $metadataLastUpdate $output]
array set wordArray $keywords
set accessDatefilled 0
# FOREACH
foreach index [lsort -command FieldCompare [array names currentRepositoryMetadataArray ${rep-i},*]] {
# VALUE
set value $currentRepositoryMetadataArray($index)
# Store value C:/tmp/bbb.txt auto 0 a
# regsub -all {<} $value {\<} value ;# commented by GJFB in 2018-06-14
# regsub -all {>} $value {\>} value ;# commented by GJFB in 2018-06-14
set value [EscapeUntrustedData $value] ;# added by GJFB in 2018-06-14
regsub -all {""} $value {"} value ;# "" -> "
# regsub -all {\\} $value {\\\\} value ;# \ -> \\ ($\mu$) - useful in abstract ;# commented by GJFB in 2018-06-14
# regsub -all {\$} $value {\$} value ;# $ -> \$ ($w$-operator) ;# commented by GJFB in 2018-06-14
# field
regsub {.*,} $index {} field ;# author
# drop some fields
if [regexp {^$|^first|^index$|^supervisor$|^agreement$|^lasthostcollection$} $field] {continue}
if [regexp $excludedFields $field] {continue}
if [string equal {} $size] {
# just a reference
# if [regexp {^repository$|^lastupdate$|^size$|^numberoffiles$|^hostcollection$} $field] {continue}
# if [regexp {^lastupdate$|^size$|^numberoffiles$|^hostcollection$} $field] {continue}
if [regexp {^lastupdate$|^size$|^numberoffiles$} $field] {continue} ;# added by GJFB in 2016-01-16
}
if {[string equal {Archival Unit} $referenceType] && [string equal {contents} $field]} {
# contents
set contentsList {}
foreach {searchExpression title} $value {
lappend contentsList [list $searchExpression $title]
}
set value [join $contentsList
] ;# added by GJFB in 2013-04-13
}
if {$field == "size"} {
set size [lindex $value 0]
if {$size <= 1} {
set value "$size \$Kbyte"
} else {
set value "$size \$Kbytes"
}
}
# curriculo Lattes
if {$field == "label"} {
regsub {^lattes: (\d+) (.*)} $value {lattes: \1 \2} value
}
# Google Scholar
if {$field == "title"} {
regsub -all {"} $value {} value2 ;# " -> {}
# regsub -all { } $value2 {+} value2 ;# not needed
set value2 [SetNoMatch $value2 no yes 1] ;# Google doesn't work properly with accent
if ![string equal {} $size] {
# not just a reference
regsub -all {/} $rep {__} window
regsub -all {\.|@|-} $window {_} window
# set value "[HighlightWord $field $value]" ;# commented by GJFB in 2018-06-01
set value "[HighlightWord $field $value]"
}
set defaultMirrorHomePageRep dpi.inpe.br/banon/2000/01.23.20.24
set value "$value ![](\"http://$localSite/col/$defaultMirrorHomePageRep/doc/externalLink.png\") "
# set value "$value"
}
# notes
# repository
# databaserepository
# identifier
if {![string equal {} $size] || [string equal {Archival Unit} $referenceType]} {
# not just a reference or an Archival Unit
if [regexp {^repository$|^databaserepository$|^identifier$} $field] {
regsub -all {/} $value {__} window
regsub -all {\.|@|-} $window {_} window
# set metadataRep2 [FindMetadataRep $value] ;# commented by GJFB in 2018-06-01 - useless and doesn't work with identifier
# set value "<\;$value>\;"
# set value "<\;$value>\;"
# set value "<\;$value>\;"
# set value "<\;[HighlightWord $field $value]>\;"
# set value "[HighlightWord $field $value]"
# set value "[HighlightWord $field $value]" ;# commented by GJFB in 2018-06-01
set value "[HighlightWord $field $value]"
}
}
# previousedition
# nextedition
if [regexp {^previousedition$|^nextedition$} $field] {
# if $staticIPFlag {set serverName urlib.net} else {set serverName $localSite} ;# added by GJFB in 2018-01-06 - commented by GJFB in 2018-06-06 - produces the error "empty expression" when the communication with urlib.net fails
if {![string equal {} $staticIPFlag] && $staticIPFlag} {set serverName urlib.net} else {set serverName $localSite} ;# added by GJFB in 2018-06-06 - if the communication with urlib.net fails then staticIPFlag value is set to empty
regsub -all {/} $value {__} window
regsub -all {\.|@|-} $window {_} window
set metadataRep2 [FindMetadataRep $value]
# set value "[HighlightWord $field $value]"
set value "[HighlightWord $field $value]"
}
# nexthigherunit
# previouslowerunit
if [regexp {^nexthigherunit$|^previouslowerunit$} $field] {
# if $staticIPFlag {set serverName urlib.net} else {set serverName $localSite} ;# added by GJFB in 2018-01-06 - commented by GJFB in 2018-06-06 - produces the error "empty expression" when the communication with urlib.net fails
if {![string equal {} $staticIPFlag] && $staticIPFlag} {set serverName urlib.net} else {set serverName $localSite} ;# added by GJFB in 2018-06-06 - if the communication with urlib.net fails then staticIPFlag value is set to empty
set list {}
foreach item $value {
if [TestContentType $item Metadata] {continue}
regsub -all {/} $item {__} window
regsub -all {\.|@|-} $window {_} window
set metadataRep2 [FindMetadataRep $item]
lappend list "[HighlightWord $field $item]"
}
# set value [join $list
]
set value $list
# Store value C:/tmp/bbb.txt auto 0 a
}
if [string equal {repository} $field] {
if {[info exists metadataArray(${rep-i},readpermission)] && \
[regexp {deny} $metadataArray(${rep-i},readpermission)] && \
[info exists metadataArray(${rep-i},size)]} {
# restricted access
# translationTable(restricted access) is defined in mirror/xxSearchResult.tcl (where xx is en, pt-BR, ...)
append value " ($translationTable(restricted access))"
}
}
if {$field == "url"} {
# url
# set value "<\;[HighlightWord $field $value]>\;"
# set value "[HighlightWord $field $value]" ;# commented by GJFB in 2018-06-05 - the URL value may be an untrusted data
set value "[HighlightWord $field $value]" ;# added by GJFB in 2018-06-05 - XSS prevention
}
if {$field == "doi"} {
# doi
# set value [list "<\;[HighlightWord $field $value]>\;"]
set value [list "[HighlightWord $field $value]"]
}
if 0 {
# commented by GJFB in 2018-05-31 while introducing the new field name: holdercode - secondarykey for Image is no more a reference code as define in ISAD(G) - now the reference code would be the holdercode value plus the identifier value (not implemented)
if {$field == "secondarykey" && [string equal {Image} $referenceType]} {
set value "$value $identifier"
}
}
if [regexp {^childrepositories|^parentrepositories|^copyright} $field] {
set list {}
# Store value C:/tmp/aaa auto 0 a
foreach item $value {
if [TestContentType $item Metadata] {continue}
# lappend list "<\;$item>\;"
regsub -all {/} $item {__} prefix
regsub -all {\.|@|-} $prefix {_} prefix
# lappend list "<\;$item>\;"
# lappend list "<\;$item>\;"
# lappend list "<\;[HighlightWord $field $item]>\;"
lappend list "[HighlightWord $field $item]"
}
# Store value C:/tmp/aaa auto 0 a
set value [join $list
]
}
if {$field == "site"} {
# set value "<\;[HighlightWord $field $localSite]>\;"
set value "[HighlightWord $field $localSite]"
}
if {$field == "hostcollection"} {
set value [join $value
]
# set hostCollection $value
}
if {$field == "holdercode"} {
set value [join $value
]
}
if {$field == "dayofbirth"} {
regsub {^\d{4,}-(.*)$} $value {YYYY-\1} value ;# hide the year of birth
}
# set xxx --$value--
# Store xxx C:/tmp/bbb.txt auto 0 a
# Store field C:/tmp/aaa auto 0 a
# if [regexp {^affiliation|^author|^base|^cartographer|^committee|^editor|^electronicmailaddress$|^group|^programmer|^reporter|^serieseditor|^source|^supervisor|^translator} $field]
if {[lsearch -exact $multipleLineFieldNameList $field] != -1 && !([string equal {Electronic Source} $referenceType] && [string equal {producer} $field])} {
# multiple line fields and not (Electronic Source and producer) (producer is not a multiple line field for Electronic Source)
# drop some fields
set value [MultipleRegsub {,*$} $value {}] ;# drop trailing commas
if {[info exists creatorListLength] && $creatorListLength > 1} {
# if [regexp "^($creatorFieldName|resumeid|orcid|group|affiliation|electronicmailaddress)$" $field] # ;# removed by GJFB in 2019-05-10
switch -regexp -- $field "^($creatorFieldName|resumeid|orcid|group|affiliation|electronicmailaddress)$" {
set stringLength [string length $creatorListLength]
set j 1
set enumeratedList {}
foreach item $value {
regsub -all { } [format %${stringLength}s $j] {\ } j2
## lappend enumeratedList "$item"
# lappend enumeratedList "$j2 $item"
switch -exact $field resumeid {
lappend enumeratedList "$j2 $item"
} orcid {
lappend enumeratedList "$j2 $item"
} default {
lappend enumeratedList "$j2 $item"
}
incr j
}
# set value "[join $enumeratedList
] "
set value [join $enumeratedList
]
} default {
set value [join $value
]
}
} else {
# set value [join $value
]
switch -regexp -- $field resumeid {
set value "$value"
} orcid {
set value "$value"
# # {component|nexthigherunit|previouslowerunit} # ;# commented by GJFB in 2018-08-23
} {^(component|nexthigherunit|previouslowerunit|notes|committee|editor)$} { ;# added by GJFB in 2018-08-23 - solves the conference proceedings reference type which have one author and more than one editor
set value [join $value
]
} default {
set value [join $value]
}
}
}
# set xxx --$value--
# Store xxx C:/tmp/bbb.txt auto 0 a
if [regexp {^author|^programmer|^reporter|^cartographer|^title} $field] {
set bg BGCOLOR=#FFFFFF
set color $color2
} elseif {[regexp {^editor} $field] && [string equal {Edited Book} $referenceType]} {
set bg BGCOLOR=#FFFFFF
set color $color2
} else {
set bg ""
}
if [regexp {^size|^lastupdate} $field] {
set color $color1
}
if [regexp {^e-mailaddress|^username|^documentstage|^readpermission|^visibility} $field] {
set color $color3
}
# access date
if [regexp {^accessdate} $field] {
set accessDatefilled 1
}
if [regexp {} $value] {
# is a web link
lappend output "| \$field\::conversionTable($field) | $value | "
} else {
# is not a web link
lappend output "| \$field\::conversionTable($field) | [HighlightWord $field $value] | "
if {$field == "metadatalastupdate" && [info exists output2]} {
set output [concat $output $output2]
}
}
}
# FOREACH - end
set color $color1
# set encodingName [Execute $serverAddress [list GetEncodingName]]
# set convertToUTF8 [expr [regexp {Apache/2} $env(SERVER_SOFTWARE)] || [string equal {utf-8} $encodingName]] ;# solves the accent problem - same code is used in xxDocContent.html
# set convertToUTF8 [string equal {utf-8} $encodingName] ;# solves the accent problem - same code is used in xxDocContent.html
# source
set dir $homePath/col/$rep/source
# foreach {lineList j} [CreateDirectoryContentList $rep $dir $convertToUTF8] {break}
foreach {lineList j} [CreateDirectoryContentList $rep $dir] {break}
# {source Directory Content} and {there are no files} are defined in xxSearchResult.tcl (where xx is en, pt-BR, ...)
set dir $homePath/col/$rep/source
set fileList {}
DirectoryContent fileList $dir $dir 650
if [string equal {} $fileList] {
lappend output "| \${source Directory Content} | \${there are no files} | "
} else {
if 0 {
set lineList {}
foreach file [lsort -dictionary $fileList] {
regsub -all -- {\$} $file {\$} file2
lappend lineList "\
\
| \
$file2\
| \
\
[clock format [file mtime $homePath/col/$rep/source/$file] -format "%d/%m/%Y %H:%M"]\
| \
\
[
set size [file size $homePath/col/$rep/source/$file]
if {$size < 1048576} {
set size2 [format "%.1f KiB" [expr $size / 1024.]]
} else {
set size2 [format "%.1f MiB" [expr $size / 1048576.]]
}
]\
| \
\
"
}
}
# Store lineList C:/tmp/bbb.txt auto 0 a
lappend output "| \${source Directory Content} | | "
}
# agreement
set dir $homePath/col/$rep/agreement
# foreach {lineList j} [CreateDirectoryContentList $rep $dir $convertToUTF8] {break}
foreach {lineList j} [CreateDirectoryContentList $rep $dir] {break}
ConditionalSet agreementFileList currentRepositoryMetadataArray(${rep-i},agreement) {}
if [file isdirectory $dir] {
# lappend output "| \${agreement Directory Link} | \${see directory content} | "
# lappend output [join $lineList \n]
lappend output "| \${agreement Directory Content} | | "
} else {
lappend output "| \${agreement Directory Content} | \${there are no files} | "
}
if [info exists metadataRep] {
# history
set history {}
set previousUser {}
array set previousHistoryArray {}
set yearChange {}
foreach item $repositoryProperties($metadataRep,history) {
set currentUser [lindex $item 2]
if {[llength $item] == 4} {
array set currentHistoryArray [lindex $item 3]
} else {
array set currentHistoryArray {}
}
set userChange $previousUser
if {![string equal {} $previousUser] && ![string equal {} $currentUser]} {
if {![string equal $previousUser $currentUser]} {
set userChange "$previousUser -> $currentUser"
}
}
if {[regexp -- {->} $userChange] || [regexp -- {->} $yearChange]} {
lappend history "[ReturnDate [lindex $previousItem 0]] :: $userChange :: $yearChange"
}
ConditionalSet yearChange previousHistoryArray(D) {}
if {![string equal {} [array get previousHistoryArray]] && \
![string equal {} [array get currentHistoryArray]]} {
if {![string equal $previousHistoryArray(D) $currentHistoryArray(D)]} {
set yearChange "$previousHistoryArray(D) -> $currentHistoryArray(D)"
}
}
set previousUser $currentUser
array set previousHistoryArray [array get currentHistoryArray]
set previousItem $item
}
# user name
if [info exists currentRepositoryMetadataArray(${rep-i},username)] {
set userName $currentRepositoryMetadataArray(${rep-i},username)
if ![string equal $userName $currentUser] {
set userChange "$currentUser -> $userName"
} else {
set userChange "$currentUser"
}
} else {
set userChange "$currentUser ->"
}
if {[regexp -- {->} $userChange] || [regexp -- {->} $yearChange]} {
lappend history "[ReturnDate [lindex $previousItem 0]] :: $userChange :: $yearChange"
}
if ![string equal {} $history] {
set history [join $history
]
lappend output "| \$History | $history | "
}
}
# empty fields
set emptyFieldList {}
# puts [ReturnReferModel $referenceType]
foreach field [ReturnReferModel $referenceType] {
set field1 [lindex $field 1] ;# author
if [string equal {accessdate} $field1] {continue}
if [string equal {isbn/issn} $field1] {continue}
if {[lsearch [array names currentRepositoryMetadataArray ${rep-i},*] ${rep-i},$field1] == -1} {lappend emptyFieldList $field1}
}
if {[lsearch [array names currentRepositoryMetadataArray ${rep-i},*] ${rep-i},size] == -1} {lappend emptyFieldList size numberoffiles}
# if {[lsearch [array names currentRepositoryMetadataArray ${rep-i},*] ${rep-i},readergroup] == -1} {lappend emptyFieldList readergroup} ;# readergroup is not part of the refer model - commented by GJFB in 2017-05-06 - now readergroup is part of the refer model
if ![string equal {} $emptyFieldList] {
lappend output "| \${Empty Fields} | [lsort $emptyFieldList] | "
}
# access date
if {![regexp $excludedFields accessdate] && !$accessDatefilled} {
lappend output "| \$field\::conversionTable(accessdate) | \$accessDate | "
}
# update
if {$i == 0} {
## rep
# set rep [ReturnRepositoryName $metadataRep]
if [TestForUpdate $mirrorRep $remoteIp ${rep-i} $rep] {
# lappend output "| $includeReturnAddress | \; | "
if [string equal {yes} $includeReturnAddress] {
# include return address
# lappend output "| \${update} | \; | "
# lappend output "| \${update} | \; | "
lappend output "| \${update} | \; | "
} else {
# lappend output "| \${update} | \; | "
# lappend output "| \${update} | \; | "
lappend output "| \${update} | \; | "
}
}
}
# related
set relatedLink [ComputeRelatedLink ${rep-i} $languageRepository $hideSimilarButton related]
if ![string equal {} $relatedLink] {
lappend output "| $relatedLink | \; | "
}
lappend output " "
# lappend output "
"
lappend output " |
"
return [list $metadataLastUpdate $output]
# return [join $output \n]
}
# CreateFullEntry - end
# ----------------------------------------------------------------------
# ReturnDate
# date example: 2006:03.10.23.19.33
proc ReturnDate {date} {
regexp {(....):(..)\.(..)\.(..)\.(..)\.(..)} $date m year month day hour minute second
return "$year-$month-$day $hour:$minute:$second"
# return "$year-$month-$day"
}
# ReturnDate - end
# ----------------------------------------------------------------------
# CreateFullBibTeXEntry
# path example: ../
# path not used
proc CreateFullBibTeXEntry {rep-i path mirrorRep} {
global metadataArray
global homePath
set metadataList [array get metadataArray ${rep-i},*]
# rep
if [regexp {(.*)-0} ${rep-i} m metadataRep] {
set rep [ReturnRepositoryName $metadataRep]
}
# size
ConditionalSet size metadataArray(${rep-i},size) {}
# isJustReference
if {[string compare {} $size] == 0} {
# just a reference
set isJustReference 1
} else {
set isJustReference 0
}
set output [CreateBibTeXEntry $metadataList ${rep-i} $mirrorRep $isJustReference]
lappend output ""
# metadataLastUpdate
set metadataLastUpdate $metadataArray(${rep-i},metadatalastupdate)
return [list $metadataLastUpdate $output]
}
# CreateFullBibTeXEntry - end
# ----------------------------------------------------------------------
# CreateBibTeXEntry
proc CreateBibTeXEntry {metadataList rep-i {mirrorRep {}} {isJustReference 0}} {
# runs with post
global inverseTable
global bib2referRepository
global ${bib2referRepository}::r2b
global ${bib2referRepository}::r2bTable
global loBiMiRep
global masterLanguagePattern ;# created in LoadGlobalVariables
global multipleLineFieldNameList
global fieldAttributeTable
global localSite
global environmentArray
# puts --$metadataList--
array set metadataArray $metadataList
# reference type
set referenceType $metadataArray(${rep-i},referencetype)
set referenceType2 $referenceType
if [regexp {^Book$} $referenceType] {
if {[info exists metadataArray(${rep-i},publisher)] || \
[info exists metadataArray(${rep-i},serieseditor)]} {
# publisher or serieseditor
set referenceType2 {Book1}
} else {
# no publisher and no serieseditor
set referenceType2 {Book2}
}
}
if [regexp {Edited Book} $referenceType] {
if ![info exists metadataArray(${rep-i},organization)] {
# no organization
set referenceType2 {Edited Book1}
} else {
# organization
set referenceType2 {Edited Book2}
}
}
if [regexp {Report} $referenceType] {
if ![info exists metadataArray(${rep-i},institution)] {
# no institution
set referenceType2 {Report1}
} else {
# institution
set referenceType2 {Report2}
}
}
if [regexp {Book Section} $referenceType] {
if [info exists metadataArray(${rep-i},booktitle)] {
# title and booktitle
set referenceType2 {Book Section2}
} else {
# no booktitle
set referenceType2 {Book Section1}
}
}
if [regexp {Thesis} $referenceType] {
if [info exists metadataArray(${rep-i},thesistype)] {
set thesisType $metadataArray(${rep-i},thesistype)
# set masterLanguagePattern master|mestrado
if [regexp -nocase $masterLanguagePattern $thesisType] {
# Masters Thesis
set referenceType2 {Thesis1}
} else {
# PhD Thesis
set referenceType2 {Thesis2}
}
} else {
# %9 doesn't exist
set referenceType2 {Misc}
}
}
# entry type
set entryType $r2b($referenceType2)
# citationKey
# set citationKey $metadataArray(${rep-i},citationkey) ;# commented by GJFB in 2018-06-14
set citationKey [EscapeUntrustedData $metadataArray(${rep-i},citationkey)] ;# added by GJFB in 2018-06-14
# metadataLastUpdate
# set metadataLastUpdate $metadataArray(${rep-i},metadatalastupdate)
if {$mirrorRep != {} && ![TestContentType $mirrorRep Mirror]} {
# mirrorRep may be relative to another site and therefore don't exist
set mirrorRep $loBiMiRep
}
# set output [array get metadataArray ${rep-i},*] ;# <<< testing
lappend output "@$entryType\{$citationKey,"
set accessDatefilled 0
# return [array names metadataArray ${rep-i},*]
# return [lsort -command BibFieldCompare [array names metadataArray ${rep-i},*]]
#FOREACH
foreach index [lsort -command BibFieldCompare [array names metadataArray ${rep-i},*]] {
# return --$index--
set value $metadataArray($index)
# puts --$value--
regsub -all {""} $value {"} value
regsub -all {\$} $value {\$} value ;# $ -> \$ ($w$-operator)
regsub -all {\\} $value {\\\\} value ;# \% -> \\% (\$ -> \\$) - added by GJFB in 2014-05-29 otherwise \% (\$) in metadataList is displayed % ($)
# field
regsub {.*,} $index {} field
# puts "$field =--$value--"
if [regexp {^$|^first|^index$|^supervisor$} $field] {continue}
# lappend output $field
if [string equal {supervisor} $field] {continue}
if 1 {
if [string equal {pages} $field] {
regsub -all -- {([0-9])-} $value {\1--} value ;# 1-2-3 -> 1--2--3
}
# must be used for all the fields (to avoid the sequence #{# \{"} that is not a correct LaTeX one)
regsub -all {"} $value {{"}} value
regsub -all {&} $value {\\\\&} value ;# & -> \\\&
regsub -all {ã} $value {{\\\~a}} value
regsub -all {á} $value {{\\\'a}} value
regsub -all {à} $value {{\\\`a}} value
regsub -all {â} $value {{\\\^a}} value
regsub -all {ä} $value {{\\\"a}} value
regsub -all {ç} $value {{\\\c{c}}} value
regsub -all {é} $value {{\\\'e}} value
regsub -all {è} $value {{\\\`e}} value
regsub -all {ê} $value {{\\\^e}} value
regsub -all {ë} $value {{\\\"e}} value
regsub -all {í} $value {{\\\'{\\\i}}} value
regsub -all {ì} $value {{\\\`{\\\i}}} value
regsub -all {î} $value {{\\\^{\\\i}}} value
regsub -all {ï} $value {{\\\"{\\\i}}} value
regsub -all {õ} $value {{\\\~o}} value
regsub -all {ó} $value {{\\\'o}} value
regsub -all {ò} $value {{\\\`o}} value
regsub -all {ô} $value {{\\\^o}} value
regsub -all {ö} $value {{\\\"o}} value
regsub -all {ú} $value {{\\\'u}} value
regsub -all {ü} $value {{\\\"u}} value
regsub -all {ý} $value {{\\\'y}} value
regsub -all {ÿ} $value {{\\\"y}} value
regsub -all {Ã} $value {{\\\~A}} value
regsub -all {Á} $value {{\\\'A}} value
regsub -all {À} $value {{\\\`A}} value
regsub -all {Â} $value {{\\\^A}} value
regsub -all {Ä} $value {{\\\"A}} value
regsub -all {Ç} $value {{\\\C{C}}} value ;# ?
regsub -all {É} $value {{\\\'E}} value
regsub -all {È} $value {{\\\`E}} value
regsub -all {Ê} $value {{\\\^E}} value
regsub -all {Ë} $value {{\\\"E}} value
regsub -all {Í} $value {{\\\'{\\\I}}} value ;# ?
regsub -all {Ì} $value {{\\\`{\\\I}}} value ;# ?
regsub -all {Î} $value {{\\\^{\\\I}}} value ;# ?
regsub -all {Ï} $value {{\\\"{\\\I}}} value ;# ?
regsub -all {Õ} $value {{\\\~O}} value
regsub -all {Ó} $value {{\\\'O}} value
regsub -all {Ò} $value {{\\\`O}} value
regsub -all {Ô} $value {{\\\^O}} value
regsub -all {Ö} $value {{\\\"O}} value
regsub -all {Ú} $value {{\\\'U}} value
regsub -all {Ü} $value {{\\\"U}} value
regsub -all {Ý} $value {{\\\'Y}} value
regsub -all {Ÿ} $value {{\\\"Y}} value
} else {
regsub -all -- {([0-9])-} $value {\1--} value ;# 1-2-3 -> 1--2--3
regsub -all {ã} $value {\\\~a} value
# ...
regsub -all {Ÿ} $value {\\\"Y} value
regsub -all {"} $value {{"}} value ;# #{# \" -> \{"} (#{# \{"} is not a correct LaTeX sequence)
regsub -all {&} $value {\\\&} value
}
# global homePath
# Store field $homePath/xxx auto 0 a
# drop some fields
# if [regexp {^$|^first|^index$|^lastupdate$|^metadatalastupdate$|^size$|^numberoffiles$|^site$|^contenttype$|^referencetype$|^thesistype$|^citationkey$|^childrepositories$|^parentrepositories$|^previousedition$|^nextedition$|^e-mailaddress$|^secondarykey$|^secondarytype$|^tertiarytype$|^dissemination$|^format$|^secondarydate$|^group$|^affiliation$|^electronicmailaddress$|^project$|^username$|^usergroup$|^readergroup$|^readpermission$|^documentstage$|^visibility$|^mark$|^electronicmailaddress$} $field] {continue}
# if [regexp {^metadatarepository$|^targetfile$} $field] {continue} ;# not defined in fieldAttributeTable
if [regexp {^metadatarepository$} $field] {continue} ;# not defined in fieldAttributeTable
if {[info exists fieldAttributeTable($field,2)] && !$fieldAttributeTable($field,2)} {continue}
if ![info exists r2bTable($referenceType2,$inverseTable($referenceType,$field))] {continue}
if $isJustReference {
# just a reference
# if [regexp {^repository$|^lastupdate$|^metadatalastupdate$|^hostcollection$} $field] {continue}
if [regexp {^repository$} $field] {continue}
}
set bibField $r2bTable($referenceType2,$inverseTable($referenceType,$field))
if {$field == "repository" && $mirrorRep != {}} {
# rep, metadataRep and site
set rep $value
if [regexp {(.*)-0} ${rep-i} m metadataRep] {
regsub -all {/} ${mirrorRep}___$metadataRep {__} window
regsub -all {\.|@|-} $window {_} window
}
# set value "$rep"
# lappend output [format "%24s" "$bibField = "]"$value",
# set value "$localSite"
# lappend output [format "%24s" "site = "]"$value",
if ![TestContentType $rep {External Contribution}] {
set domainName $environmentArray(domainName)
if [string equal {} $domainName] {
# set value "http://$localSite/$rep" ;# commented by GJFB in 2018-09-13
if [info exists metadataArray(${rep-i},identifier)] {
set id $metadataArray(${rep-i},identifier)
set value "http://$localSite/rep/$id" ;# added by GJFB in 2018-09-13 - added rep/ to let display the 'How to cite' link
} else {
set value "http:/$localSite/rep/$rep" ;# added by GJFB in 2018-09-13 - added rep/ to let display the 'How to cite' link
}
} else {
# set value "http://urlib.net/$rep" ;# commented by GJFB in 2018-09-13
if [info exists metadataArray(${rep-i},identifier)] {
set id $metadataArray(${rep-i},identifier)
set value "http://urlib.net/rep/$id" ;# added by GJFB in 2018-09-13 - added rep/ to let display the 'How to cite' link
set ibi $id
} else {
set value "http://urlib.net/rep/$rep" ;# added by GJFB in 2018-09-13 - added rep/ to let display the 'How to cite' link
set ibi $rep
}
lappend output [format "%24s" "ibi = "]"$ibi",
}
lappend output [format "%24s" "url = "]"$value",
}
} elseif {$field == "databaserepository" && $mirrorRep != {}} {
regsub -all {/} $value {__} window
regsub -all {\.|@|-} $window {_} window
set value "$value"
lappend output [format "%24s" "$bibField = "]"$value",
} elseif {$field == "url"} {
# probably an External Contribution
set value [EscapeUntrustedData $value] ;# added by GJFB in 2018-06-08
# set value "$value" ;# commented by GJFB in 2018-06-05 - the URL value may be an untrusted data
lappend output [format "%24s" "url = "]"$value", ;# added by GJFB in 2018-06-05 - XSS prevention
} elseif {$field == "doi"} {
set value [EscapeUntrustedData $value] ;# added by GJFB in 2018-06-08
lappend output [format "%24s" "doi = "]"$value",
set value "http://dx.doi.org/$value"
lappend output [format "%24s" "url = "]"$value",
} elseif {$field == "firstdoi"} {
continue
} else {
if {[string equal {Conference Proceedings} $referenceType] && \
[string equal {booktitle} $field] && \
![regexp {\.{3}$} $value]} {
# add ...
regsub {(Anais|Anales|Actas|Proceedings|Memória Final|Memórias|Resumos Extendidos|Extended Abstracts|Resumos|Resumenes|Abstracts)} $value {\1...} value
}
if {[string equal {Conference Proceedings} $referenceType] && \
[string equal {conferencename} $field] && \
[regexp {\d( |$)} $value]} {
# add .
regsub {(\d)( |$)} $value {\1.\2} value
}
# if [regexp {^affiliation|^author|^base|^cartographer|^committee|^editor|^electronicmailaddress$|^group|^programmer|^reporter|^serieseditor|^source|^supervisor|^translator} $field]
if {[lsearch -exact $multipleLineFieldNameList $field] != -1} {
# multiple line fields
set value [MultipleRegsub {,*$} $value {}] ;# drop trailing commas
set value2 {}
foreach name $value {
if ![regexp {,} $name] {
set name [list $name] ;# xx xx -> {xx xx}
}
lappend value2 $name
}
set value [join $value2 { and }]
}
set line [format "%24s" "${bibField} = "]\"
# drop extra space
regsub -all { +} $value { } fieldContent
regsub -all {(^|[^\\\{])"} $fieldContent {\1{"}} fieldContent ;# {"}
foreach word [split $fieldContent] {
# set xxx --$word--
# Store xxx C:/tmp/aaa auto 0 a
set newLine "${line}${word} " ;# add one word
# if {[string length $newLine] < "73"} #
if {[string length $newLine] < "93"} {
set line $newLine
} else {
# regsub -all {<} $line {\<} line ;# commented by GJFB in 2018-06-14
# regsub -all {>} $line {\>} line ;# commented by GJFB in 2018-06-14
set line [EscapeUntrustedData $line] ;# added by GJFB in 2018-06-14
lappend output $line
set line " $word "
}
}
# if {[string length $line] < "71"} #
if {[string length $line] < "91"} {
regsub { $} $line {} line
set line ${line}\",
} else {
regsub { [^ ]+ $} $line { } line
# regsub -all {<} $line {\<} line ;# commented by GJFB in 2018-06-14
# regsub -all {>} $line {\>} line ;# commented by GJFB in 2018-06-14
set line [EscapeUntrustedData $line] ;# added by GJFB in 2018-06-14
lappend output $line
set line " ${word}\"," ;# add one more line
}
# regsub -all {<} $line {\<} line ;# commented by GJFB in 2018-06-14
# regsub -all {>} $line {\>} line ;# commented by GJFB in 2018-06-14
set line [EscapeUntrustedData $line] ;# added by GJFB in 2018-06-14
# access date
if {$field == "accessdate"} {
set accessDatefilled 1
}
lappend output $line
}
}
# FOREACH - end
# access date
if {$mirrorRep != {} && !$accessDatefilled} {
lappend output [format "%24s" "urlaccessdate = "]\"\$accessDate\",
}
# Drop trailing comma after the last list item
set lastLine [lindex $output end]
regsub {,$} $lastLine {} lastLine
set output [lreplace $output end end $lastLine]
# Drop trailing comma after the last list item - end
lappend output "\}"
return $output
}
# CreateBibTeXEntry - end
# ----------------------------------------------------------------------
# CreateFullReferEntry
# path example: ../
proc CreateFullReferEntry {rep-i path mirrorRep} {
global metadataArray
global inverseTable
global loBiMiRep
global homePath
global multipleLineFieldNameList
global fieldAttributeTable
global localSite
# repository
if [regexp {(.*)-0} ${rep-i} m metadataRep] {
set rep [ReturnRepositoryName $metadataRep]
regsub -all {/} ${mirrorRep}___$metadataRep {__} window
regsub -all {\.|@|-} $window {_} window
}
# size
ConditionalSet size metadataArray(${rep-i},size) {}
# referenceType
set referenceType $metadataArray(${rep-i},referencetype)
# metadataLastUpdate
set metadataLastUpdate $metadataArray(${rep-i},metadatalastupdate)
foreach index [array names metadataArray ${rep-i},*] {
# value
set value $metadataArray($index)
regsub -all {\\} $value {\\\\} value ;# \% -> \\% - added by GJFB in 2014-05-29 otherwise \% in metadataList is displayed imply %
regsub -all {<} $value {\<} value
regsub -all {>} $value {\>} value
regsub -all {""} $value {"} value ;# "
regsub -all {\$} $value {\$} value ;# $ -> \$ ($w$-operator)
# field
regsub {.*,} $index {} field
# drop some fields
# if [regexp {^$|^first|^index$|^supervisor$} $field] {continue}
if [regexp {^$|^first|^index$} $field] {continue}
# if [regexp {^$|^first|^secondarykey$|^citationkey$|^lastupdate$|^accessdate$|^site$|^size$|^numberoffiles$|^language$|^contenttype$|^hostcollection$|^copyholder$|^childrepositories$|^parentrepositories$|^databaserepository|^e-mailaddress$|^secondarytype$|^tertiarytype$|^dissemination$|^format$|^secondarydate$|^area$|^group$|^affiliation$|^electronicmailaddress$|^project$|^username$|^usergroup$|^readergroup$|^readpermission$|^documentstage$|^accessdate$|^visibility$|^mark$|^index$} $field] {continue}
if {[info exists fieldAttributeTable($field,1)] && !$fieldAttributeTable($field,1)} {continue}
if {$field == "repository"} {
if ![TestContentType $mirrorRep Mirror] {
# mirrorRep may be relative to another site and therefore don't exist
set mirrorRep $loBiMiRep
}
set value "$rep"
# set value "$rep"
}
# url
if {$field == "url"} {
# set value "$value" ;# commented by GJFB in 2018-06-05 - the URL value may be an untrusted data
}
# if ![regexp {^{.*}$} $value] {set value [list $value]} ;# not author - doesn't work when an author name reduces to only one word, in this case there is no bracket
# not a multiple line fields
# if ![regexp {^affiliation|^author|^base|^cartographer|^committee|^editor|^electronicmailaddress$|^group|^programmer|^reporter|^serieseditor|^source|^supervisor|^translator} $field] {set value [list $value]}
if {[lsearch -exact $multipleLineFieldNameList $field] == -1} {set value [list $value]}
# lappend xxx [list $field $value]
foreach item $value {
lappend output "$inverseTable($referenceType,$field) $item
"
}
}
set output [lsort -command ReferFieldCompare $output]
lappend output "
"
# lappend output $xxx ;# == puts $xxx
# lappend output $multipleLineFieldNameList ;# == puts $multipleLineFieldNameList
return [list $metadataLastUpdate $output]
}
# CreateFullReferEntry - end
# ----------------------------------------------------------------------
# CreateDateTitleSite
# used in enAbout.html ...
# path example: ../
# dateFieldName value is lastupdate, metadatalastupdate or issuedate
# siteFieldName value is site or newspaper
proc CreateDateTitleSite {
rep-i path mirrorRep outputFormat
cellBackgroundColor dateFieldName siteFieldName
} {
global localSite
set metadataLastUpdate [GetMetadataLastUpdate ${rep-i}]
# date
if [string equal {lastupdate} $dateFieldName] {
set lastUpdate [GetLastUpdate ${rep-i}]
regexp {(..):(..)\.(..)} $lastUpdate m year month day
} elseif {[string equal {metadatalastupdate} $dateFieldName]} {
regexp {(..):(..)\.(..)} $metadataLastUpdate m year month day
} elseif {[string equal {issuedate} $dateFieldName]} {
set issueDate [GetFieldValue ${rep-i} issuedate]
if ![regexp {(....)-(..)-(..)} $issueDate m year month day] {
foreach {year month day} {- - -} {break}
}
} else {
foreach {year month day} {- - -} {break}
}
# title
set title [GetFieldValue ${rep-i} title] ;# commented by GJFB in 2018-06-14
set title [EscapeUntrustedData [GetFieldValue ${rep-i} title]] ;# added by GJFB in 2018-06-14
# siteAddress
# set siteAddress [GetServerAddress]
set siteAddress $localSite ;# not used with default mirror
if 0 {
if {[string compare {newspaper} $siteFieldName] == 0} {
set newspaper [GetFieldValue ${rep-i} newspaper]
}
if {[string compare {referencetype} $siteFieldName] == 0} {
# used with default mirror
set referenceType [GetFieldValue ${rep-i} referencetype]
}
}
set $siteFieldName [GetFieldValue ${rep-i} $siteFieldName]
# repName
regsub -- {-0$} ${rep-i} {} metadataRep
set repName [ReturnRepositoryName $metadataRep]
# SUBST
set output [list [subst $outputFormat]] ;# uses cellBackgroundColor
# set output [list $outputFormat]
return [list $metadataLastUpdate $output]
}
# CreateDateTitleSite - end
# ----------------------------------------------------------------------
# CreateFullXMLEntry
# path example: ../
proc CreateFullXMLEntry {rep-i} {
global localSite
set metadataLastUpdate [GetMetadataLastUpdate ${rep-i}]
set output [ConvertMetadata2XML ${rep-i} 1 $localSite]
return [list $metadataLastUpdate $output]
}
# CreateFullXMLEntry - end
# ----------------------------------------------------------------------
# ProvideRepository
# returns a repository name which metadata contains the specified
# metadata. If the repository doesn't exist, then it is
# created together with its metadata. The default metadata are
# used and uptaded based on the specified metadata
# metadataEntryList is a list of fields and values
# example of metadataEntryList: {{area SO150000} {date 1997} {base Landsat-TM}}
proc ProvideRepository {metadataEntryList} {
# runs with post
# global metadataArray
global searchRepository
set entrySearch [join $metadataEntryList { and }]
set searchResult [${searchRepository}::MountSearch $entrySearch]
# puts ---$searchResult---
# puts >>>[llength $searchResult]
foreach index $searchResult {
regexp {(.*)-([^-]*)$} $index m metadataRep i
if {$i == 0} {
# return the first encountered
return [ReturnRepositoryName $metadataRep]
}
}
# no repository found, create a new one
return [CreateRepMetadataRep empty {} $metadataEntryList]
}
# ProvideRepository - end
# ----------------------------------------------------------------------
# ReferFieldCompare
proc ReferFieldCompare {a b} {
global referRepository
global ${referRepository}::orderingTable
# regsub {.*%} [lindex $a 0] {%} aa ;# ex: aa == %A, doesn't work because of . in: "... Library".
# regsub {.*%} [lindex $b 0] {%} bb
regexp {(%[^ ]+)} $a m aa ;# ex: aa == %A
regexp {(%[^ ]+)} $b m bb
return [expr $orderingTable($aa)<=$orderingTable($bb)?-1:1]
}
# ReferFieldCompare - end
# ----------------------------------------------------------------------
# BibFieldCompare
proc BibFieldCompare {a b} {
global inverseTable
global bib2referRepository
global ${bib2referRepository}::bibOrderingTable
global ${bib2referRepository}::r2bTable
global fieldAttributeTable
upvar referenceType referenceType
upvar referenceType2 referenceType2
upvar entryType entryType
regexp {,(.*)} $a m aField :# ex. of aField: referencetype
regexp {,(.*)} $b m bField
# drop some fields
# set xxx $aField
# Store xxx C:/tmp/bbb auto 0 a
# if [regexp {^visibility$|^mark$|^readergroup$|^electronicmailaddress$|^firstelectronicmailaddress$} $aField] {return -1}
# if [regexp {^visibility$|^mark$|^readergroup$|^electronicmailaddress$|^firstelectronicmailaddress$} $bField] {return 1}
if {[info exists fieldAttributeTable($aField,2)] && !$fieldAttributeTable($aField,2)} {return -1}
if {[info exists fieldAttributeTable($bField,2)] && !$fieldAttributeTable($bField,2)} {return 1}
if ![info exists r2bTable($referenceType2,$inverseTable($referenceType,$aField))] {return -1}
if ![info exists r2bTable($referenceType2,$inverseTable($referenceType,$bField))] {return 1}
set aa $entryType,$r2bTable($referenceType2,$inverseTable($referenceType,$aField))
set bb $entryType,$r2bTable($referenceType2,$inverseTable($referenceType,$bField))
if {! [info exists bibOrderingTable($aa)] && \
! [info exists bibOrderingTable($bb)]} {
return [string compare $aa $bb]
} elseif {[info exists bibOrderingTable($aa)] && \
! [info exists bibOrderingTable($bb)]} {
return -1
} elseif {! [info exists bibOrderingTable($aa)] && \
[info exists bibOrderingTable($bb)]} {
return 1
} else {
# return [expr $bibOrderingTable($aa)<=$bibOrderingTable($bb)?-1:1] ;# doesn't work with tcl 8.3.1
return [string compare $bibOrderingTable($aa) $bibOrderingTable($bb)]
}
}
# BibFieldCompare - end
# ----------------------------------------------------------------------
# FindBannerPath
# size values are Big, Small or {}; but Big is not used
proc FindBannerPath {language size} {
global col
# global URLibServiceRepository
global serverAddress
global urlibServerAddress ;# urlib.net and port
# global urlibServerAddressWithIP ;# ip and port of urlib.net
global bannerPathArray ;# load form a @bannerSequence.tcl file - see LoadBannerPathArray
global bannerRoot ;# path of the directory containing files like nextSite, used in CreateBannerSpace and FindBannerPath - set in post file
upvar addr addr ;# set in ServeLocalCollection
# set serverAddressWithIP [GetServerAddress 1] ;# xxx.xxx.x.xx:80 ou xxx.xxx.x.xx 800 but URLib server address is www.urlib.net 800
# set urlibServerAddress $urlibServerAddressWithIP ;# ip and port of urlib.net
# if {$serverAddressWithIP != "$urlibServerAddress"} #
if {$serverAddress != "$urlibServerAddress"} {
# the current server is not the URLib server
## Main Site
# set xxx [CallTrace]
# Store xxx C:/tmp/aaa auto 0 a
# Store addr C:/tmp/aaa auto 0 a
if [regexp {^150.163} $addr] {
# INPE domain
set iconetBannerRep dpi.inpe.br/banon/2000/03.03.10.27
if [file isdirectory $col/$iconetBannerRep] {
# the Portuguese/Brazil ICONet banner exists
set bannerPath ../$col/col/$iconetBannerRep/doc/@pt-BRSmallBanner.html
} else {
# the Portuguese/Brazil ICONet banner doesn't exist
# display the URLib acting! banner
set bannerPath [lindex $bannerPathArray($language) 1]
}
# Store bannerPath C:/tmp/aaa auto 0 a
return $bannerPath
}
}
# set auxDoc $col/$URLibServiceRepository/auxdoc
set iMax [llength $bannerPathArray($language)]
if {$size == ""} {
# any banner size (big or small) needed
# Load $auxDoc/${language}BannerIndex i
Load $bannerRoot/${language}BannerIndex i
if {$i == ""} {set i 0}
incr i
if {$i >= "$iMax"} {set i 0}
set bannerPath [lindex $bannerPathArray($language) [expr $iMax - $i - 1]]
# Store i $auxDoc/${language}BannerIndex
Store i $bannerRoot/${language}BannerIndex auto 0 w 1
return $bannerPath
}
# a small banner is needed
# Load $auxDoc/${language}SmallBannerIndex i
Load $bannerRoot/${language}SmallBannerIndex i
if {$i == ""} {
# Load $auxDoc/${language}BannerIndex i
Load $bannerRoot/${language}BannerIndex i
if {$i == ""} {set i 0}
}
incr i
if {$i >= "$iMax"} {set i 0}
set j [expr $i + $iMax - 1]
set pathList [concat $bannerPathArray($language) \
$bannerPathArray($language)]
set pathList [lrange $pathList $i $j]
foreach path $pathList {
if [regexp {SmallBanner.html$} $path] {
# a small banner has been found
# Store i $auxDoc/${language}SmallBannerIndex
Store i $bannerRoot/${language}SmallBannerIndex auto 0 w 1
return $path
}
incr i
if {$i >= "$iMax"} {set i 0}
}
# no small banner has been found - return nothing
}
# FindBannerPath - end
# ----------------------------------------------------------------------
# GetOfficialIconRep
proc GetOfficialIconRep {} {
global officialIconRepList
# get the first encountered
# return dpi.inpe.br/banon/2000/01.31.19.17 ;# URLib icon
return [lindex $officialIconRepList 0]
}
# GetOfficialIconRep - end
# ----------------------------------------------------------------------
# GetSampledDocumentDBServerAddress
# Used in:
# Get (get.tcl)
# PerformCheck
#
# returns ip:port
proc GetSampledDocumentDBServerAddress {} {
# runs with post
# global postEnvironmentArray
# return [Compress $postEnvironmentArray(sampledDocumentDBServerAddress)]
return {urlib.net 800}
}
# GetSampledDocumentDBServerAddress - end
# ----------------------------------------------------------------------
# GetURLibAdEMailAddress
# Used in:
# CreateBannerSpace (utilities1.tcl) - left banner
proc GetURLibAdEMailAddress {} {
# runs with post
global postEnvironmentArray
return [Compress $postEnvironmentArray(urlibadEMailAddress)]
}
# GetURLibAdEMailAddress - end
# ----------------------------------------------------------------------
# GetURLibServiceLastVersion
proc GetURLibServiceLastVersion {} {
# runs with post
global repositoryProperties
global URLibServiceRepository
# return [lindex $repositoryProperties($URLibServiceRepository,history) end]
return [GetVersionStamp $URLibServiceRepository]
}
# GetURLibServiceLastVersion - end
# ----------------------------------------------------------------------
# PutURLibServerAddress
# not used anymore - was used by change.tcl only
proc PutURLibServerAddress2 {xxx1 xxx2 xxx3 xxx4 xxx5 xxx6} {
# runs with post
global postEnvironmentArray
# set site [Compress $xxx]
set postEnvironmentArray(urlibServerAddress) $xxx1
set postEnvironmentArray(sampledDocumentDBServerAddress) $xxx2
set postEnvironmentArray(urlibadEMailAddress) $xxx3
set postEnvironmentArray(regionalURLibServerAddress) $xxx4
set postEnvironmentArray(sampledDocumentRegionalDBServerAddress) $xxx5
set postEnvironmentArray(regionalURLibAdEMailAddress) $xxx6
# SAVE
StoreArray postEnvironmentArray ../auxdoc/.postEnvironmentArray.tcl
# SAVE - end
return done
}
# PutURLibServerAddress - end
# ----------------------------------------------------------------------
# CompareOccurrence-
# see also CompareOccurrence in utilities1.tcl
proc CompareOccurrence- {a b} {
set a1 [lindex $a 1]
set b1 [lindex $b 1]
return [expr $a1<$b1?-1:1]
}
# CompareOccurrence- - end
# ----------------------------------------------------------------------
# Compress
proc Compress {inputList} {
set m 0
set sh [lindex $inputList 0]
set inputList [lrange $inputList 1 end]
foreach item $inputList {
foreach i [lindex $item end] {
set m [Max $m $i]
}
}
set sM [lindex [lindex $inputList end] 0]
for {set t 0} {$t <= $m} {incr t} {
set break 0
for {set s $sM} {$s > -1} {incr s -1} {
if {[lindex [lindex $inputList $s] 1] >= $t} {
set value $s
continue
} else {
lappend list [list [lindex [lindex $inputList $value] end] $value]
set break 1
break
}
}
if !$break {lappend list [list [lindex [lindex $inputList $value] end] $value]}
}
set jP {}
foreach item $list {
set i [lindex $item 0]
set j [lindex $item end]
if {$j == "$jP"} {
incr ii
} else {
set ii 0
}
lappend list2 [list $j [lindex $i $ii]]
set jP $j
}
set list2 [lsort -command CompareOccurrence- [lrange $list2 1 end]]
foreach item $list2 {
lappend address [binary format c [expr [lindex $item 0] + $sh]]
}
return [join $address {}]
}
# source utilities1.tcl
# puts [Compress {33 {0 0 0} {1 0 0} {2 0 0} {3 0 0} {4 0 0} {5 0 0} {6 0 0} {7 0 0} {8 0 0} {9 0 0} {10 0 0} {11 0 0} {12 0 0} {13 3 {4 8 12}} {14 3 {4 8 12}} {15 8 {2 3 7 10 19}} {16 11 {6 9 17}} {17 14 {1 5 13}} {18 16 {11 15}} {19 17 14} {20 18 20} {21 18 20} {22 18 20} {23 18 20} {24 19 18} {25 20 16} {26 20 16} {27 20 16} {28 20 16} {29 20 16} {30 20 16} {31 20 16} {32 20 16} {33 20 16} {34 20 16} {35 20 16} {36 20 16} {37 20 16} {38 20 16} {39 20 16} {40 20 16} {41 20 16} {42 20 16} {43 20 16} {44 20 16} {45 20 16} {46 20 16} {47 20 16} {48 20 16} {49 20 16} {50 20 16} {51 20 16} {52 20 16} {53 20 16} {54 20 16} {55 20 16} {56 20 16} {57 20 16} {58 20 16} {59 20 16} {60 20 16} {61 20 16} {62 20 16} {63 20 16} {64 20 16} {65 20 16} {66 20 16} {67 20 16} {68 20 16} {69 20 16} {70 20 16} {71 20 16} {72 20 16} {73 20 16} {74 20 16} {75 20 16} {76 20 16} {77 20 16} {78 20 16} {79 20 16} {80 20 16} {81 20 16} {82 20 16} {83 20 16} {84 20 16} {85 20 16} {86 20 16} {87 20 16} {88 20 16} {89 20 16} {90 20 16} {91 20 16} {92 20 16} {93 20 16}}]
# => 200.210.103.243:1905
# Compress - end
# ----------------------------------------------------------------------
# GetVersionRegistrationTime
proc GetVersionRegistrationTime {rep lastUpdate} {
global homePath
global sampledDocumentDBRepository
# docPath
set docPath $homePath/col/$sampledDocumentDBRepository/doc
set URParts [file split $rep]
set year [lindex $URParts 2]
set rest [lreplace $URParts 2 2]
regsub -all { } $rest {=} rest
regsub -all {[:/]} $lastUpdate {=} versionStamp
# directoryPath
set directoryPath $docPath/$year/$rest/$versionStamp
Load $directoryPath/time time
return $time
}
# GetVersionRegistrationTime - end
# ----------------------------------------------------------------------
# GetHostCollectionSite
# used by Get only
proc GetHostCollectionSite {rep} {
# runs with post
global homePath
global repositoryNameDBRepository
global loBiMiRep
global loCoInRep
# docPath
set docPath $homePath/col/$repositoryNameDBRepository/doc
set URParts [file split $rep]
set year [lindex $URParts 2]
set rest [lreplace $URParts 2 2]
regsub -all { } $rest {=} rest
# directoryPath
set directoryPath $docPath/$year/$rest
if [file isdirectory $directoryPath] {
# repository name registered
Load $directoryPath/hostCollection data binary
set data [UnShift $data]
if {[lindex $data 0] != "$rep"} {return} ;# corrupted hostCollection
set hostCollection [lindex $data end]
Load $homePath/col/$loBiMiRep/doc/@siteList.txt fileContent
set found 0
foreach line [split $fileContent \n] {
if {[string compare $hostCollection [lindex $line 1]] == 0} {
set hostCollectionSite [lindex $line 0]
set found 1
break
}
}
if {[string compare $hostCollection $loCoInRep] == 0} {
set hostCollectionSite [GetServerAddress]
set found 1
}
if $found {
return [list $hostCollectionSite]
}
}
}
# GetHostCollectionSite - end
# ----------------------------------------------------------------------
# TestForUpdate
# returns 1 when the remoteIp is
# in the permissionList and
# there is a valid advanced user and
# $rep contains the original document
proc TestForUpdate {mirrorRep remoteIp rep-i rep} {
global environmentArray
## global serverAddress
global homePath
global metadataArray
# set serverAddress [GetServerAddress 1]
# if [info exists environmentArray($mirrorRep,permissionList)] {
# set permissionList $environmentArray($mirrorRep,permissionList)
# } else {
# set permissionList {}
# }
ConditionalSet permissionList environmentArray($mirrorRep,permissionList) {}
## regsub {:.*} $serverAddress {} localIp
# foreach {localIp urlibPort} [ReturnCommunicationAddress $serverAddress] {break}
set localIp $environmentArray(ipAddress)
lappend permissionList $localIp
set found 0
foreach permission $permissionList {
if [regexp $permission $remoteIp] {set found 1; break}
}
if {!$found && \
([lsearch -exact $permissionList {All Sites}] != -1 || \
[lsearch -exact $permissionList {All IPs}] != -1)} {set found 1}
# if {[file exists $homePath/col/$rep/service/userName] && ![Check-htpasswd] && $found} #
if {[info exists metadataArray(${rep-i},username)] && ![Check-htpasswd] && $found} {
if [GetDocumentState $rep] {
# $rep contains the original document
return 1
}
}
return 0
}
# TestForUpdate - end
# ----------------------------------------------------------------------
# CreateBibINPEOutput
proc CreateBibINPEOutput {rep-i localSite mirrorRep} {
global BibINPERepository
return [${BibINPERepository}::CreateOutput ${rep-i} $localSite $mirrorRep]
}
# CreateBibINPEOutput - end
# ----------------------------------------------------------------------
# CompareWords
# used in CreateBriefEntry only
# example:
# lsort -command CompareWords {{automática 1} {cardíaca 2} {computadorizadas 2} {eixo 1} {imagens 1}}
# => {computadorizadas 2} {cardíaca 2} {automática 1} {imagens 1} {eixo 1}
proc CompareWords {a b} {
set aFrequency [lindex $a 1]
set bFrequency [lindex $b 1]
if {$aFrequency < $bFrequency} {
return 1
} else {
if {$aFrequency == $bFrequency} {
set aWordLength [string length [lindex $a 0]]
set bWordLength [string length [lindex $b 0]]
if {$aWordLength < $bWordLength} {
return 1
} else {
if {$aWordLength == $bWordLength} {
return 0
}
return -1
}
}
return -1
}
}
# CompareWords - end
# ----------------------------------------------------------------------
# ComputeSimilarity
# used in GetMetadataRepositories only
proc ComputeSimilarity {xList yList} {
set domain [lsort -unique [concat $xList $yList]]
# puts $domain
if {[llength $domain] == 1} {return 1.0}
set xList2 0 ;# must not be empty otherwise xList2 may be constant (e.g., xList == {a b c} and yList == {a b})
set yList2 0 ;# must not be empty otherwise yList2 may be constant (e.g., xList == {a b} and yList == {a b c})
foreach item $domain {
lappend xList2 [llength [lsearch -all $xList $item]]
lappend yList2 [llength [lsearch -all $yList $item]]
}
# puts $xList2
# puts $yList2
return [format %.2f [expr ([Correlation $xList2 $yList2] + 1) / 2.]]
}
if 0 {
source utilities1.tcl
set x {a b c}
set y {a b}
ComputeSimilarity $x $y
# => 0.79
}
# ComputeSimilarity - end
# ----------------------------------------------------------------------
# SimplifyWordList
# flag1 value is 0 or 1; 1 means to drop punctuation mark
# flag2 value is 0 or 1; 1 means to drop common words and set no match
proc SimplifyWordList {wordList flag1 flag2} {
global commonWords
if $flag1 {
# regsub -all {[,.:;?!'"/()]} $wordList {} wordList
# regsub -all {[,.:;?!'"(){}]} $wordList {} wordList ;# commented by GJFB in 2010-09-09 (title may contain words within [] resulting in an empty similar list)
# regsub -all {[,.:;?!'"(){}\[\]]} $wordList {} wordList ;# added by GJFB in 2010-09-09 - commented by GJFB in 2010-09-15 (ponctuation mark may not be followed by a space)
regsub -all {[,.:;?!'"(){}\[\]]} $wordList { } wordList ;# ' added by GJFB in 2010-09-15
# regsub -all { [-/] } $wordList { } wordList
# regsub -all {[-–—/]} $wordList { } wordList ;# here, there are three kinds of hyphen (see also CreateRepArray) - added by GJFB in 2010-09-09 (Sub-THz -> Sub THz) - commented by GJFB in 2010-12-20 because / is not a separator when indexing words
regsub -all {[-–—]} $wordList { } wordList ;# here, there are three kinds of hyphen (see also CreateRepArray) - added by GJFB in 2010-12-20 (Sub-THz -> Sub THz)
}
if $flag2 {
regsub -all -nocase $commonWords " $wordList " { } wordList ;# drop common words
regsub -all -nocase {estudos?|study|studies} " $wordList " { } wordList ;# drop some other words
set wordList [SetNoMatch $wordList no no 1]
set wordList [string trim $wordList]
}
return $wordList
}
# SimplifyWordList - end
# ----------------------------------------------------------------------
# ComputeRelatedLink
# used in CreateBriefEntry and CreateBriefTitleAuthorEntry only
# similarButtonName value is related or Related
proc ComputeRelatedLink {rep-i languageRepository hideSimilarButton similarButtonName} {
global metadataArray
global ${languageRepository}::translationTable ;# switch to the appropriate language - set in xxSearchResult.tcl, xxReferenceTypeName.tcl and xxFillingInstructions.tcl (where xx is en, pt-BR, ...)
# lsearch -all was introduced after 8.3
if {[info tclversion] > 8.3 && \
[info exists metadataArray(${rep-i},language)] && \
[string equal {no} $hideSimilarButton]} {
set language $metadataArray(${rep-i},language)
if [regexp {^en$|^pt$} $language] {
# SET selectedFieldNameList
# options are only:
set selectedFieldNameList {title}
# set selectedFieldNameList {keywords}
# set selectedFieldNameList {title keywords}
# SET numberOfWords in each combination
# set numberOfWords 2 ;# must be greater than 1
set numberOfWords 4 ;# must be greater than 1
# SET numberOfCombinations
set numberOfCombinations 2 ;# numberOfCombinations <= numberOfWords (see Search.tcl)
foreach fieldName {title keywords} {
ConditionalSet $fieldName metadataArray(${rep-i},$fieldName) {}
# set $fieldName [SimplifyWordList [set $fieldName] 1 0] ;# commented by GJFB in 2010-09-09
set $fieldName [SimplifyWordList [set $fieldName] 1 1] ;# added by GJFB in 2010-09-09
set ${fieldName}SimplifiedList [SimplifyWordList [set $fieldName] 0 1] ;# set titleSimplifiedList and keywordsSimplifiedList
}
foreach fieldName $selectedFieldNameList {
lappend wordListList [set $fieldName] ;# used when computing similarity
lappend wordSimplifiedListList [set ${fieldName}SimplifiedList] ;# used when searching for similar
}
set wordList [join $wordListList]
set referenceWordSimplifiedList [lsort -unique [join $wordSimplifiedListList]]
if {[llength $referenceWordSimplifiedList] >= $numberOfWords} {
ConditionalSet abstract metadataArray(${rep-i},abstract) {}
set abstractSimplifiedList [SimplifyWordList $abstract 1 1]
# CONCAT title keywords abstract
set wordSimplifiedList [concat $titleSimplifiedList $keywordsSimplifiedList $abstractSimplifiedList]
# puts "wordSimplifiedList = $wordSimplifiedList"
set referenceWordListWithFrequencies {}
foreach word $referenceWordSimplifiedList {
lappend referenceWordListWithFrequencies [list $word [llength [lsearch -all $wordSimplifiedList $word]]]
}
# puts "referenceWordListWithFrequencies = $referenceWordListWithFrequencies"
set importantWordList {}
# LRANGE
foreach item [lrange [lsort -command CompareWords $referenceWordListWithFrequencies] 0 [expr $numberOfWords - 1]] {
lappend importantWordList [lindex $item 0]
}
# regsub -all -- {\+} $wordList {%2B} wordList
regsub -all {\+} $wordList {%2B} wordList ;# simplified by GJFB in 2011-02-15
regsub -all {<|>} $wordList {} wordList ;# added by GJFB in 2011-02-15 to solved the problem of the existence of a title word like <100>
regsub -all {\$} $wordList {%24} wordList ;# added by GJFB in 2019-10-10 - convert $ to %24; - needed when the title have some $ like in: R$2,7
# regsub -all -- {\+} $importantWordList {%2B} importantWordList
regsub -all {\+} $importantWordList {%2B} importantWordList ;# simplified by GJFB in 2011-02-15
regsub -all {<|>} $importantWordList {} importantWordList ;# added by GJFB in 2011-02-15
# append output2 " | $translationTable(related)"
return "$translationTable($similarButtonName)"
}
}
}
}
# ComputeRelatedLink - end
# ----------------------------------------------------------------------
|
![](\"http://\$localSite/col/$defaultMirrorHomePageRep/doc/externalLink.png\")
"
}
lappend output "$translationTable($referenceType) [join $sherpaLink]"
} else {
lappend output "$translationTable($referenceType)"
}
}
# restricted access
if {[info exists metadataArray(${rep-i},readpermission)] && \
[regexp {deny} $metadataArray(${rep-i},readpermission)] && \
[info exists metadataArray(${rep-i},size)]} {
# translationTable(restricted access) is defined in mirror/xxSearchResult.tcl (where xx is en, pt-BR, ...)
lappend output " $translationTable(restricted access)"
}
# similarity
# display the similarity value
# puts $similarity
if {![regexp {:} $similarity] && ![string equal {} $similarity]} {
# the similarity value is neither the value of a citation key nor empty
lappend output " ($similarity)"
}
## prototype (symbol: pi - first letter of prototype in Greek)
# master
if 1 {
if {!$i && [info exists metadataArray(${rep-i},size)]} {
# if [info exists metadataArray(${rep-i},hostcollection)] #
if [GetDocumentState $rep] { ;# added by GJFB in 2018-06-03
lappend output " -m-"
} else {
lappend output " ---"
}
}
}
# author and year
lappend output ""
if [string equal {Newspaper Article} $referenceType] {
ConditionalSet author metadataArray(${rep-i},newspaper) {}
} else {
set author [FormatAuthorList [GetAuthor ${rep-i}] {;} 0 0 {&} 3]
}
set author [EscapeUntrustedData $author] ;# added by GJFB in 2018-06-08 - escape untrusted data - XSS prevention
if [string equal {Film or Broadcast} $referenceType] {
ConditionalSet year metadataArray(${rep-i},yearreleased) {}
} else {
ConditionalSet year metadataArray(${rep-i},year) {}
}
set year [EscapeUntrustedData $year] ;# added by GJFB in 2018-06-08 - escape untrusted data - XSS prevention
if {$i == 0} {
if [info exists repositoryProperties($rep,authorhomepage)] {
set authorHomePageRep $repositoryProperties($rep,authorhomepage)
# regsub {([^,]*),} $author "\\1," author ;# commented by GJFB - cannot be relative; works with doc/mirrorsearch.cgi but doesn't with doc/mirror.cgi/Recent
regsub {([^,]*),} $author "\\1," author
} else {
ConditionalSet resumeID metadataArray(${rep-i},resumeid) {}
set resumeID [lindex $resumeID 0]
set resumeID [EscapeUntrustedData $resumeID] ;# added by GJFB in 2018-06-08 - escape untrusted data - XSS prevention
if $standaloneModeFlag {
regsub {([^,;]*)([,;])} $author {\1\2} author
} else {
ConditionalSet orcid metadataArray(${rep-i},orcid) {}
set orcid [lindex $orcid 0]
if [string equal {} $orcid] {
# ConditionalSet resumeID metadataArray(${rep-i},resumeid) {}
# set resumeID [lindex $resumeID 0]
if [string equal {} $resumeID] {
regsub {([^,;]*)([,;])} $author {\1\2} author
} else {
# resumeid
regsub {([^,]*),} $author "\\1," author
}
} else {
# orcid
regsub {([^,]*),} $author "\\1," author
}
}
## >>> here it is assumed that the host name doesn't contain any periods (.)
# if {[string equal {} $resumeID] || ![regexp {\.} $localSite]} #
if {[string equal {} $resumeID] || $standaloneModeFlag} {
regsub {([^,;]*)([,;])} $author {\1\2} author
} else {
# Resume
# regsub {([^,]*),} $author "\\1," author
regsub {([^,]*),} $author "\\1," author
}
}
} else {
regsub {([^,;]*)([,;])} $author {\1\2} author
}
lappend output "![](\"http://$localSite/col/$rep/images/thumbnail1$targetFileExtension\")
\
\
"
}
}
lappend output ![](\"http://$localSite/col/$repository/images/thumbnail2$targetFileExtension\")
\
![](\"http://$localSite/col/$rep/images/thumbnail3$targetFileExtension\")
\