Install the Ghostscript package to automatically generate a thumbnail image of the the page of a PDF file by setting the property:

service.gs=/path/to/bin/gs

If on Amazon AWS you can do:

sudo yum install ghostscript

To find out where GS is located do:

which gs

See llm.html

The Zoomable Image entry type uses an external script, magick-slicer.sh, that is available on Github. This script requires ImageMagic to be installed. Once installed add the below property to your repository.properties file:

ramadda.image.slicer=/path/to/magick-slicer.sh

If running on Amazon AWS you can install ImageMagick with:

sudo yum install -y ImageMagick ImageMagick-devel

When ingesting images RAMADDA can extract text from the image using the Tesserarct OCR package. This text can then be used for searching. To configure this first install https://github.com/tesseract-ocr/tesseract. Once installed add the below property to your repository.properties file:

ramadda.tesseract=/path/to/tesseract

wget https://github.com/DanBloomberg/leptonica/archive/refs/tags/1.83.1.tar.gz
tar -xvzf 1.83.1.tar.gz
cd leptonica-1.83.1
./autobuild
./configure
make
sudo make install

export PKG_CONFIG_PATH='/usr/local/lib/pkgconfig'

wget https://github.com/tesseract-ocr/tesseract/archive/refs/tags/5.3.1.tar.gz
tar -xvzf 5.3.1.tar.gz
cd tesseract-5.3.1
./autogen.sh
./configure
make
sudo make install
sudo ldconfig

# Navigate to the tessdata directory
sudo mkdir -p /usr/local/share/tessdata
cd /usr/local/share/tessdata

# Download the English language training data, for example
sudo wget https://github.com/tesseract-ocr/tessdata/raw/main/eng.traineddata

RAMADDA supports a Jupyter Notebook entry type. It will do its own custom rendering of the notebook. You can also configure RAMADDA to use jupyter to do the rendering by setting the following property value:

ramadda.jupyter.path=/path/to/anaconda/bin/jupyter

RAMADDA integrates a number of GDAL based geospatial and raster services. To enable this install GDAL and set the following properties:

service.gdal=/usr/local/bin
service.gdal.gdal_translate=/usr/local/bin/gdal_translate
service.gdal.gdalinfo=/usr/local/bin/gdalinfo
service.gdal.ogrinfo=/usr/local/bin/ogrinfo
service.gdal.gdalwarp=/usr/local/bin/gdalwarp
service.gdal.gdaldem=/usr/local/bin/gdaldem
service.gdal.ogr2ogr=/usr/local/bin/ogr2ogr

To install gdal it might be available on your system's package manager (e.g, yum, brew). Alternatively, you can use pixi to easily install gdal. See https://www.youtube.com/watch?v=2GNmhmoIiJs

Install pixi:

curl -fsSL https://pixi.sh/install.sh | bash

Make a geo dir and init pixi:

mkdir geo
cd geo
pixi init

Add gdal:

pixi add gdal

pixi will install gdal into:

/home/ec2-user/geo/.pixi/envs/default/bin

You can add it to your PATH in the .bashrc

set PATH="$PATH:/home/ec2-user/geo/.pixi/envs/default/bin"

Then add the properties to repository.properties

service.gdal=/home/ec2-user/geo/.pixi/envs/default/bin
service.gdal.gdal_translate=/home/ec2-user/geo/.pixi/envs/default/bin/gdal_translate
service.gdal.gdalinfo=/home/ec2-user/geo/.pixi/envs/default/bin/gdalinfo
service.gdal.gdalwarp=/home/ec2-user/geo/.pixi/envs/default/bin/gdalwarp
service.gdal.gdaldem=/home/ec2-user/geo/.pixi/envs/default/bin/gdaldem
service.gdal.ogr2ogr=/home/ec2-user/geo/.pixi/envs/default/bin/ogr2ogr

To configure your RAMADDA to provide [https://arks.org/ Archival Resource Keys (ARKS)\] see [arkids.html here\].

RAMADDA supports multiple languages. To enable this set the following property:

ramadda.languages.enabled = true

##Set this to define the default language 
##ramadda.language.default=es                                                                      

If enabled then logged in users can set their default language. Also there will be a link shown in the upper right of every page to change the displayed language. The translations for each language are defined in a ".pack" file. There are language packs defined in the RAMADDA source (on Github) for Spanish, French and Chinese. You can define your own language packs and place them in the htdocs/languages directory under your RAMADDA home directory.

See purpleair_index.html

You can add NEON data entries but if you want to have a higher rate limit you should obtain an API key from NEON. Go and sign in to NEON. Once signed in create an API key and add it as a RAMADDA property:

neon.api.key=YOUR KEY

For configuring Census data see /repository/census/index.html

For Federal Reserve, Energy Information Agency, Quandl integration see /repository/biz/index.html

RAMADDA can geocode addresses through the use of external services. Create API keys from the below service provides and set any (or all) of the below API keys in a repository.properties file.

• [https://developers.google.com/maps/documentation/geocoding/get-api-key Google API Key\]
• [https://www.here.com/docs/bundle/getting-here-credentials/page/README.html here.com\]
• [https://www.geocod.io/ geocode.io\]

#for google geocoding
google.key=

#For geocoding using  the Here API from  https://www.here.com/
#also for isoline and routing in the Intgerated Map Data Viewer (IMDV)
here.key=

#For geocoding from https://www.geocod.io/
geocodeio.key=

There are a number of other services that access external APIs and require an API key. Here are some of them.

#for google geocoding
google.key=

#For geocoding using  the Here API from  https://www.here.com/
#also for route generation in the editable maps 
here.key=

#For geocoding from https://www.geocod.io/
geocodeio.key=




#show google streetview images
google.streetview.key=


#For accessing purple air sensor data
#https://www2.purpleair.com/
purpleair.api.key=

#for enabling sms access
twilio.accountsid=
twilio.authtoken=
twilio.phone=


#bureau of labor statistics
bls.api.key=

#fec
fec.api.key=


#used in the GTFS displays
ramadda.uber.token=
ramadda.lyft.clientid=
ramadda.lyft.secret=

#other...
quandl.api.key=
webhose.api.key=
enigma.api.key=
wolfram.api.key=

RAMADDA can support the Twitter Card metadata standard. This embeds metadata in an entry page like the below. When a URL to a RAMADDA page is pasted into a post then Twitter will harvest the metadata to provide a display in the post.

<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:title" content="Salton Sea">
<meta name="twitter:description" content="This is an example...">
<meta name="twitter:image" content="https://ramadda.org/repository/metadata/view/Screenshot_2023-09-25_at_08-12-53_Salton_Sea_Map.png?element=1&entryid=0e3af72d-8be7-4f9d-933d-983fad440bba&metadata_id=b96d579f-d914-4d8a-bb04-78c5896a8243">
<meta name="twitter:creator" content="@jeffmcwh">

By default the name of the entry is used for the title. If the entry has a Thumbnail image property attached to it then the Twitter Card will be an image. If the entry is an Image then the image will be used. Else it will just be a text summary. The entry's snippet is used for the description.

There is also a Twitter Card property type that can be used to specify the title, creator, description and image. Under Add Property->Miscellaneous add the Twitter Card property: Enter any of the values. If defined in the property these will override the defaults of the entry's name, snippet, etc. These properties can be inherited. For example, you can add an inherited Twitter Card property at the top-level of your repository with just the Twitter handle specified. Then for any descendent entry you can specify a title, thumbnail, etc.

To disable this set the following property in one of the .properties files in your RAMADDA home directory:

ramadda.showtwittercard=false

RAMADDA supports embedding Github checkins into wiki text with the form:

@(github user=some_user_name)  
or:
@(github owner=repository_owner repository=repository)

The access to the Github API is rate limited. To increase the request rate create a personal access token through Github and set the following RAMADDA property:

github.token=your token

By default RAMADDA serves up all of its HTML resources (javascript, css, images etc) from its own server. However, for performance, RAMADDA can be configured to use external content delivery networks (CDN) by setting this property:

ramadda.cdnok=true

For the core resources RAMADDA uses cdn.jsdeliver.net using the latest Github version tag, e.g.:

https://cdn.jsdelivr.net/gh/geodesystems/ramadda@6.60.0/...

For other resources RAMADDA uses the standard CDN for the resource, e.g.:

https://code.jquery.com/jquery-3.3.1.min.js

There are also a number of other flags

#Chunk all of the css together
ramadda.css.all=true

#Serve the javascript minified and chunked 
ramadda.minified=true

#When displaying an entry serve up the beginning of the page before
#any processing of the contents of the page
ramadda.streamoutput=true

#cache the web resources in memory
ramadda.cachehtdocs=true

See templates.html

To see the server info go to the /repository/info link.

If you want to add a contact for your site then set the property in a .properties file in your RAMADDA home directory:

ramadda.contact=...

You can add any other information for this page with:

ramadda.information=This  is my server...

RAMADDA also provides a security.txt file that follows the specification from https://securitytxt.org/. The URL is: /repository/well-known/security.txt.
You can change the contact with the following property:

ramadda.security.contact=mailto:youremail@foo.com

You can specify one or more properties in a .properties file in your RAMADDA home directory.

ramadda.httpheader1=<header name>:<header value>
ramadda.httpheader2=<header name>:<header value>  
...

e.g: For specifying HSTS Strict-Transport-Security header you would do:

ramadda.httpheader1=Strict-Transport-Security:max-age=86400; includeSubDomains

Once you restart your RAMADDA it is a good idea to check the headers, e.g. with curl:

curl -v "http://localhost:8080" > foo

JSON-LD is the JSON for Linking Data metadata standard and is used by Google and others to extract structured metadata from a web page. To enable this embedding in entry pages in RAMADDA set the following property in one of the .properties files in your RAMADDA home directory:

ramadda.showjsonld=true

You can enable logging of entry activities by setting the property:

ramadda.logging.logactivityfile=true

When set various entry activities - view, file, data (providing data to a display) - are logged to a file:
<ramadda home>/logs/entryactivity.log

RAMADDA has a number of external search providers that are not RAMADDA servers, e.g. Bureau of Labor Statistics, FRED, etc To disable these set:

ramadda.search.providers.show=false

RAMADDA has the ability to perform remote searches on a number of external data repositories, e.g., CKAN, Socrata, Federal Reserve, REDDIT, etc. This can be disabled by setting the property in a repository.properties file:

ramadda.search.providers.show=false