D-Net

{"type_source": "SVN", "goal": "package -U -T 4C source:jar", "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet45/modules/dnet-modular-vocabularies-ui/trunk/", "deploy_repository": "dnet45-snapshots", "version": "4", "mail": "sandro.labruzzo@isti.cnr.it,michele.artini@isti.cnr.it, claudio.atzori@isti.cnr.it, alessia.bardi@isti.cnr.it", "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-snapshots", "name": "dnet-modular-vocabularies-ui"}

package eu.dnetlib.functionality.modular.ui.vocabularies.model;

import java.util.ArrayList;

import java.util.List;

public class Term implements Comparable<Term> {

	private String englishName;

	private String nativeName;

	private String encoding;

	private String code;

	private List<Synonym> synonyms = new ArrayList<Synonym>();

	private List<Relation> relations = new ArrayList<Relation>();

	public Term() {}

	public Term(String englishName, String nativeName, String encoding,

			String code, List<Synonym> synonyms, List<Relation> relations) {

		super();

		this.englishName = englishName;

		this.nativeName = nativeName;

		this.encoding = encoding;

		this.code = code;

		this.synonyms = synonyms;

		this.relations = relations;

	}

	public String getEnglishName() {

		return englishName;

	}

	public void setEnglishName(String englishName) {

		this.englishName = englishName;

	}

	public String getNativeName() {

		return nativeName;

	}

	public void setNativeName(String nativeName) {

		this.nativeName = nativeName;

	}

	public String getEncoding() {

		return encoding;

	}

	public void setEncoding(String encoding) {

		this.encoding = encoding;

	}

	public String getCode() {

		return code;

	}

	public void setCode(String code) {

		this.code = code;

	}

	public List<Synonym> getSynonyms() {

		return synonyms;

	}

	public void setSynonyms(List<Synonym> synonyms) {

		this.synonyms = synonyms;

	}

	public List<Relation> getRelations() {

		return relations;

	}

	public void setRelations(List<Relation> relations) {

		this.relations = relations;

	}

	@Override

	public int compareTo(Term o) {

		return englishName.compareTo(o.getEnglishName());

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.model;

public class Vocabulary implements Comparable<Vocabulary> {

	private String id;

	private String name;

	private String description;

	private String code;

	public Vocabulary() {}

	public Vocabulary(String id, String name, String description, String code) {

		super();

		this.id = id;

		this.name = name;

		this.description = description;

		this.code = code;

	}

	public String getId() {

		return id;

	}

	public void setId(String id) {

		this.id = id;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getDescription() {

		return description;

	}

	public void setDescription(String description) {

		this.description = description;

	}

	public String getCode() {

		return code;

	}

	public void setCode(String code) {

		this.code = code;

	}

	@Override

	public int compareTo(Vocabulary o) {

		return name.compareTo(o.getName());

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.model;

public class Synonym implements Comparable<Synonym> {

	private String term;

	private String encoding;	

	public Synonym() {}

	public Synonym(String term, String encoding) {

		super();

		this.term = term;

		this.encoding = encoding;

	}

	public String getTerm() {

		return term;

	}

	public void setTerm(String term) {

		this.term = term;

	}

	public String getEncoding() {

		return encoding;

	}

	public void setEncoding(String encoding) {

		this.encoding = encoding;

	}

	@Override

	public int compareTo(Synonym o) {

		return term.compareTo(o.getTerm());

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.model;

public class Relation implements Comparable<Relation> {

	private String type;

	private String code;

	public Relation() {}

	public Relation(final String type, final String code) {

		super();

		this.type = type;

		this.code = code;

	}

	public String getType() {

		return type;

	}

	public void setType(final String type) {

		this.type = type;

	}

	@Override

	public int compareTo(final Relation o) {

		return code.compareTo(o.getCode());

	}

	public String getCode() {

		return code;

	}

	public void setCode(final String code) {

		this.code = code;

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.persistence;

import com.google.common.base.Function;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpDocumentNotFoundException;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;

import eu.dnetlib.enabling.is.registry.ISRegistryDocumentNotFoundException;

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryException;

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryService;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Relation;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Synonym;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Term;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Vocabulary;

import eu.dnetlib.miscutils.datetime.DateUtils;

import org.antlr.stringtemplate.StringTemplate;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang.StringEscapeUtils;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

import java.io.IOException;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Map;

public class RegistryServiceVocabularyDAO extends VocabularyDAO {

	@Override

	public List<Vocabulary> getVocabularies() throws VocabularyException {

		try {

			final String query =

					"for $x in collection('/db/DRIVER/VocabularyDSResources/VocabularyDSResourceType') order by $x//VOCABULARY_NAME "

							+ "return concat ($x//RESOURCE_IDENTIFIER/@value,' §§§ ',$x//VOCABULARY_NAME,' §§§ ',$x//VOCABULARY_DESCRIPTION,' §§§ ',$x//VOCABULARY_NAME/@code)";

			List<Vocabulary> vocabularies = Lists.transform(serviceLocator.getService(ISLookUpService.class).quickSearchProfile(query),

					new Function<String, Vocabulary>() {

				@Override

				public Vocabulary apply(final String s) {

					String[] tokens = s.split("§§§");

					return new Vocabulary(tokens[0].trim(), tokens[1].trim(), tokens[2].trim(), tokens[3].trim());

				}

			});

			return vocabularies;

		} catch (ISLookUpException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public List<Term> getTerms(final String vocabularyId) throws VocabularyException {

		try {

			String profile = serviceLocator.getService(ISLookUpService.class).getResourceProfile(vocabularyId);

			final Document doc = new SAXReader().read(new StringReader(profile));

			final Map<String, Term> terms = Maps.newHashMap();

			for (Object t : doc.selectNodes("//TERM")) {

				final Element termNode = (Element) t;

				final String code = termNode.valueOf("@code");

				if (!terms.containsKey(code)) {

					final Term term = new Term();

					term.setEnglishName(termNode.valueOf("@english_name"));

					term.setNativeName(termNode.valueOf("@native_name"));

					term.setEncoding(termNode.valueOf("@encoding"));

					term.setCode(code);

					term.setSynonyms(new ArrayList<Synonym>());

					term.setRelations(new ArrayList<Relation>());

					terms.put(code, term);

				}

				final Term term = terms.get(code);

				for (Object s : termNode.selectNodes(".//SYNONYM")) {

					final Element synNode = (Element) s;

					final Synonym syn = new Synonym();

					syn.setTerm(synNode.valueOf("@term"));

					syn.setEncoding(synNode.valueOf("@encoding"));

					term.getSynonyms().add(syn);

				}

				for (Object r : termNode.selectNodes(".//RELATION")) {

					final Element relNode = (Element) r;

					final Relation rel = new Relation();

					rel.setCode(relNode.valueOf("@code"));

					rel.setType(relNode.valueOf("@type"));

					term.getRelations().add(rel);

				}

				Collections.sort(term.getSynonyms());

				Collections.sort(term.getRelations());

			}

			final List<Term> list = Lists.newArrayList(terms.values());

			Collections.sort(list);

			return list;

		} catch (ISLookUpDocumentNotFoundException e) {

			throw new VocabularyException(e);

		} catch (ISLookUpException e) {

			throw new VocabularyException(e);

		} catch (DocumentException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public void commitTerms(final List<Term> terms, final String vocabularyId) throws VocabularyException {

		try {

			// prepare terms for XML

			for (Term t : terms) {

				t.setCode(StringEscapeUtils.escapeXml(t.getCode()));

				t.setEncoding(StringEscapeUtils.escapeXml(t.getEncoding()));

				t.setEnglishName(StringEscapeUtils.escapeXml(t.getEnglishName()));

				t.setNativeName(StringEscapeUtils.escapeXml(t.getNativeName()));

				for (Synonym s : t.getSynonyms()) {

					s.setEncoding(StringEscapeUtils.escapeXml(s.getEncoding()));

					s.setTerm(StringEscapeUtils.escapeXml(s.getTerm()));

				}

				for (Relation r : t.getRelations()) {

					r.setType(StringEscapeUtils.escapeXml(r.getType()));

					r.setCode(StringEscapeUtils.escapeXml(r.getCode()));

				}

			}

			StringTemplate st =

					new StringTemplate(IOUtils.toString(getClass().getResourceAsStream("/eu/dnetlib/functionality/modular/templates/terms.xml.st")));

			st.setAttribute("terms", terms);

			serviceLocator.getService(ISRegistryService.class).updateProfileNode(vocabularyId, "//TERMS", st.toString());

		} catch (IOException e) {

			throw new VocabularyException(e);

		} catch (ISRegistryException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public void commitVocabularyInfo(final Vocabulary voc, final String vocabularyId) throws VocabularyException {

		try {

			String xml = "<VOCABULARY_DESCRIPTION>{desc}</VOCABULARY_DESCRIPTION>";

			xml = xml.replace("{desc}", StringEscapeUtils.escapeXml(voc.getDescription()));

			serviceLocator.getService(ISRegistryService.class).updateProfileNode(vocabularyId, "//VOCABULARY_DESCRIPTION", xml);

		} catch (ISRegistryException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public String createVocabulary(final Vocabulary voc) throws VocabularyException {

		try {

			StringTemplate st = new StringTemplate(

					IOUtils.toString(getClass().getResourceAsStream("/eu/dnetlib/functionality/modular/templates/vocabulary.xml.st")));

			st.setAttribute("name", voc.getName());

			st.setAttribute("description", voc.getDescription());

			st.setAttribute("code", voc.getCode());

			st.setAttribute("date", DateUtils.now_ISO8601());

			String newVocabularyId = serviceLocator.getService(ISRegistryService.class).registerProfile(st.toString());

			return newVocabularyId;

		} catch (IOException e) {

			throw new VocabularyException(e);

		} catch (ISRegistryException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public void dropVocabulary(final String vocabularyId) throws VocabularyException {

		try {

			serviceLocator.getService(ISRegistryService.class).deleteProfile(vocabularyId);

		} catch (ISRegistryDocumentNotFoundException e) {

			throw new VocabularyException(e);

		} catch (ISRegistryException e) {

			throw new VocabularyException(e);

		}

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.persistence;

public class VocabularyException extends Exception {

	/**

	 *

	 */

	private static final long serialVersionUID = 1L;

	Exception exception;

	public VocabularyException(final Exception e) {

		this.exception = e;

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.persistence;

import java.util.List;

import javax.annotation.Resource;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Term;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Vocabulary;

public abstract class VocabularyDAO {

	@Resource

	protected UniqueServiceLocator serviceLocator;

	public abstract List<Vocabulary> getVocabularies() throws VocabularyException;

	public abstract List<Term> getTerms(final String vocabularyId) throws VocabularyException;

	public abstract void commitTerms(final List<Term> terms, final String vocabularyId) throws VocabularyException;

	public abstract void commitVocabularyInfo(final Vocabulary voc, final String vocabularyId) throws VocabularyException;

	public abstract String createVocabulary(final Vocabulary voc) throws VocabularyException;

	public abstract void dropVocabulary(final String vocabularyId) throws VocabularyException;

}

package eu.dnetlib.functionality.modular.ui.vocabularies.controllers;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.IOUtils;

import org.springframework.ui.ModelMap;

import eu.dnetlib.functionality.modular.ui.ModuleEntryPoint;

public class EntryPointController extends ModuleEntryPoint {

	@Override

	protected void initialize(ModelMap map, HttpServletRequest request,	HttpServletResponse response) throws Exception {

		map.addAttribute("validRelations", IOUtils.toString(getClass().getResourceAsStream("/eu/dnetlib/functionality/modular/ui/term_relations.json"))); 

	}

}	

package eu.dnetlib.functionality.modular.ui.vocabularies.controllers;

import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Term;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Vocabulary;

import eu.dnetlib.functionality.modular.ui.vocabularies.persistence.VocabularyDAO;

import eu.dnetlib.functionality.modular.ui.vocabularies.persistence.VocabularyException;

/**

 * Web controller for the UI

 *

 * @author Andrea Mannocci

 */

@Controller

public class VocabulariesController extends VocabularyDAO {

	private static final Log log = LogFactory.getLog(VocabulariesController.class);

	@Resource(name = "vocabularyDao")

	private VocabularyDAO dao;

	/**

	 * Returns all vocabularies serialized in json. Invoked by angularJS

	 */

	@Override

	@RequestMapping("/ui/vocabularies.json")

	public @ResponseBody List<Vocabulary> getVocabularies() throws VocabularyException {

		log.info("vocabularies.json");

		return dao.getVocabularies();

	}

	/**

	 * Returns all terms and their synonyms belonging to a vocabulary. Invoked by AngularJS

	 */

	@Override

	@RequestMapping("/ui/terms.json")

	public @ResponseBody List<Term> getTerms(@RequestParam(value = "vocabularyId", required = true) final String vocabularyId) throws VocabularyException {

		log.info("terms.json?vocabularyId=" + vocabularyId);

		return dao.getTerms(vocabularyId);

	}

	@Override

	@RequestMapping(value = "/ui/commitVocabulary", method = RequestMethod.POST)

	public @ResponseBody void commitTerms(@RequestBody(required = true) final List<Term> terms,

			@RequestParam(value = "vocabularyId", required = true) final String vocabularyId) throws VocabularyException {

		log.info("committing vocabulary id = " + vocabularyId);

		dao.commitTerms(terms, vocabularyId);

	}

	@Override

	@RequestMapping(value = "/ui/commitVocabularyInfo", method = RequestMethod.POST)

	public @ResponseBody void commitVocabularyInfo(@RequestBody(required = true) final Vocabulary voc,

			@RequestParam(value = "vocabularyId", required = true) final String vocabularyId) throws VocabularyException {

		log.info("committing vocabulary info id = " + vocabularyId);

		dao.commitVocabularyInfo(voc, vocabularyId);

	}

	@Override

	@RequestMapping(value = "/ui/createVocabulary", method = RequestMethod.POST)

	public @ResponseBody String createVocabulary(@RequestBody(required = true) final Vocabulary voc) throws VocabularyException {

		log.info("create vocabulary");

		String vocId = dao.createVocabulary(voc);

		return vocId;

	}

	@Override

	@RequestMapping(value = "/ui/dropVocabulary", method = RequestMethod.GET)

	public @ResponseBody void dropVocabulary(@RequestParam(value = "vocabularyId", required = true) final String vocabularyId) throws VocabularyException {

		log.info("delete vocabulary id=" + vocabularyId);

		dao.dropVocabulary(vocabularyId);

	}

}

[

	{ "id": "owl:complementOf",         "label": "complementOf" },

	{ "id": "owl:differentFrom",        "label": "differentFrom" },

	{ "id": "owl:disjointUnionOf",      "label": "disjointUnionOf" },

	{ "id": "owl:disjointWith",         "label": "disjointWith" },

	{ "id": "owl:equivalentClass",      "label": "equivalentClass" },

	{ "id": "owl:incompatibleWith",     "label": "incompatibleWith" },

	{ "id": "owl:inverseOf",            "label": "inverseOf" },

	{ "id": "owl:propertyDisjointWith", "label": "propertyDisjointWith" },

	{ "id": "owl:sameAs",               "label": "sameAs" },

	{ "id": "owl:someValuesFrom",       "label": "someValuesFrom" },

	{ "id": "owl:unionOf",              "label": "unionOf" },

	{ "id": "skos:broader",       		"label": "broaderConcept" },

	{ "id": "skos:narrower",       		"label": "narrowerConcept" }

]

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean name="registryServiceVocabularyDAO" class="eu.dnetlib.functionality.modular.ui.vocabularies.persistence.RegistryServiceVocabularyDAO" />

	<alias name="${dnet.modular.ui.vocabulary.dao}" alias="vocabularyDao"/>

</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean name="/ui/vocabularies.do"

		class="eu.dnetlib.functionality.modular.ui.vocabularies.controllers.EntryPointController"

		p:menu="Vocabulary editor" 

		p:title="D-NET vocabulary editor"

		p:description="D-NET vocabulary editor" 

		p:group="Configuration">

		<property name="permissionLevels">

			<set>

				<value>USER</value>

			</set>

		</property>

	</bean>

</beans>

dnet.modular.ui.vocabulary.dao = registryServiceVocabularyDAO

$common/master( header={

	<script type="text/javascript" src="../resources/js/angular.min.js"></script>

	<script type="text/javascript" src="../resources/js/vocabularies.js"></script>

	<script type="text/javascript" src="../resources/js/uniqueChecker.js"></script>

	<script type="text/javascript" src="../resources/js/modalTerm.js"></script>

	<script type="text/javascript" src="../resources/js/modalInfo.js"></script>

	<script type="text/javascript" src="../resources/js/modalSynonym.js"></script>

	<script type="text/javascript" src="../resources/js/modalRelation.js"></script>

	<script type="text/javascript">

		function getValidRelations() {

			return $if(validRelations)$$validRelations$$else$[]$endif$;

		}

	</script>

}, body={

	<div ng-app="vocabulariesUI" ng-controller="vocabulariesCtrl">

		<div class="row">

			<vocabulary-list></vocabulary-list>

			<div class="col-xs-12 col-sm-12 col-md-9 col-lg-9" ng-show="entries != null && selectedVocabularyIndex != null" >

				<form role="form" class="form-inline">

					<div class="btn-group">

						<button type="button" class="btn btn-default" ng-click="showInfoModal()">

							Edit info <span class="glyphicon glyphicon-book"></span>

						</button>

						<button type="button" class="btn btn-default" ng-click="showTermModal(null)">

							New Term <span class="glyphicon glyphicon-pencil"></span>

						</button>

						<button type="button" class="btn btn-default" ng-click="commit()" ng-show="!autocommit">

							Commit <span class="glyphicon glyphicon-floppy-saved"></span>

						</button>

						<button type="button" class="btn btn-default" ng-click="reloadTerms()" ng-show="!autocommit">

							Discard all <span class="glyphicon glyphicon-repeat"></span>

						</button>

						<button type="button" class="btn btn-default" ng-click="reloadTerms()" ng-show="autocommit">

                            Refresh from IS <span class="glyphicon glyphicon-refresh"></span>

                        </button>

						<button type="button" class="btn btn-default" ng-click="dropVocabulary()">

							Drop vocabulary <span class="glyphicon glyphicon-trash"></span>

						</button>

					</div>

					<div class="checkbox">

                        <label><input type="checkbox" ng-model="autocommit"> Auto-commit</label>

                    </div>

					<div class="form-group pull-right">

						<input type="text" class="form-control" ng-model="termFilter" placeholder="Filter by...">

					</div>

				</form>

				<br><br>

				<term-list></term-list>

			</div>

		</div>

		<!-- infoModal -->

		<modal-info></modal-info>

		<!-- term Modal -->

		<modal-term></modal-term>

		<!-- synonymModal -->

		<modal-synonym></modal-synonym>

		<!-- relModal -->

		<modal-relation></modal-relation>

	</div>

} )$

<?xml version="1.0" encoding="UTF-8"?>

<RESOURCE_PROFILE xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

	<HEADER>

		<RESOURCE_IDENTIFIER value="" />

		<RESOURCE_TYPE value="VocabularyDSResourceType" />

		<RESOURCE_KIND value="VocabularyDSResources" />

		<RESOURCE_URI value="String" />

		<DATE_OF_CREATION value="$date$" />

	</HEADER>

	<BODY>

		<CONFIGURATION>

			<VOCABULARY_NAME code="$code$">$name$</VOCABULARY_NAME>

			<VOCABULARY_DESCRIPTION>$description$</VOCABULARY_DESCRIPTION>

			<TERMS>

				<TERM english_name="Example" encoding="en" native_name="Example" code="0000">

					<SYNONYMS>

						<SYNONYM encoding="it" term="Esempio" />

						<SYNONYM encoding="es" term="Ejemplo" />

						<SYNONYM encoding="el" term="μάθημα" />

						<SYNONYM encoding="zh" term="鉴戒" />

						<SYNONYM encoding="ja" term="事例" />

						<SYNONYM encoding="ru" term="пример" />

					</SYNONYMS>

					<RELATIONS />

				</TERM>

			</TERMS>

		</CONFIGURATION>

		<STATUS>

			<LAST_UPDATE value="$date$" />

		</STATUS>

		<SECURITY_PARAMETERS />

	</BODY>

</RESOURCE_PROFILE>

<TERMS>

	$terms:{t|

	<TERM native_name="$t.nativeName$" code="$t.code$" english_name="$t.englishName$" encoding="$t.encoding$">

        <SYNONYMS>

        	$t.synonyms:{s|

            <SYNONYM term="$s.term$" encoding="$s.encoding$"/>

            }$

        </SYNONYMS>

        <RELATIONS>

        	$t.relations:{r|

            <RELATION type="$r.type$" code="$r.code$"/>

            }$

        </RELATIONS>

    </TERM>

	}$

</TERMS>

<div class="panel-group" id="TermsAccordion">

	<div class="panel panel-default"

		ng-repeat="term in entries | filter:termFilter">

		<div class="panel-heading">

			<h4 class="panel-title">

				 <a data-toggle="collapse" data-parent="#accordion"

					href="#accordionTerm{{$index}}"><strong>{{term.code}}</strong> <br/> <span class="text-muted">{{term.englishName}}</span></a> <span

					class="pull-right">

					<button type="button" class="btn btn-xs btn-primary " ng-click="showTermModal(term)">

						<span class="glyphicon glyphicon-pencil"></span>

					</button>

					<button type="button" class="btn btn-xs btn-danger " ng-click="deleteTerm(term)">

						<span class="glyphicon glyphicon-trash"></span>

					</button>

				</span>

			</h4>

		</div>

		<div id="accordionTerm{{$index}}" class="panel-collapse collapse">

			<div class="panel-body">

				<ul class="nav nav-tabs">

					<li class="active"><a href="#accordionTerm{{$index}}_synonyms"

						data-toggle="tab">Synonyms</a></li>

					<li><a href="#accordionTerm{{$index}}_rels" data-toggle="tab">Relations</a></li>

				</ul>

				<div class="tab-content" style="margin-top: 10px;">

					<div class="tab-pane active" id="accordionTerm{{$index}}_synonyms">

						<p class="text-muted" ng-hide="term.synonyms.length > 0">No synonyms</p>

						<table class="table table-bordered table-striped" ng-show="term.synonyms.length > 0">

							<th>Synonym</th>

							<th>Encoding</th>

							<th>Operation</th>

							<tr ng-repeat="synonym in term.synonyms">

								<td class="col-md-8">{{synonym.term}}</td>

								<td class="col-md-4">{{synonym.encoding}}</td>

								<td class="col-md-1">

									<button type="button" class="btn btn-xs btn-primary" ng-click="showSynonymModal(term, synonym)">

										<span class="glyphicon glyphicon-pencil"></span>

									</button>

									<button type="button" class="btn btn-xs btn-danger" ng-click="deleteSynonym(term, synonym)">

										<span class="glyphicon glyphicon-trash"></span>

									</button>

								</td>

							</tr>

						</table>

						<button class="btn btn-xs btn-primary" type="button"

							ng-click="showSynonymModal(term, null)">

							<span class="glyphicon glyphicon-plus"></span>

						</button>

					</div>

					<div class="tab-pane" id="accordionTerm{{$index}}_rels">

						<p class="text-muted" ng-hide="term.relations.length > 0">No relations</p>

						<table class="table table-bordered table-striped" ng-show="term.relations.length > 0">

							<th>Related Term</th>

							<th>Relation Type</th>

							<th>Operation</th>

							<tr ng-repeat="rel in term.relations">

								<td class="col-md-8">{{rel.code}}</td>

								<td class="col-md-4">{{rel.type}}</td>

								<td class="col-md-1">

									<button type="button" class="btn btn-xs btn-primary" ng-click="showRelModal(term, rel)">

										<span class="glyphicon glyphicon-pencil"></span>

									</button>

									<button type="button" class="btn btn-xs btn-danger" ng-click="deleteRel(term, rel)">

										<span class="glyphicon glyphicon-trash"></span>

									</button>

								</td>

							</tr>

						</table>

						<button class="btn btn-xs btn-primary" type="button" ng-click="showRelModal(term, null)">

							<span class="glyphicon glyphicon-plus"></span>

						</button>

					</div>

				</div>

			</div>

		</div>

	</div>

</div>

<div class="column col-xs-12 col-sm-12 col-md-3 col-lg-3">

	<form role="form" class="form-inline">

		<button type="button" class="btn btn-default" ng-click="selectedVocabularyIndex = null; showInfoModal()">

			New vocabulary <span class="glyphicon glyphicon-plus"></span>

		</button>

		<div class="form-group pull-right">

			<input type="text" class="form-control" ng-model="vocabularyFilter" placeholder="Filter by...">

		</div>

	</form>

	<br/><br/>

	<ul class="nav nav-pills nav-stacked">

		<li ng-repeat="voc in vocabularies | filter:vocabularyFilter"

			ng-class="{'active': (selectedVocabularyIndex != null) && (voc.id == vocabularies[selectedVocabularyIndex].id)}"

			ng-click="loadTerms(voc)">

				<a>{{voc.name}}<span class="glyphicon glyphicon-chevron-right pull-right"/></a>

		</li>

	</ul>

</div>

<div class="modal fade" id="termModal" tabindex="-1" role="dialog" aria-labelledby="termModalLabel" aria-hidden="true">

	<div class="modal-dialog">

		<div class="modal-content">

			<div class="modal-header">

				<button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>

				<h4 id="termModalLabel">Term editor</h4>

			</div>

			<div class="modal-body">

				<form name="termForm" class="form-horizontal" role="form">

					<div class="form-group" ng-class="{'has-error': termForm.code.$error.unique, 'has-warning': !modalTerm.code}">

						<label class="col-sm-4 control-label" for="code">Code</label>

						<div class="col-sm-8">

							<input class="form-control" unique-code ng-disabled="selectedTermIndex != -1" type="text" name="code" placeholder="code" ng-model="modalTerm.code">

						</div>

					</div>

					<div class="form-group" ng-class="{'has-warning': !modalTerm.englishName}">

						<label class="col-sm-4 control-label" for="englishName">English name</label>

					    <div class="col-sm-8">

					    	<input class="form-control" unique-term type="text" name="englishName" placeholder="english name" ng-model="modalTerm.englishName">

					    </div>

					</div>

					<div class="form-group" ng-class="{'has-warning': !modalTerm.nativeName}">

						<label class="col-sm-4 control-label" for="nativeName">Native name</label>

						<div class="col-sm-8">

							<input class="form-control" type="text" name="nativeName" placeholder="native name" ng-model="modalTerm.nativeName">

						</div>

					</div>

					<div class="form-group" ng-class="{'has-warning': !modalTerm.encoding}">

						<label class="col-sm-4 control-label" for="encoding">Encoding</label>

						<div class="col-sm-8">

							<input class="form-control" type="text" name="encoding" placeholder="encoding" ng-model="modalTerm.encoding">

						</div>

					</div>

				</form>				

			</div>

			<div class="modal-footer">

				<button type="button" class="btn btn-primary" ng-disabled="(termForm.code.$error.unique)||(!modalTerm.code)||(!modalTerm.englishName)"

				        ng-click="editTerm()">Add to vocabulary

				</button>

			</div>

		</div>

	</div>

</div>

<div class="modal fade" id="infoModal" tabindex="-1" role="dialog" aria-labelledby="infoModalLabel" aria-hidden="true">

	<div class="modal-dialog">

		<div class="modal-content">

			<div class="modal-header">

				<button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>

				<h4 id="infoModalLabel">Vocabulary information</h4>

			</div>

			<div class="modal-body">

				<form name="infoForm" class="form-horizontal" role="form">

					<div class="form-group">

						<label class="col-sm-4 control-label" for="vocabularyId">Vocabulary ID &#160;<a href="isManager.do#/profile/{{modalInfo.id}}"><span class="glyphicon glyphicon-link"></span></a></label>

					    <div class="col-sm-8">

					      	<input class="form-control" ng-disabled="true" type="text" name="vocabularyId" ng-model="modalInfo.id">

					    </div>

					</div>

					<div class="form-group" ng-class="{'has-warning': !modalInfo.name}">

						<label class="col-sm-4 control-label" for="vocabularyName">Vocabulary name</label>

					    <div class="col-sm-8">

					      	<input class="form-control" ng-disabled="selectedVocabularyIndex != null" type="text" name="vocabularyName" placeholder="vocabulary name" ng-model="modalInfo.name">

					    </div>

					</div>

					<div class="form-group" ng-class="{'has-warning': !modalInfo.code}">

						<label class="col-sm-4 control-label" for="vocabularyCode">Vocabulary code</label>

						<div class="col-sm-8">

							<input class="form-control" ng-disabled="selectedVocabularyIndex != null" type="text" name="vocabularyCode" placeholder="vocabulary code" ng-model="modalInfo.code">

						</div>

					</div>

					<div class="form-group">

						<label class="col-sm-4 control-label" for="vocabularyDescription">Vocabulary description</label>

						<div class="col-sm-8">

							<textarea class="col-sm-12" rows="3" type="text" name="vocabularyDescription" placeholder="vocabulary description" ng-model="modalInfo.description"></textarea>

						</div>

					</div>

				</form>				

			</div>

			<div class="modal-footer">

				<button type="button" class="btn btn-primary" ng-disabled="(!modalInfo.name)||(!modalInfo.code)" ng-click="editInfo()">Save</button>

			</div>

		</div>

	</div>

</div>

<div class="modal fade" id="synonymModal" tabindex="-1" role="dialog" aria-labelledby="synonymModalLabel" aria-hidden="true">

	<div class="modal-dialog">

		<div class="modal-content">

			<div class="modal-header">

				<button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>

				<h4 id="synonymModalLabel">Synonym editor</h4>

			</div>

			<div class="modal-body">

				<form name="synonymForm" class="form-horizontal" role="form">

					<div class="form-group">

						<label class="col-sm-4 control-label" for="refterm">Ref. Term</label>

					    <div class="col-sm-8">

							<span id="refterm" class="form-control" type="text" disabled>{{modalSynonym.refTerm}}</span>

					    </div>

					</div>

					<div class="form-group" ng-class="{'has-error': synonymForm.term.$error.unique, 'has-warning': !modalSynonym.term}">

						<label class="col-sm-4 control-label" for="term">Term</label>

						<div class="col-sm-8">

							<input class="form-control" unique-synonym name="term" type="text" placeholder="new synonym" ng-model="modalSynonym.term">

						</div>

					</div>

					<div class="form-group" ng-class="{'has-warning': !modalSynonym.encoding}">

						<label class="col-sm-4 control-label" for="encoding">Encoding</label>

						<div class="col-sm-8">

							<input class="form-control" name="encoding" type="text" placeholder="encoding" ng-model="modalSynonym.encoding">

						</div>

					</div>

				</form>				

			</div>

			<div class="modal-footer">

				<button type="button" class="btn btn-primary" ng-disabled="(synonymForm.term.$error.unique)||(!modalSynonym.term) " ng-click="editSynonym()">Add

					to vocabulary

				</button>

			</div>

		</div>

	</div>

</div>

<div class="modal fade" id="relModal" tabindex="-1" role="dialog" aria-labelledby="relModalLabel" aria-hidden="true">

	<div class="modal-dialog">

		<div class="modal-content">

			<div class="modal-header">

				<button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>

				<h4 id="relModalLabel">Relation editor</h4>

			</div>

			<div class="modal-body">

				<form name="relForm" class="form-horizontal" role="form">

					<div class="form-group">

						<label class="col-sm-4 control-label" for="refterm">Ref. Term</label>

					    <div class="col-sm-8">

							<span id="refterm" class="form-control" type="text" disabled>{{modalRel.refTerm}}</span>

					    </div>

					</div>

					<div class="form-group" ng-class="{'has-warning': !modalRel.code}">

						<label class="col-sm-4 control-label" for="term">Related term</label>

						<div class="col-sm-8">

							<select class="form-control" ng-model="modalRel.code">

								<option value="">-- choose related term --</option>

								<option value="{{term.code}}" ng-repeat="term in entries" ng-selected="term.code == modalRel.code">{{term.code}}</option>

							</select>								

						</div>

					</div>

					<div class="form-group" ng-class="{'has-warning': !modalRel.type}">

						<label class="col-sm-4 control-label" for="encoding">Relation type</label>

						<div class="col-sm-8">

							<select class="form-control" ng-model="modalRel.type">

								<option value="">-- choose relation type --</option>

								<option value="{{rt.id}}" ng-repeat="rt in validRelations" ng-selected="rt.id == modalRel.type">{{rt.label}}</option>

							</select>

						</div>

					</div>

				</form>				

			</div>

			<div class="modal-footer">

				<button type="button" class="btn btn-primary" ng-disabled="!(modalRel.type && modalRel.code) " ng-click="editRel()">Save</button>

			</div>

		</div>

	</div>

</div>

var module = angular.module('modalTerm', []);

module.directive('modalTerm', function() {

	return {

		restrict: 'E',

		templateUrl: '../resources/html/vocabularies/modalTerm.html',

		controller: function($scope){

			$scope.showTermModal = function(term) {

				$scope.selectedTermIndex = $scope.entries.indexOf(term);

				if (term != null) {

					// edit existing term

					$scope.modalTerm.englishName = term.englishName;

					$scope.modalTerm.nativeName = term.nativeName;

					$scope.modalTerm.encoding = term.encoding;

					$scope.modalTerm.code = term.code;

				} else {

					// edit new term

					$scope.modalTerm.englishName = '';

					$scope.modalTerm.nativeName = '';

					$scope.modalTerm.encoding = '';

					$scope.modalTerm.code = '';

				}

				$('#termModal').modal();

			};

			$scope.editTerm = function() {

				if ($scope.selectedTermIndex == -1) {

					// new term

					$scope.entries.push({

						"englishName" : $scope.modalTerm.englishName,

						"nativeName" : $scope.modalTerm.nativeName,

						"encoding" : $scope.modalTerm.encoding,

						"synonyms" : [],

						"code" : $scope.modalTerm.code

					});

				} else {

					// term update

					$scope.entries[$scope.selectedTermIndex].englishName = $scope.modalTerm.englishName;

					$scope.entries[$scope.selectedTermIndex].nativeName = $scope.modalTerm.nativeName;

					$scope.entries[$scope.selectedTermIndex].encoding = $scope.modalTerm.encoding;

					$scope.entries[$scope.selectedTermIndex].code = $scope.modalTerm.code;

				}

				// dismiss modal

				$('.modal').modal('hide');

				if ($scope.autocommit) {

					$scope.commit();

				} else {

					showPermanotice("Uncommitted changes!");

				}

			}

		},

		controllerAs: 'modalTerm'

	};

});

var module = angular.module('modalInfo', []);

module.directive('modalInfo', function(){

	return {

		restrict: 'E',

		templateUrl: '../resources/html/vocabularies/modalInfo.html',

		controller: function($scope, $http){

			$scope.showInfoModal = function() {

				if ($scope.selectedVocabularyIndex != null) {

					// show modal for editing info of existing vocabulary

					$scope.modalInfo.id = $scope.vocabularies[$scope.selectedVocabularyIndex].id;

					$scope.modalInfo.name = $scope.vocabularies[$scope.selectedVocabularyIndex].name;

					$scope.modalInfo.code = $scope.vocabularies[$scope.selectedVocabularyIndex].code;

					$scope.modalInfo.description = $scope.vocabularies[$scope.selectedVocabularyIndex].description;

				} else {

					// show modal for new vocabulary

					$scope.modalInfo.id = '';

					$scope.modalInfo.name = '';

					$scope.modalInfo.code = '';

					$scope.modalInfo.description = '';

					hidePermanotice();

				}

				$('#infoModal').modal();

			}

			$scope.editInfo = function() {

				showSpinner();

				if ($scope.selectedVocabularyIndex == null) {

					// new vocabulary

					$http.post('createVocabulary', 

								{"name" : $scope.modalInfo.name, 

								"code" : $scope.modalInfo.code, 

								"description" : $scope.modalInfo.description})

						.success(

							function(data) {

								show_notification("success", "Vocabulary created successfully!");

								$scope.vocabularies.push({

									"id" : data,

									"name" : $scope.modalInfo.name,

									"code" : $scope.modalInfo.code,

									"description" : $scope.modalInfo.description

								});

								hideSpinner();

								$scope.loadVocabularies();

							})

						.error(

							function() {

								show_notification("error", "Cannot edit info..");

								hideSpinner();

							});

				} else {

					// edit vocabulary

					$http.post('commitVocabularyInfo?vocabularyId=' + $scope.vocabularies[$scope.selectedVocabularyIndex].id, 

								{"name" : $scope.modalInfo.name, 

								"code" : $scope.modalInfo.code, 

								"description" : $scope.modalInfo.description})

						.success(

							function() {

								// update model

								$scope.vocabularies[$scope.selectedVocabularyIndex].id = $scope.modalInfo.id;

								$scope.vocabularies[$scope.selectedVocabularyIndex].name = $scope.modalInfo.name;

								$scope.vocabularies[$scope.selectedVocabularyIndex].code = $scope.modalInfo.code;

								$scope.vocabularies[$scope.selectedVocabularyIndex].description = $scope.modalInfo.description;

								show_notification("success", "Vocabulary information saved correctly!");

								hideSpinner();

								$scope.loadVocabularies();

							})

						.error(

							function() {

								show_notification("error", "Cannot edit info..");

								hideSpinner();

							});

				}

				// dismiss modal

				$('.modal').modal('hide');

			}

		},

		controllerAs: 'modalInfo'

	};

});

var module = angular.module('modalSynonym', []);

module.directive('modalSynonym', function(){

	return {

		restrict: 'E',

		templateUrl: '../resources/html/vocabularies/modalSynonym.html',

		controller: function($scope){

			$scope.showSynonymModal = function(term, synonym) {

				$scope.selectedTermIndex = $scope.entries.indexOf(term);

				$scope.selectedSynonymIndex = $scope.entries[$scope.selectedTermIndex].synonyms.indexOf(synonym);

				if (synonym != null) {

					// edit existing synonym

					$scope.modalSynonym.refTerm = $scope.entries[$scope.selectedTermIndex].englishName;

					$scope.modalSynonym.term = $scope.entries[$scope.selectedTermIndex].synonyms[$scope.selectedSynonymIndex].term;

					$scope.modalSynonym.encoding = $scope.entries[$scope.selectedTermIndex].synonyms[$scope.selectedSynonymIndex].encoding;

				} else {

					// new synonym

					$scope.modalSynonym.refTerm = $scope.entries[$scope.selectedTermIndex].englishName;

					$scope.modalSynonym.term = '';

					$scope.modalSynonym.encoding = '';

				}

				$('#synonymModal').modal();

			};

			$scope.editSynonym = function() {

				if ($scope.selectedSynonymIndex == -1) {

					$scope.entries[$scope.selectedTermIndex].synonyms.push({

						"term" : $scope.modalSynonym.term,

						"encoding" : $scope.modalSynonym.encoding

					});

				} else {

					$scope.entries[$scope.selectedTermIndex].synonyms[$scope.selectedSynonymIndex].term = $scope.modalSynonym.term;

					$scope.entries[$scope.selectedTermIndex].synonyms[$scope.selectedSynonymIndex].encoding = $scope.modalSynonym.encoding;

				}

				// dismiss modal

				$('.modal').modal('hide');

				if ($scope.autocommit) {

					$scope.commit();

				} else {

					showPermanotice("Uncommitted changes!");

				}

			}

		},

		controllerAs: 'modalSynonym'

	}

});

var module = angular.module('modalRelation', []);

module.directive('modalRelation', function(){

	return {

		restrict: 'E',

		templateUrl: '../resources/html/vocabularies/modalRelation.html',

		controller: function($scope) {

			$scope.showRelModal = function(term, rel) {

				$scope.selectedTermIndex = $scope.entries.indexOf(term);

				$scope.selectedRelIndex = $scope.entries[$scope.selectedTermIndex].relations.indexOf(rel);

				if (rel != null) {

					// edit existing synonym

					$scope.modalRel.refTerm = $scope.entries[$scope.selectedTermIndex].englishName;

					$scope.modalRel.code = $scope.entries[$scope.selectedTermIndex].relations[$scope.selectedRelIndex].code;

					$scope.modalRel.type = $scope.entries[$scope.selectedTermIndex].relations[$scope.selectedRelIndex].type;

				} else {

					// new synonym

					$scope.modalRel.refTerm = $scope.entries[$scope.selectedTermIndex].englishName;

					$scope.modalRel.code = '';

					$scope.modalRel.type = '';

				}

				$('#relModal').modal();

			};

			$scope.editRel = function() {

				if ($scope.selectedRelIndex == -1) {

					$scope.entries[$scope.selectedTermIndex].relations.push({

						"code" : $scope.modalRel.code,

						"type" : $scope.modalRel.type

					});

				} else {

					$scope.entries[$scope.selectedTermIndex].relations[$scope.selectedRelIndex].code = $scope.modalRel.code;

					$scope.entries[$scope.selectedTermIndex].relations[$scope.selectedRelIndex].type = $scope.modalRel.type;

				}

				// dismiss modal

				$('.modal').modal('hide');

				if ($scope.autocommit) {

					$scope.commit();

				} else {

					showPermanotice("Uncommitted changes!");

				}

			}

		},

		controllerAs: 'modalRelation'

	};

});

var module = angular.module('uniqueChecker', []);

module.directive('uniqueTerm', function() {

    return {

      restrict: 'A',

      require: 'ngModel',

      link: function (scope, element, attrs, ngModel) {

	            function validateTerm() {

	            	ngModel.$setValidity('unique', true);

	            	if (!scope.modalTerm.englishName || (scope.selectedTermIndex != -1 && scope.modalTerm.englishName.toLowerCase() == scope.entries[scope.selectedTermIndex].englishName.toLowerCase())) {

	            		return;

	            	}

	            	for (i in scope.entries) {

	            		if (scope.entries[i].englishName.toLowerCase() == scope.modalTerm.englishName.toLowerCase()) {

	            			ngModel.$setValidity('unique', false);

	            			return;

	            		}

	            		for (j in scope.entries[i].synonyms) {

	            			if (scope.entries[i].synonyms[j].term.toLowerCase() == scope.modalTerm.englishName.toLowerCase()) {

		            			ngModel.$setValidity('unique', false);

		            			return;

		            		}

	            		}

	            	}

	            }

	            // register callback (validate) for $scope.modalTerm.englishName

	            scope.$watch( 

	        		function() {

	        			return scope.modalTerm.englishName;

	        		}, validateTerm);

	        }

    };

});

module.directive('uniqueCode', function() {

  return {

    restrict: 'A',

    require: 'ngModel',

    link: function (scope, element, attrs, ngModel) {

	          function validateCode() {

		          	ngModel.$setValidity('unique', true);

		          	if (!scope.modalTerm.code || (scope.selectedTermIndex != -1 && scope.modalTerm.code.toLowerCase() == scope.entries[scope.selectedTermIndex].code.toLowerCase())) {

		          		return;

		          	}

		          	for (i in scope.entries) {

		          		if (scope.modalTerm.code.toLowerCase() == scope.entries[i].code.toLowerCase()) {

		          			ngModel.$setValidity('unique', false);

		          		}

		          	}

	          	}

	          // register callback (validate) for $scope.modalTerm.code

	          scope.$watch( 

	          		function() {

	          			return scope.modalTerm.code;

	          		}, validateCode);

	      	}

  };

});

module.directive('uniqueSynonym', function() {

  return {

    restrict: 'A',

    require: 'ngModel',

    link: function (scope, element, attrs, ngModel) {

	    	  function validateSynonym() {

	    		  ngModel.$setValidity('unique', true);

	          		if (!scope.modalSynonym.term || (scope.selectedSynonymIndex != -1 && scope.modalSynonym.term.toLowerCase() == scope.entries[scope.selectedTermIndex].synonyms[scope.selectedSynonymIndex].term.toLowerCase())) {

	          			return;

	          		}

	          		for (i in scope.entries) {

		          		for (j in scope.entries[i].synonyms) {

		          			if (scope.entries[i].synonyms[j].term.toLowerCase() == scope.modalSynonym.term.toLowerCase()) {

		            			ngModel.$setValidity('unique', false);

		            			return;

		            		}

		          		}

	          		}

	          	}

	          	// register callback (validate) for $scope.modalTerm.englishName

	          	scope.$watch( 

		      		function() {

		      			return scope.modalSynonym.term;

		      		}, validateSynonym);

	      }

  };

});

var module = angular.module('vocabulariesUI', ['uniqueChecker', 'modalTerm', 'modalInfo', 'modalSynonym', 'modalRelation']);

module.directive('vocabularyList', function(){

	return {

		restrict: 'E',

		templateUrl: '../resources/html/vocabularies/vocabulary-list.html'

	};

});

module.directive('termList', function(){

	return {

		restrict: 'E',

		templateUrl: '../resources/html/vocabularies/term-list.html'

	};

});

module.controller('vocabulariesCtrl', function ($scope, $http) {

	$scope.entries = [];

	$scope.modalSynonym = {};

	$scope.modalRel = {};

	$scope.modalTerm = {};

	$scope.modalInfo = {};

	$scope.validRelations = getValidRelations();

	$scope.autocommit = false;

	initSpinner();

	showSpinner();

	$scope.loadVocabularies = function() {

		$http.get('vocabularies.json')

		.success(

			function(data) {

				$scope.vocabularies = data;

				hideSpinner();

			})

		.error(

			function() {

				show_notification("error", "An error occurred while loading registered vocabulary profiles..");

				hideSpinner();

			});

	};

	$scope.loadVocabularies();

	/*---------LOAD TERMS---------*/

	$scope.loadTerms = function(vocabulary) {

		//		// check if same vocabulary

		//		if ($scope.selectedVocabularyIndex != null && vocabulary.id == $scope.vocabularies[$scope.selectedVocabularyIndex].id) {

		//			return;

		//		}

		// prompt for uncommitted changes

		if (probePermanotice() == true) {

			var r=confirm("Switching vocabulary means losing uncommitted changes.. Are you fine with that?");

			if (r == false) {

				return;

			}

		}

		//actually load terms