Add Spanish language

documentation/Advanced_Search_es.md

@@ -0,0 +1,82 @@
+# Pre-ingest
+
+In the search page you can search for Intellectual Entities, Representations or Files (use the down arrow to select the search domain). For each one of these domains you can search in all its properties or in specific properties (use the down arrow to expand the advanced search). For example, if you select Intellectual Entities, you can search in a specific field of the descriptive metadata, or find files of a certain format if the Files advanced search is selected.
+
+The search engine locates only whole words. If you want to search for partial terms you should use the '*' operator.
+
+## Search operators
+
+The following search operators are at your disposal:
+
+- Exact sentence (e.g. "Miguel Ferreira")
+- Terms begin with (e.g. Miguel F*)
+- Ignore character (e.g. Miguel Ferreir?)
+- Exclude term (e.g. -Miguel Ferreira)
+- Similar terms (e.g. Ferreir~)
+- Number range (e.g. 1900..2000)
+- Term reunion (e.g. Miguel OR Ferreira)
+
+## Search custom metadata fields
+
+There are several steps to do it:
+
+1. Generate SIPs with your new descriptive metadata type and version
+2. Configure RODA to index your new descriptive metadata format
+3. Configure RODA to show fields in the advanced search menu
+
+Optional:
+* Configure RODA to display your metadata
+* Configure RODA to allow to edit your metadata with a form
+
+
+### 1. Generate SIPs with your new desc. metadata type and version
+On the SIP you must define the descriptive metadata type and version. As you are using your own, you should define metadata type OTHER, other metadata type e.g. "GolikSwe" and metadata type version e.g. "1". This can be done directly in the METS or using the [RODA-in application](http://rodain.roda-community.org/) or the [commons-ip library](https://github.com/keeps/commons-ip).
+
+### 2. Configure RODA to index your new desc. metadata format
+On RODA, you must configure how it can index this file. To do so, you must define the XSLT under `$RODA_HOME/config/crosswalks/ingest/` with a name that is calculated by your metadata type and version.
+
+On the example with metadata type=OTHER, other metadata type="GolikSwe" and metadata version 1, you must create the file `$RODA_HOME/config/crosswalks/ingest/golikswe_1.xslt`.
+
+You can look at examples in the `$RODA_HOME/example-config/crosswalks/dissemination/ingest/` or the [online version](https://github.com/keeps/roda/tree/master/roda-core/roda-core/src/main/resources/config/crosswalks/ingest).
+
+The resulting XML must be something like:
+```xml
+<doc>
+ <field name="title">abcdefgh</field>
+ <field name="origdesc_txt">abcdefgh</field>
+ <field name="destructiondate_txt">2020-01-01</field>
+ <field name="destructiondate_dd">2020-01-01T00:00:00Z</field>
+</doc>
+```
+Rules:
+- There are some reserved field names, specially `title`, `dateInitial` and `dateFinal`, that define what appear on the lists
+- You can add new specific fields, but must always add a suffix for the data type. The most used suffixes are "\_txt" (any string tokenized), "\_ss" (non-tokenized strings for identifiers), "\_dd" for ISO1601 dates.
+- The definition of the reserved fields names is made [here](https://github.com/keeps/roda/blob/master/roda-core/roda-core/src/main/java/org/roda/core/index/schema/collections/AIPCollection.java#L61) but you may need to also access [here](https://github.com/keeps/roda/blob/master/roda-common/roda-common-data/src/main/java/org/roda/core/data/common/RodaConstants.java#L604) to find out the final name.
+- A complete list of suffixes and fields types is available at the [SOLR base schema](https://github.com/keeps/roda/blob/master/roda-core/roda-core/src/main/resources/config/index/common/conf/managed-schema).
+
+To apply the changes on the stylesheet you must ingest new content or re-index existing content.
+
+### 3. Configure RODA to show fields in the advanced search menu
+
+Change your `roda-wui.properties` to [add an new advanced search field item](https://github.com/keeps/roda/blob/master/roda-ui/roda-wui/src/main/resources/config/roda-wui.properties#L165):
+
+```javaproperties
+ui.search.fields.IndexedAIP = destructiondate # add new field to the list of fields for items (i.e. AIPs), other options are representations or files
+ui.search.fields.IndexedAIP.destructiondate.fields = destructiondate_txt # the id of the field in the index, equal to the one on the stylesheet you create
+ui.search.fields.IndexedAIP.destructiondate.i18n = ui.search.fields.IndexedAIP.destructiondate # key for the translation in ServerMessages.properties
+ui.search.fields.IndexedAIP.destructiondate.type = text # the type of the field which influences the search form input
+ui.search.fields.IndexedAIP.destructiondate.fixed = true # if it appears on advanced search by default or if it needs to be added via the "ADD SEARCH FIELD" button.
+```
+You should also add the necessary translations to your `$RODA_HOME/config/i18n/ServerMessages.properties`, and in all languages you which to support.
+
+Add [a translation for your new metadata type and version](https://github.com/keeps/roda/blob/master/roda-ui/roda-wui/src/main/resources/config/i18n/ServerMessages.properties#L121):
+
+```javaproperties
+ui.browse.metadata.descriptive.type.golikswe_1=Golik SWE (version 1)
+```
+
+Add [translations for your fields](https://github.com/keeps/roda/blob/master/roda-ui/roda-wui/src/main/resources/config/i18n/ServerMessages.properties#L2):
+
+```javaproperties
+ui.search.fields.IndexedAIP.destructiondate= Destruction Date
+```

documentation/Central_Authentication_Service_es.md

@@ -0,0 +1,10 @@
+# External authentication with CAS
+
+RODA supports integration with external authentication using [Apereo CAS](https://apereo.github.io/cas/). RODA can be configured for external authentication using the [CAS protocol](https://apereo.github.io/cas/6.6.x/protocol/CAS-Protocol.html). 
+CAS can then be used to connect to many authentication protocols and sources. For information on to install and configure an Apereo CAS instance, see the [Apereo CAS official documentation](https://apereo.github.io/cas/).
+
+## Demo
+
+Setting up the integration with external authentication can be hard, professional support services can help ensuring a secure and smooth integration. These services ensure organizations have access to the resources and support they need to effectively manage and maintain a production level RODA environment, maximizing investment and ensuring the success of digital preservation operations.
+
+To obtain more information on how to get professional support in your region, please contact [KEEP SOLUTIONS](https://www.keep.pt/en/contacts-proposals-information-telephone-address).

documentation/Descriptive_Metadata_Types_es.md

@@ -0,0 +1,29 @@
+# Descriptive metadata types
+
+When creating a new intellectual entity, one of the steps is to select the "type" of descriptive metadata.
+
+This refers to the descriptive metadata scheme that will be used, and by default RODA supports the following options:
+
+* **[EAD 2002](https://www.loc.gov/ead/)**: Encoded Archival Description (EAD) version 2002 is an XML standard for encoding archiving finding aids, maintained by the Technical Subcommittee for Encoded Archival Standards of the Society of American Archivists, in partnership with the Library of Congress. It is mainly used by archives to describe both digitally-born and analog documents.
+* **[Dublin Core](https://www.dublincore.org/schemas/xmls/)**: The Dublin Core (DC) Metadata Initiative supports innovation in metadata design and best practices. Currently recommended schemas include the *Simple DC XML schema, version 2002-12-12*, which defines terms for Simple Dublin Core, i.e. the 15 elements from the http://purl.org/dc/elements/1.1/ namespace, with no use of encoding schemes or element refinements.
+* **[Key-value](https://github.com/keeps/roda/blob/master/roda-core/roda-core/src/main/resources/config/schemas/key-value.xsd)**: An RODA internal simple description schema for key-value metadata definition, where the metadata key identifies the element (e.g. "title") and the value the content of the metadata element.
+* **Other**: Generic XML type where no schema is defined.
+
+New metadata types can be added to RODA following the documentation [Metadata formats](Metadata_Formats.md).
+
+| Descriptive metadata type | Validation | Indexing | Visualization | Edition |
+|---------------------------|----------------------|------------------|-----------------------|--------------|
+| EAD 2002 | Schema validation | Indexing rules | Visualization rules | Edition form |
+| Dublin Core | Schema validation | Indexing rules | Visualization rules | Edition form |
+| Key-value | Schema validation | Indexing rules | Visualization rules | Edition form |
+| Other | Wellformedness check | General indexing | Generic visualization | XML edit |
+
+Legend:
+* **Schema validation**: The repository offers an XML schema to validate the structure and data types of the provided metadata file. The Validation schema will be used during ingest process to check if the metadata included in the SIP is valid according the established constraints, as well as when the metadata is edited via the catalogue.
+* **Wellformedness check**: The repository will only check if the metadata XML file is well-formed and since no schema is defined the repository will not verify if the file is valid.
+* **Indexing rules**: The repository provides a default XSLT that transforms the XML-based metadata into something that the indexing engine is able to understand. Enabling advanced search over the descriptive metadata.
+* **General indexing**: The repository will index all text elements and attribute values found on the metadata file, however because the repository does not know the right mapping between the XML elements and the inner data model, only basic search will possible on the provided metadata.
+* **Visualization rules**: The repository provides a default XSLT that transforms the XML-based metadata into an HTML file that will be shown to the user when browsing an existing AIP on the catalogue.
+* **Generic visualization**: The repository provides a generic metadata viewer to display the XML-based metadata. All text elements and attributes will show in no particular order and their XPath will be used as the label. 
+* **Edition form**: The repository provides a configuration file will instruct on how to display a form to edit existing metadata.
+* **XML edit**: The repository will display a text area where the user is able to edit the XML directly.

documentation/Developers_Guide_es.md

@@ -0,0 +1,150 @@
+# Documentation guide
+
+This is a quick and durty guide on how to start coding on RODA.
+
+## Get the source code
+
+You can easily get the source code by cloning the project into your machine (just need git installed):
+
+```bash
+$ git clone https://github.com/keeps/roda.git
+```
+
+If you plan to contribute to RODA, you will need to first fork the repository into your own GitHub account and then clone it into your machine. To learn how to do it, please check this [GitHub article](https://help.github.com/articles/fork-a-repo).
+
+
+<!-- WARNING: changing this title will break links -->
+## How to build and run
+
+RODA uses [Apache Maven](http://maven.apache.org/) build system. Being a multi-module Maven project, in the root **pom.xml** is declared all the important information to all modules in RODA, such as:
+
+* Modules to be included in the default build cycle
+* Maven repositories to be used
+* Dependency management (version numbers are declared here and inherited by the sub-modules)
+* Plugin management (version numbers are declared here and inherited by the sub-modules)
+* Profiles available (There are a lot of usable profiles. One that only includes the core projects (**core**), other that includes user interface projects (**wui**), other that build RODA wui docker image (**wui,roda-wui-docker**), and some other ones that, for example, can include external plugins projects that can be integrated in RODA (**all**)).
+
+### Dependencies
+
+The pre-requisites to build RODA are:
+
+* Git client
+* Apache Maven
+* Oracle Java 8
+
+To install all dependencies in Debian based systems execute:
+
+```bash
+$ sudo add-apt-repository ppa:webupd8team/java
+$ sudo apt-get update
+$ sudo apt-get install oracle-java8-installer oracle-java8-set-default git maven ant
+```
+
+### Compilation
+
+To compile, go to the RODA sources folder and execute the command:
+
+```bash
+$ mvn clean package
+```
+
+Use the following command to skip the Unit Tests (faster).
+
+```bash
+$ mvn clean package -Dmaven.test.skip=true
+```
+
+
+After a successful compile, RODA web application will be available at `roda-ui/roda-wui/target/roda-wui-VERSION.war`. To deploy it, just put it inside your favourite servlet container (e.g. Apache Tomcat) and that is it.
+
+## How to set up the development environment
+
+### Required software
+
+Besides the software needed to build RODA, you need:
+
+* Eclipse for Java ([Download page](http://www.eclipse.org/downloads/))
+* Eclipse Maven Plugin ([Download & install instructions](http://www.eclipse.org/m2e/))
+
+Optionally you may install the following tools:
+
+* Google Plugin for Eclipse ([Download & install instructions](https://developers.google.com/eclipse/docs/getting_started)) is usefull to develop and test graphical user interface developments.
+
+**NOTE:** This is not a restrictive list of software to be used for developing RODA (as other software, like IDEs, can be used instead of the one suggested.)
+
+### How to import the code in Eclipse
+
+1. Start Eclipse
+2. Select "File > Import". Then, select "Maven > Existing Maven Projects" and click "Next"
+3. In the "Root Directory", browse to RODA source code directory on your filesystem and select "Open"
+4. Optionally, you can add it to a "Working set"
+5. Click "Finish"
+
+
+## Code structure
+
+RODA is structured as follows:
+
+### /
+
+* **pom.xml** - root Maven Project Object Model
+* **code-style** - checkstyle & Eclipse code formatter files
+* **roda-common/** - this module contains common components used by other modules/projects
+ * **roda-common-data** - this module contains all RODA related model objects used in all other modules/projects
+ * **roda-common-utils** - this module contains base utilities to be used by other modules/projects
+
+### /roda-core/
+
+ * **roda-core** - this module contains model, index and storage services, with special attention to the following packages:
+ * **common** - this package contains roda-core related utilities
+ * **storage** - this package contains both a storage abstraction (inspired on OpenStack Swift) and some implementations (ATM a filesystem & Fedora 4 based implementation)
+ * **model** - this package contains all logic around RODA objects (e.g. CRUD operations, etc.), built on top of RODA storage abstraction
+ * **index** - this package contains all indexing logic for RODA model objects, working together with RODA model through Observable pattern
+ * **migration** - this package contains all migration logic (e.g. every time a change in a model object occurs a migration might be needed)
+ * **roda-core-tests** - this module contains tests and tests helpers for roda-core module. Besides that, this module can be added as dependency for other project that have, for example, plugins and ones wants to test them more easily
+
+### /roda-ui/
+
+* **roda-wui**- this module contains the Web User Interface (WUI) web application and the web-services REST. Basically the components to allow programmatic interaction with RODA.
+
+### /roda-common/
+
+* **roda-common-data** - this module contains all RODA related model objects used in all other modules/projects
+* **roda-common-utils** - this module contains base utilities to be used by other modules/projects
+
+
+## Contribute
+
+### Source code
+
+1. [Fork the RODA GitHub project](https://help.github.com/articles/fork-a-repo)
+2. Change the code and push into the forked project
+3. [Submit a pull request](https://help.github.com/articles/using-pull-requests)
+
+To increase the changes of you code being accepted and merged into RODA source here's a checklist of things to go over before submitting a contribution. For example:
+
+* Has unit tests (that covers at least 80% of the code)
+* Has documentation (at least 80% of public API)
+* Agrees to contributor license agreement, certifying that any contributed code is original work and that the copyright is turned over to the project
+
+### Translations
+
+If you would like to translate RODA to a new language please read the [Translation Guide](Translation_Guide.md).
+
+### External plugins
+
+To create new plugins and use them to RODA it is necessary to:
+
+1. Create a new Maven project that depends on roda-core and declare the plugin class qualified name in _pom.xml_
+2. The plugin class must extend **AbstractPlugin** class and implement the necessary methods
+3. After creating the plugin, it is necessary to generate a jar file
+4. That jar file should then be included under RODA base installation folder specifically in **config/plugins/PLUGIN_NAME/**
+5. Publish plugin in market ([see instructions](./Publishing_plugins.md))
+
+## REST API
+
+RODA is completely controlled via a REST API. This is great to develop external services or integrate other applications with the repository. The documentation of the API is available at [https://demo.roda-community.org/api-docs/](https://demo.roda-community.org/api-docs/).
+
+### Developing 3rd party integrations
+
+If you are interested in developing an integration with RODA via the REST API, please contact the product team for further information by leaving a question or a comment on https://github.com/keeps/roda/issues.