1369 lines
51 KiB
Java
1369 lines
51 KiB
Java
package org.gcube.portlets.widgets.ckandatapublisherwidget.server;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Calendar;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Set;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.function.Function;
|
|
import java.util.stream.Collectors;
|
|
|
|
import javax.servlet.http.HttpSession;
|
|
|
|
import org.gcube.common.portal.PortalContext;
|
|
import org.gcube.common.storagehubwrapper.server.StorageHubWrapper;
|
|
import org.gcube.common.storagehubwrapper.server.tohl.Workspace;
|
|
import org.gcube.datacatalogue.utillibrary.server.DataCatalogue;
|
|
import org.gcube.datacatalogue.utillibrary.server.DataCatalogueFactory;
|
|
import org.gcube.datacatalogue.utillibrary.server.utils.CatalogueUtilMethods;
|
|
import org.gcube.datacatalogue.utillibrary.server.utils.SessionCatalogueAttributes;
|
|
import org.gcube.datacatalogue.utillibrary.shared.ResourceBean;
|
|
import org.gcube.datacatalogue.utillibrary.shared.RolesCkanGroupOrOrg;
|
|
import org.gcube.datacatalogue.utillibrary.shared.jackan.model.CkanDataset;
|
|
import org.gcube.datacatalogue.utillibrary.shared.jackan.model.CkanGroup;
|
|
import org.gcube.datacatalogue.utillibrary.shared.jackan.model.CkanLicense;
|
|
import org.gcube.datacatalogue.utillibrary.shared.jackan.model.CkanOrganization;
|
|
import org.gcube.datacatalogue.utillibrary.shared.jackan.model.CkanResource;
|
|
import org.gcube.datacatalogue.utillibrary.shared.jackan.model.CkanTag;
|
|
import org.gcube.portlets.user.uriresolvermanager.UriResolverManager;
|
|
import org.gcube.portlets.user.uriresolvermanager.exception.UriResolverMapException;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.client.CKanPublisherService;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.server.utils.CatalogueRoleManager;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.server.utils.DiscoverTagsList;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.server.utils.GenericUtils;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.server.utils.MetadataDiscovery;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.server.utils.WorkspaceUtils;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.DatasetBean;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.MetadataProfileBeanForUpdate;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.OrganizationBean;
|
|
import org.gcube.portlets.widgets.ckandatapublisherwidget.shared.ResourceElementBean;
|
|
import org.gcube.portlets.widgets.mpformbuilder.shared.license.LicenseBean;
|
|
import org.gcube.portlets.widgets.mpformbuilder.shared.metadata.MetaDataProfileBean;
|
|
import org.gcube.portlets.widgets.mpformbuilder.shared.metadata.MetadataFieldWrapper;
|
|
import org.gcube.vomanagement.usermanagement.GroupManager;
|
|
import org.gcube.vomanagement.usermanagement.UserManager;
|
|
import org.gcube.vomanagement.usermanagement.exception.GroupRetrievalFault;
|
|
import org.gcube.vomanagement.usermanagement.exception.UserManagementSystemException;
|
|
import org.gcube.vomanagement.usermanagement.impl.LiferayGroupManager;
|
|
import org.gcube.vomanagement.usermanagement.impl.LiferayUserManager;
|
|
import org.gcube.vomanagement.usermanagement.model.GCubeUser;
|
|
import org.geojson.GeoJsonObject;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
|
|
import com.liferay.portal.service.UserLocalServiceUtil;
|
|
|
|
/**
|
|
* Server side of the data publisher.
|
|
*
|
|
* @author Costantino Perciante at ISTI-CNR (costantino.perciante@isti.cnr.it)
|
|
*/
|
|
public class CKANPublisherServicesImpl extends RemoteServiceServlet implements CKanPublisherService {
|
|
|
|
private static final long serialVersionUID = 7252248774050361697L;
|
|
|
|
// Logger
|
|
// private static final org.slf4j.Logger logger =
|
|
// LoggerFactory.getLogger(CKANPublisherServicesImpl.class);
|
|
private static final Logger logger = LoggerFactory.getLogger(CKANPublisherServicesImpl.class);
|
|
public static final String ITEM_URL_FIELD = "Item URL";
|
|
public static final String SYSTEM_KEY_PREFIX = "system:";
|
|
public static final String SYS_TYPE = SYSTEM_KEY_PREFIX + "type";
|
|
public static final String TAGS_VOCABULARY_KEY = "TAGS_VOCABULARY";
|
|
|
|
public static final List<String> SYSTEM_CUSTOM_FIELDS_PREFIXES = Arrays.asList(ITEM_URL_FIELD, SYSTEM_KEY_PREFIX);
|
|
|
|
// map <orgName, scope>
|
|
private ConcurrentHashMap<String, String> mapOrganizationScope = new ConcurrentHashMap<String, String>();
|
|
|
|
/**
|
|
* Dev mode set contexts.
|
|
*/
|
|
private void devModeSetContexts() {
|
|
if (!isWithinPortal()) {
|
|
logger.info("DETECTED DEV MODE");
|
|
GenericUtils.getCurrentContext(getThreadLocalRequest(), true);
|
|
GenericUtils.getCurrentToken(getThreadLocalRequest(), true);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Retrieve an instance of the library for the scope.
|
|
*
|
|
* @param scope if it is null it is evaluated from the session
|
|
* @return the catalogue
|
|
*/
|
|
public DataCatalogue getCatalogue(String scope) {
|
|
|
|
DataCatalogue instance = null;
|
|
String scopeInWhichDiscover = null;
|
|
try {
|
|
scopeInWhichDiscover = scope != null && !scope.isEmpty() ? scope
|
|
: GenericUtils.getCurrentContext(getThreadLocalRequest(), false);
|
|
logger.debug("Discovering ckan instance into scope " + scopeInWhichDiscover);
|
|
instance = DataCatalogueFactory.getFactory().getUtilsPerScope(scopeInWhichDiscover);
|
|
} catch (Exception e) {
|
|
logger.warn("Unable to retrieve ckan utils in scope " + scopeInWhichDiscover + ". Error is "
|
|
+ e.getLocalizedMessage());
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the list of organizations in which the user can publish (roles
|
|
* ADMIN/EDITOR).
|
|
*
|
|
* @param username the username
|
|
* @param scope the scope
|
|
* @return the list of organizations
|
|
* @throws UserManagementSystemException the user management system exception
|
|
* @throws GroupRetrievalFault the group retrieval fault
|
|
*/
|
|
private List<OrganizationBean> getUserOrganizationsListAdmin(String username, String scope)
|
|
throws UserManagementSystemException, GroupRetrievalFault {
|
|
|
|
logger.debug("Request for user " + username + " organizations list");
|
|
List<OrganizationBean> orgsName = new ArrayList<OrganizationBean>();
|
|
|
|
HttpSession httpSession = getThreadLocalRequest().getSession();
|
|
String keyPerScope = CatalogueUtilMethods
|
|
.concatenateSessionKeyScope(SessionCatalogueAttributes.CKAN_ORGANIZATIONS_PUBLISH_KEY, scope);
|
|
|
|
if (httpSession.getAttribute(keyPerScope) != null) {
|
|
orgsName = (List<OrganizationBean>) httpSession.getAttribute(keyPerScope);
|
|
logger.info("List of organizations was into session " + orgsName);
|
|
} else {
|
|
String gatewayURL = GenericUtils.getGatewayClientHostname(getThreadLocalRequest());
|
|
logger.info("The Gateway URL is: " + gatewayURL);
|
|
CatalogueRoleManager.getHighestRole(scope, username, GenericUtils.getGroupFromScope(scope).getGroupName(),
|
|
this, orgsName, gatewayURL);
|
|
httpSession.setAttribute(keyPerScope, orgsName);
|
|
logger.info("Organizations name for user " + username + " has been saved into session " + orgsName);
|
|
}
|
|
|
|
return orgsName;
|
|
}
|
|
|
|
/**
|
|
* Online or in development mode?.
|
|
*
|
|
* @return true if you're running into the portal, false if in development
|
|
*/
|
|
private boolean isWithinPortal() {
|
|
try {
|
|
UserLocalServiceUtil.getService();
|
|
return true;
|
|
} catch (com.liferay.portal.kernel.bean.BeanLocatorException ex) {
|
|
logger.trace("Development Mode ON");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the workspace from storage hub.
|
|
*
|
|
* @return the workspace from storage hub
|
|
* @throws Exception the exception
|
|
*/
|
|
protected Workspace getWorkspaceFromStorageHub() throws Exception {
|
|
GCubeUser user = PortalContext.getConfiguration().getCurrentUser(this.getThreadLocalRequest());
|
|
StorageHubWrapper storageHubWrapper = WorkspaceUtils.getStorageHubWrapper(this.getThreadLocalRequest(), null,
|
|
user);
|
|
return storageHubWrapper.getWorkspace();
|
|
}
|
|
|
|
/**
|
|
* Find a license id given the license text.
|
|
*
|
|
* @param chosenLicense the chosen license
|
|
* @return the string
|
|
*/
|
|
private String findLicenseIdByLicense(String chosenLicense) {
|
|
|
|
// get scope from client url
|
|
String scope = GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
return getCatalogue(scope).findLicenseIdByLicenseTitle(chosenLicense);
|
|
|
|
}
|
|
|
|
/**
|
|
* Gets the licenses.
|
|
*
|
|
* @return the licenses
|
|
*/
|
|
@Override
|
|
public List<LicenseBean> getLicenses() {
|
|
|
|
// get http session
|
|
HttpSession httpSession = getThreadLocalRequest().getSession();
|
|
String scope = GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
logger.info("Request for CKAN licenses for scope " + scope);
|
|
String keyPerScope = CatalogueUtilMethods
|
|
.concatenateSessionKeyScope(SessionCatalogueAttributes.CKAN_LICENSES_KEY, scope);
|
|
|
|
// if(!isWithinPortal()){
|
|
// logger.info("DEV MODE returning funny licenses...");
|
|
// List<LicenseBean> licenses = new ArrayList<LicenseBean>();
|
|
// licenses.add(new LicenseBean("AFL-3.0", "https://opensource.org/licenses/AFL-3.0"));
|
|
// return licenses;
|
|
// }
|
|
|
|
List<LicenseBean> licensesBean = null;
|
|
if (httpSession.getAttribute(keyPerScope) != null) {
|
|
licensesBean = (List<LicenseBean>) httpSession.getAttribute(keyPerScope);
|
|
logger.info("List of licenses was into session");
|
|
} else {
|
|
List<CkanLicense> licenses = getCatalogue(scope).getLicenses();
|
|
licensesBean = new ArrayList<LicenseBean>();
|
|
for (CkanLicense license : licenses) {
|
|
licensesBean.add(new LicenseBean(license.getTitle(), license.getUrl()));
|
|
}
|
|
|
|
// sort the list
|
|
Collections.sort(licensesBean, new Comparator<LicenseBean>() {
|
|
public int compare(LicenseBean l1, LicenseBean l2) {
|
|
return l1.getTitle().compareTo(l2.getTitle());
|
|
}
|
|
});
|
|
|
|
httpSession.setAttribute(keyPerScope, licensesBean);
|
|
logger.info("List of licenses has been saved into session");
|
|
}
|
|
|
|
return licensesBean;
|
|
}
|
|
|
|
/**
|
|
* Gets the dataset bean.
|
|
*
|
|
* @param folderId the folder id
|
|
* @return the dataset bean
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public DatasetBean getDatasetBean(String folderId) throws Exception {
|
|
|
|
DatasetBean bean = null;
|
|
String userName = GenericUtils.getCurrentUser(getThreadLocalRequest()).getUsername();
|
|
|
|
logger.info("DatasetBean request for folderId " + folderId + " and " + userName);
|
|
|
|
if (isWithinPortal()) {
|
|
try {
|
|
|
|
String scope = GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
|
|
logger.debug("Scope recovered from session is " + scope);
|
|
logger.debug(
|
|
"Request dataset metadata bean for folder with id " + folderId + " whose owner is " + userName);
|
|
|
|
UserManager liferUserManager = new LiferayUserManager();
|
|
GCubeUser userOwner = liferUserManager.getUserByUsername(userName);
|
|
|
|
// build bean
|
|
logger.debug("Building bean");
|
|
bean = new DatasetBean();
|
|
|
|
bean.setId(folderId);
|
|
bean.setOwnerIdentifier(userName);
|
|
bean.setVersion(1);
|
|
bean.setAuthorName(userOwner.getFirstName());
|
|
bean.setAuthorSurname(userOwner.getLastName());
|
|
bean.setAuthorEmail(userOwner.getEmail());
|
|
bean.setMaintainer(userOwner.getFullname());
|
|
bean.setMaintainerEmail(userOwner.getEmail());
|
|
bean.setOrganizationList(getUserOrganizationsListAdmin(userName, scope));
|
|
bean.setTagsVocabulary(discoverTagsVocabulary(scope));
|
|
|
|
// if the request comes from the workspace
|
|
if (folderId != null && !folderId.isEmpty()) {
|
|
Workspace workspace = getWorkspaceFromStorageHub();
|
|
WorkspaceUtils.toWorkspaceResource(folderId, userName, bean, workspace);
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error while retrieving bean information", e);
|
|
throw new Exception("Error while retrieving basic information " + e.getMessage());
|
|
}
|
|
} else {
|
|
|
|
logger.info("DEV MODE DETECTED");
|
|
GenericUtils.getCurrentToken(getThreadLocalRequest(), true);
|
|
|
|
try {
|
|
bean = new DatasetBean();
|
|
bean.setId(folderId);
|
|
bean.setDescription("This is a fantastic description");
|
|
bean.setVersion(1);
|
|
String onlyAlphanumeric = "test-creation-blablabla".replaceAll("[^A-Za-z0-9]", "");
|
|
bean.setTitle(onlyAlphanumeric + Calendar.getInstance().getTimeInMillis());
|
|
bean.setAuthorName("Francesco");
|
|
bean.setAuthorSurname("Mangiacrapa");
|
|
bean.setAuthorEmail("francesco.mangiacrapa@isti.cnr.it");
|
|
bean.setMaintainer("Francesco Mangiacrapa");
|
|
bean.setMaintainerEmail("francesco.mangiacrapa@isti.cnr.it");
|
|
|
|
// UPDATED By Francesco
|
|
String scope = GenericUtils.getCurrentContext(this.getThreadLocalRequest(), false);
|
|
String vreName = scope.substring(scope.lastIndexOf("/") + 1, scope.length());
|
|
logger.debug("In dev mode using the scope: " + scope + " and VRE name: " + vreName);
|
|
bean.setOrganizationList(Arrays.asList(new OrganizationBean(vreName, vreName.toLowerCase(), true)));
|
|
|
|
bean.setOwnerIdentifier(userName);
|
|
|
|
if (folderId != null && !folderId.isEmpty()) {
|
|
Workspace workspace = getWorkspaceFromStorageHub();
|
|
WorkspaceUtils.toWorkspaceResource(folderId, userName, bean, workspace);
|
|
}
|
|
} catch (Exception e) {
|
|
logger.error("Error while building bean into dev mode", e);
|
|
throw new Exception("Error while retrieving basic information " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
logger.debug("Returning bean " + bean);
|
|
return bean;
|
|
}
|
|
|
|
/**
|
|
* Gets the dataset bean for update.
|
|
*
|
|
* @param datasetIdOrName the dataset id or name
|
|
* @return the dataset bean for update
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public DatasetBean getDatasetBeanForUpdate(String datasetIdOrName) throws Exception {
|
|
|
|
DatasetBean bean = null;
|
|
String userName = GenericUtils.getCurrentUser(getThreadLocalRequest()).getUsername();
|
|
|
|
logger.info("DatasetBeanForUpdate request for " + datasetIdOrName + " and " + userName);
|
|
|
|
String scopePerCurrentUrl = GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
|
|
DataCatalogue utils = getCatalogue(scopePerCurrentUrl);
|
|
|
|
CkanDataset dataset = utils.getDataset(datasetIdOrName, userName);
|
|
|
|
if (dataset == null) {
|
|
// the user cannot read the item, so he/she is not the owner nor the admin
|
|
throw new Exception("Dataset with id " + datasetIdOrName + " not found for user " + userName);
|
|
}
|
|
|
|
logger.debug("Building bean");
|
|
bean = new DatasetBean();
|
|
|
|
bean.setId(datasetIdOrName);
|
|
bean.setCkanName(dataset.getName());
|
|
bean.setTitle(dataset.getTitle());
|
|
bean.setDescription(dataset.getNotes());
|
|
bean.setLicense(dataset.getLicenseTitle());
|
|
bean.setVisibile(dataset.isPriv());
|
|
|
|
long version = 1;
|
|
try {
|
|
version = Long.parseLong(dataset.getVersion());
|
|
} catch (Exception e) {
|
|
// TODO: handle exception
|
|
}
|
|
bean.setVersion(version);
|
|
|
|
bean.setOwnerIdentifier(dataset.getCreatorUserId());
|
|
|
|
bean.setAuthorFullName(dataset.getAuthor());
|
|
bean.setAuthorEmail(dataset.getAuthorEmail());
|
|
|
|
bean.setMaintainer(dataset.getMaintainer());
|
|
bean.setMaintainerEmail(dataset.getMaintainerEmail());
|
|
|
|
CkanOrganization ckanOrganization = dataset.getOrganization();
|
|
|
|
// UPDATED By Francesco
|
|
final OrganizationBean ckanOrganizationBean = new OrganizationBean(ckanOrganization.getTitle(),
|
|
ckanOrganization.getName(), true);
|
|
bean.setOrganizationList(Arrays.asList(ckanOrganizationBean));
|
|
|
|
List<CkanTag> listDatasetTags = dataset.getTags();
|
|
|
|
if (logger.isDebugEnabled()) {
|
|
logger.debug("List tags from CKAN are: ");
|
|
for (CkanTag ckanTag : listDatasetTags) {
|
|
// logger.debug("ckanTag: " + ckanTag.getDisplayName());
|
|
logger.debug("ckanTag: " + ckanTag.getName());
|
|
}
|
|
}
|
|
|
|
// selected tags into Dataset
|
|
if (listDatasetTags != null) {
|
|
List<String> listTags = dataset.getTags().stream().map(t -> t.getName()).collect(Collectors.toList());
|
|
logger.info("setTags: {}", listTags);
|
|
bean.setTags(listTags);
|
|
}
|
|
|
|
// Vocabulary Tags from Generi Resources
|
|
bean.setTagsVocabulary(discoverTagsVocabulary(scopePerCurrentUrl));
|
|
|
|
// Settings the CKAN resources
|
|
List<CkanResource> resources = dataset.getResources();
|
|
if (resources != null) {
|
|
List<ResourceElementBean> list = new ArrayList<ResourceElementBean>(resources.size());
|
|
for (CkanResource ckanResource : resources) {
|
|
ResourceElementBean reb = PublisherCatalogueConveter.toResourceElementBean(ckanResource,
|
|
ckanOrganizationBean.getName());
|
|
list.add(reb);
|
|
}
|
|
bean.setResources(list);
|
|
}
|
|
|
|
// Settings the dataset type
|
|
Map<String, List<String>> extras = dataset.getListExtrasAsHashMap();
|
|
if (extras != null) {
|
|
List<String> theDatasetType = extras.get(SYS_TYPE);
|
|
if (theDatasetType != null && theDatasetType.size() > 0) {
|
|
bean.setChosenType(theDatasetType.get(0));
|
|
}
|
|
}
|
|
|
|
logger.debug("Returning bean " + bean);
|
|
logger.info("Returning the bean for dataset title {} and type {}" + bean.getTitle(), bean.getChosenType());
|
|
return bean;
|
|
}
|
|
|
|
/**
|
|
* Discover from the IS the vocabulary of tags for this scope, if present.
|
|
*
|
|
* @param context the context
|
|
* @return a list of tags vocabulary
|
|
*/
|
|
private List<String> discoverTagsVocabulary(String context) {
|
|
|
|
logger.debug("Looking for vocabulary of tags in this context " + context);
|
|
String keyPerVocabulary = CatalogueUtilMethods.concatenateSessionKeyScope(TAGS_VOCABULARY_KEY, context);
|
|
|
|
List<String> vocabulary = (List<String>) getThreadLocalRequest().getSession().getAttribute(keyPerVocabulary);
|
|
if (vocabulary == null) {
|
|
vocabulary = DiscoverTagsList.discoverTagsList(context);
|
|
if (vocabulary != null)
|
|
getThreadLocalRequest().getSession().setAttribute(keyPerVocabulary, vocabulary);
|
|
}
|
|
|
|
logger.debug("Vocabulary for tags is " + vocabulary);
|
|
|
|
return vocabulary;
|
|
}
|
|
|
|
/**
|
|
* Gets the tags for organization.
|
|
*
|
|
* @param orgName the org name
|
|
* @return the tags for organization
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public List<String> getTagsForOrganization(String orgName) throws Exception {
|
|
return discoverTagsVocabulary(getScopeFromOrgName(orgName));
|
|
}
|
|
|
|
/**
|
|
* Creates the C kan dataset.
|
|
*
|
|
* @param toCreate the to create
|
|
* @return the dataset bean
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public DatasetBean createCKanDataset(DatasetBean toCreate) throws Exception {
|
|
|
|
try {
|
|
devModeSetContexts();
|
|
logger.info("Request for creating a dataset with title: {} " + toCreate.getTitle());
|
|
if (logger.isDebugEnabled()) {
|
|
logger.debug("Dataset is: {} " + toCreate);
|
|
}
|
|
String userName = GenericUtils.getCurrentUser(getThreadLocalRequest()).getUsername();
|
|
String title = toCreate.getTitle();
|
|
String organizationNameOrId = toCreate.getSelectedOrganization();
|
|
String author = toCreate.getAuthorFullName();
|
|
String authorMail = toCreate.getAuthorEmail();
|
|
String maintainer = toCreate.getMaintainer();
|
|
String maintainerMail = toCreate.getMaintainerEmail();
|
|
long version = toCreate.getVersion();
|
|
String description = toCreate.getDescription();
|
|
String chosenLicense = toCreate.getLicense();
|
|
String licenseId = findLicenseIdByLicense(chosenLicense);
|
|
List<String> listOfTags = toCreate.getTags();
|
|
Map<String, List<String>> customFields = toCreate.getCustomFields();
|
|
|
|
// add Type for custom fields
|
|
if (toCreate.getChosenType() != null)
|
|
customFields.put(SYS_TYPE, Arrays.asList(toCreate.getChosenType()));
|
|
|
|
boolean setPublic = toCreate.getVisibility();
|
|
|
|
// get the list of resources and convert to ResourceBean
|
|
List<ResourceBean> resources = null;
|
|
ResourceElementBean resourcesToAdd = toCreate.getResourceRoot();
|
|
|
|
// converting to resources to be added
|
|
if (resourcesToAdd != null) {
|
|
Workspace workspace = getWorkspaceFromStorageHub();
|
|
resources = WorkspaceUtils.toResources(toCreate, workspace, userName);
|
|
}
|
|
|
|
logger.debug("The user wants to publish in organization with name " + organizationNameOrId);
|
|
String scope = getScopeFromOrgName(organizationNameOrId);
|
|
DataCatalogue utils = getCatalogue(scope);
|
|
|
|
if (!isWithinPortal()) {
|
|
logger.debug("Should be added:");
|
|
for (String key : customFields.keySet()) {
|
|
logger.debug("Custom field with key: " + key + ", value: " + customFields.get(key));
|
|
}
|
|
}
|
|
|
|
String datasetId = utils.createCkanDatasetMultipleCustomFields(userName, title, null, organizationNameOrId,
|
|
author, authorMail, maintainer, maintainerMail, version, description, licenseId, listOfTags,
|
|
customFields, resources, setPublic, true, true);
|
|
|
|
if (datasetId != null) {
|
|
|
|
logger.info("Dataset created!");
|
|
toCreate.setId(datasetId);
|
|
|
|
// #23491 Building the go to the item to "Catalogue Portlet URL" (instead of URI
|
|
// Resolver URL)
|
|
String catalogueURL = utils.getPortletUrl();
|
|
// logger.debug("Returning catalogueURL: "+catalogueURL);
|
|
// logger.debug("Returning datasetId: "+datasetId);
|
|
toCreate.setSource(String.format("%s?path=/dataset/%s", catalogueURL, datasetId));
|
|
logger.debug("Returning getSource(): " + toCreate.getSource());
|
|
logger.debug("Returning dataset: " + toCreate);
|
|
|
|
// #24744 Returning lazy object
|
|
toCreate.setGroups(null);
|
|
toCreate.setCustomFields(null);
|
|
toCreate.setGroupsForceCreation(null);
|
|
toCreate.setMetadataList(null);
|
|
toCreate.setOrganizationList(null);
|
|
|
|
logger.info("Returning lazy dataset: " + toCreate);
|
|
|
|
// createdDatasetBean.getSource();
|
|
// createdDatasetBean.getTitle();
|
|
// resourceForm = new AddResourceToDataset(eventBus, createdDatasetBean.getId(),
|
|
// createdDatasetBean.getTitle(),
|
|
// createdDatasetBean.getSelectedOrganization(), owner, datasetUrl);
|
|
return toCreate;
|
|
} else {
|
|
logger.error("Failed to create the dataset");
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error while creating item ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
/**
|
|
* Update CKAN dataset.
|
|
*
|
|
* @param toUpdate the to create
|
|
* @return the dataset bean
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public DatasetBean updateCKANDataset(DatasetBean toUpdate) throws Exception {
|
|
|
|
try {
|
|
devModeSetContexts();
|
|
logger.info("Request for updating a dataset with title: {} " + toUpdate.getTitle());
|
|
if (logger.isDebugEnabled()) {
|
|
logger.debug("Dataset is: {} " + toUpdate);
|
|
}
|
|
|
|
if (toUpdate.getCkanName() == null)
|
|
throw new Exception("Error on updating: the input parameter 'name' is null");
|
|
|
|
String userName = GenericUtils.getCurrentUser(getThreadLocalRequest()).getUsername();
|
|
String title = toUpdate.getTitle();
|
|
String organizationNameOrId = toUpdate.getSelectedOrganization();
|
|
String author = toUpdate.getAuthorFullName();
|
|
String authorMail = toUpdate.getAuthorEmail();
|
|
String maintainer = toUpdate.getMaintainer();
|
|
String maintainerMail = toUpdate.getMaintainerEmail();
|
|
long version = toUpdate.getVersion();
|
|
String description = toUpdate.getDescription();
|
|
String chosenLicense = toUpdate.getLicense();
|
|
String licenseId = findLicenseIdByLicense(chosenLicense);
|
|
List<String> listOfTags = toUpdate.getTags();
|
|
Map<String, List<String>> customFields = toUpdate.getCustomFields();
|
|
|
|
// add Type for custom fields
|
|
// if (toUpdate.getChosenType() != null) {
|
|
// customFields.put(SYS_TYPE, Arrays.asList(toUpdate.getChosenType()));
|
|
// }
|
|
|
|
// Reading the CKAN Dataset with extras in order to set the reserver system into
|
|
// update request
|
|
String scopePerCurrentUrl = GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
DataCatalogue utils = getCatalogue(scopePerCurrentUrl);
|
|
CkanDataset currentDataset = utils.getDataset(toUpdate.getId(), userName);
|
|
|
|
Map<String, List<String>> ckanExtras = currentDataset.getListExtrasAsHashMap();
|
|
Map<String, List<String>> ckanReserverSystemExtras = getReserverdSystemFields(ckanExtras);
|
|
// putting all reserved system fields into customFields to update
|
|
customFields.putAll(ckanReserverSystemExtras);
|
|
|
|
// Settings the CKAN resources
|
|
List<CkanResource> listCurrentResources = currentDataset.getResources();
|
|
List<ResourceBean> resources = null;
|
|
if (listCurrentResources != null) {
|
|
resources = new ArrayList<ResourceBean>(listCurrentResources.size());
|
|
for (CkanResource ckanResource : listCurrentResources) {
|
|
String orgName = null; // not required here
|
|
ResourceBean reb = PublisherCatalogueConveter.toResourceBean(ckanResource, orgName);
|
|
resources.add(reb);
|
|
}
|
|
}
|
|
|
|
boolean setPublic = toUpdate.getVisibility();
|
|
|
|
// get the list of resources and convert to ResourceBean from the Workspace
|
|
ResourceElementBean resourcesToAdd = toUpdate.getResourceRoot();
|
|
// converting to resources to be added
|
|
if (resourcesToAdd != null) {
|
|
Workspace workspace = getWorkspaceFromStorageHub();
|
|
resources.addAll(WorkspaceUtils.toResources(toUpdate, workspace, userName));
|
|
}
|
|
|
|
logger.debug("The user wants to publish in organization with name " + organizationNameOrId);
|
|
// String scope = getScopeFromOrgName(organizationNameOrId);
|
|
|
|
if (!isWithinPortal()) {
|
|
logger.debug("Should be added:");
|
|
for (String key : customFields.keySet()) {
|
|
logger.debug("Custom field with key: " + key + ", value: " + customFields.get(key));
|
|
}
|
|
}
|
|
|
|
String datasetId = utils.updateCkanDatasetMultipleCustomFields(userName, title, toUpdate.getCkanName(),
|
|
organizationNameOrId, author, authorMail, maintainer, maintainerMail, version, description,
|
|
licenseId, listOfTags, customFields, resources, setPublic, true, true);
|
|
|
|
if (datasetId != null) {
|
|
|
|
logger.info("Dataset updated!");
|
|
toUpdate.setId(datasetId);
|
|
|
|
// #23491 Building the go to the item to "Catalogue Portlet URL" (instead of URI
|
|
// Resolver URL)
|
|
String catalogueURL = utils.getPortletUrl();
|
|
// logger.debug("Returning catalogueURL: "+catalogueURL);
|
|
// logger.debug("Returning datasetId: "+datasetId);
|
|
toUpdate.setSource(String.format("%s?path=/dataset/%s", catalogueURL, datasetId));
|
|
logger.debug("Returning getSource(): " + toUpdate.getSource());
|
|
logger.debug("Returning dataset: " + toUpdate);
|
|
|
|
// #24744 Returning lazy object
|
|
toUpdate.setGroups(null);
|
|
toUpdate.setCustomFields(null);
|
|
toUpdate.setGroupsForceCreation(null);
|
|
toUpdate.setMetadataList(null);
|
|
toUpdate.setOrganizationList(null);
|
|
|
|
logger.info("Returning lazy dataset: " + toUpdate);
|
|
|
|
// createdDatasetBean.getSource();
|
|
// createdDatasetBean.getTitle();
|
|
// resourceForm = new AddResourceToDataset(eventBus, createdDatasetBean.getId(),
|
|
// createdDatasetBean.getTitle(),
|
|
// createdDatasetBean.getSelectedOrganization(), owner, datasetUrl);
|
|
return toUpdate;
|
|
} else {
|
|
logger.error("Failed to update the dataset");
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error while updating item ", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
/**
|
|
* Adds the resource to dataset.
|
|
*
|
|
* @param resource the resource
|
|
* @param organizationName the organization name
|
|
* @param datasetId the dataset id
|
|
* @return the resource element bean
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public ResourceElementBean addResourceToDataset(ResourceElementBean resource, String organizationName,
|
|
String datasetId) throws Exception {
|
|
logger.info("called addResourceToDataset");
|
|
devModeSetContexts();
|
|
String username = GenericUtils.getCurrentUser(getThreadLocalRequest()).getUsername();
|
|
logger.debug("Incoming request for creating new resource for dataset with id " + datasetId
|
|
+ " and organization name of the dataset is " + resource.getOrganizationNameDatasetParent());
|
|
logger.debug("Owner is " + username + " and resource is " + resource);
|
|
|
|
ResourceBean resourceBean = new ResourceBean(resource.getUrl(), resource.getName(), resource.getDescription(),
|
|
null, username, datasetId, null);
|
|
|
|
// get the scope in which we should discover the ckan instance given the
|
|
// organization name in which the dataset was created
|
|
String scope = getScopeFromOrgName(resource.getOrganizationNameDatasetParent());
|
|
DataCatalogue catalogue = getCatalogue(scope);
|
|
CkanResource theCreatedResource = catalogue.addResource(resourceBean, datasetId,
|
|
resource.getOrganizationNameDatasetParent(), username);
|
|
|
|
if (theCreatedResource != null) {
|
|
logger.info("Resource " + resource.getName() + " is now available");
|
|
|
|
ResourceElementBean reb = PublisherCatalogueConveter.toResourceElementBean(theCreatedResource,
|
|
organizationName);
|
|
|
|
return reb;
|
|
}
|
|
|
|
logger.debug("No resource created");
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Delete resource from dataset.
|
|
*
|
|
* @param resource the resource
|
|
* @return true, if successful
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public boolean deleteResourceFromDataset(ResourceElementBean resource) throws Exception {
|
|
logger.debug("Request for deleting resource " + resource);
|
|
boolean deleted = false;
|
|
devModeSetContexts();
|
|
try {
|
|
// get the scope in which we should discover the ckan instance given the
|
|
// organization name in which the dataset was created
|
|
String scope = getScopeFromOrgName(resource.getOrganizationNameDatasetParent());
|
|
DataCatalogue catalogue = getCatalogue(scope);
|
|
String username = GenericUtils.getCurrentUser(getThreadLocalRequest()).getUsername();
|
|
deleted = catalogue.deleteResourceFromDataset(resource.getCkanResourceID(), username);
|
|
if (deleted) {
|
|
logger.info("Resource described by " + resource + " deleted");
|
|
} else
|
|
logger.error("Resource described by " + resource + " NOT deleted");
|
|
} catch (Exception e) {
|
|
String error = "Sorry, an error occurred while trying to delete resource described by "
|
|
+ resource.getName();
|
|
logger.error(error, e);
|
|
throw new Exception(error + ". Error is: " + e.getMessage());
|
|
}
|
|
return deleted;
|
|
|
|
}
|
|
|
|
/**
|
|
* Gets the profiles.
|
|
*
|
|
* @param orgName the org name
|
|
* @return the profiles
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public List<MetaDataProfileBean> getProfiles(String orgName) throws Exception {
|
|
|
|
logger.debug("Requested profiles for products into orgName " + orgName);
|
|
List<MetaDataProfileBean> toReturn = new ArrayList<MetaDataProfileBean>();
|
|
try {
|
|
String evaluatedScope = getScopeFromOrgName(orgName);
|
|
logger.debug("Evaluated scope is " + evaluatedScope);
|
|
toReturn = MetadataDiscovery.getMetadataProfilesList(evaluatedScope, getThreadLocalRequest());
|
|
} catch (Exception e) {
|
|
logger.error("Failed to retrieve profiles for scope coming from organization name " + orgName, e);
|
|
throw e;
|
|
}
|
|
|
|
return toReturn;
|
|
}
|
|
|
|
/**
|
|
* Gets the profile for update.
|
|
*
|
|
* @param orgName the org name
|
|
* @param datasetType the dataset type
|
|
* @param datasedIdOrName the datased id or name
|
|
* @return the profile for update
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public MetadataProfileBeanForUpdate getProfileForUpdate(String orgName, String datasetType, String datasedIdOrName)
|
|
throws Exception {
|
|
logger.info("Called getProfileForUpdate for orgName {} and dataset type {} ", orgName, datasetType);
|
|
logger.debug("Requested profiles for products into orgName " + orgName);
|
|
List<MetaDataProfileBean> toRead = new ArrayList<MetaDataProfileBean>();
|
|
|
|
List<MetaDataProfileBean> toReturn = new ArrayList<MetaDataProfileBean>();
|
|
try {
|
|
String evaluatedScope = getScopeFromOrgName(orgName);
|
|
logger.debug("Evaluated scope is " + evaluatedScope);
|
|
toRead = MetadataDiscovery.getMetadataProfilesList(evaluatedScope, getThreadLocalRequest());
|
|
|
|
// Getting profile for datasetType, expecting only one
|
|
toReturn = toRead.stream().filter(tr -> tr.getType().compareTo(datasetType) == 0)
|
|
.collect(Collectors.toList());
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Failed to retrieve profiles for scope coming from organization name " + orgName, e);
|
|
throw e;
|
|
}
|
|
|
|
// retrieve scope per current Portlet url
|
|
String scopePerCurrentUrl = GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
String username = GenericUtils.getCurrentUser(getThreadLocalRequest()).getUsername();
|
|
DataCatalogue utils = getCatalogue(scopePerCurrentUrl);
|
|
CkanDataset dataset = utils.getDataset(datasedIdOrName, username);
|
|
|
|
if (toReturn.isEmpty())
|
|
throw new Exception("No Profile found for dataset type: " + datasetType);
|
|
|
|
// Settings current values in the profile found
|
|
MetaDataProfileBean profileBean = toReturn.get(0);
|
|
if (logger.isTraceEnabled()) {
|
|
logger.trace("The source profile is: {}", profileBean);
|
|
logger.trace("The metadatafields into source profile are: {}", profileBean.getMetadataFields().size());
|
|
for (int i = 0; i < profileBean.getMetadataFields().size(); i++) {
|
|
MetadataFieldWrapper mw = profileBean.getMetadataFields().get(i);
|
|
logger.trace(i + " MetadataFieldWrapper : {}", mw);
|
|
}
|
|
}
|
|
Map<String, List<String>> extras = dataset.getListExtrasAsHashMap();
|
|
|
|
Map<String, List<String>> customFieldsMap = new HashMap<String, List<String>>(extras);
|
|
|
|
logger.trace("Current extras are {}", extras);
|
|
|
|
List<MetadataFieldWrapper> expandedListForMultipleOccurs = new ArrayList<MetadataFieldWrapper>();
|
|
|
|
// Operating on the source cloned list
|
|
List<MetadataFieldWrapper> clonedList = cloneList(profileBean.getMetadataFields());
|
|
|
|
// Creating bean to return
|
|
MetaDataProfileBean toReturnMetaDataProfileBean = new MetaDataProfileBean();
|
|
toReturnMetaDataProfileBean.setTitle(profileBean.getTitle());
|
|
toReturnMetaDataProfileBean.setType(profileBean.getType());
|
|
toReturnMetaDataProfileBean.setCategories(profileBean.getCategories());
|
|
|
|
for (MetadataFieldWrapper metadataFieldWrapper : clonedList) {
|
|
String fieldName = metadataFieldWrapper.getFieldNameFromCategory();
|
|
// removing profile key from the map
|
|
|
|
logger.trace("Searching field name '{}' in the profile", fieldName);
|
|
List<String> currValuesOfExtraField = extras.get(fieldName);
|
|
logger.trace("Current value found is '{}' for field name '{}'", currValuesOfExtraField, fieldName);
|
|
|
|
// the profile field is set as extra field (it is not null), so going to set the
|
|
// current values
|
|
if (currValuesOfExtraField != null && !currValuesOfExtraField.isEmpty()) {
|
|
|
|
customFieldsMap.remove(fieldName);
|
|
|
|
if (currValuesOfExtraField.size() == 1) {
|
|
metadataFieldWrapper.setCurrentValues(currValuesOfExtraField.stream().toArray(String[]::new));
|
|
} else {
|
|
// Duplicating the fields with multiple occurrences
|
|
int dataSize = currValuesOfExtraField.size();
|
|
for (int j = 0; j < dataSize; j++) {
|
|
List<MetadataFieldWrapper> cloned = cloneList(Arrays.asList(metadataFieldWrapper));
|
|
MetadataFieldWrapper mfw = cloned.get(0);
|
|
|
|
// Duplicating MetadataFieldWrapper for data list with isMultiSelection==false
|
|
if (!mfw.isMultiSelection()) {
|
|
mfw.setCurrentValues(currValuesOfExtraField.get(j) + "");
|
|
// In case of array, from the first to second-last one, repeated field is set to
|
|
// 'false'
|
|
// These properties are managed properly with the
|
|
// last one field
|
|
if (j < dataSize - 1) {
|
|
mfw.setMandatory(false);
|
|
mfw.setMaxOccurs(1);
|
|
}
|
|
expandedListForMultipleOccurs.add(mfw);
|
|
} else {
|
|
// Setting dataArray as list of current values when isMultiSelection is true
|
|
String[] toArray = (String[]) currValuesOfExtraField.toArray(new String[0]);
|
|
mfw.setCurrentValues(toArray);
|
|
expandedListForMultipleOccurs.add(mfw);
|
|
// Exit from for
|
|
break;
|
|
}
|
|
}
|
|
// returns to external for because the field with multiple occurrences has been
|
|
// added to list
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// add field to list
|
|
expandedListForMultipleOccurs.add(metadataFieldWrapper);
|
|
}
|
|
|
|
toReturnMetaDataProfileBean.setMetadataFields(expandedListForMultipleOccurs);
|
|
|
|
logger.trace("CustomFieldsMap (extras) not matching metadata profile are {}", customFieldsMap);
|
|
|
|
int customFieldsSize = customFieldsMap.size();
|
|
|
|
// There are the Custom Fields not belonging to profile
|
|
logger.info("Custom fields founds # {}", customFieldsSize);
|
|
|
|
if (customFieldsSize > 0) {
|
|
customFieldsMap = purgeSystemFields(customFieldsMap);
|
|
}
|
|
|
|
logger.info("custom fields to return {}", customFieldsMap.keySet());
|
|
|
|
MetadataProfileBeanForUpdate mpfu = new MetadataProfileBeanForUpdate();
|
|
mpfu.setListProfileBean(Arrays.asList(toReturnMetaDataProfileBean));
|
|
mpfu.setCustomFields(customFieldsMap);
|
|
|
|
if (logger.isDebugEnabled()) {
|
|
logger.debug("Returning filled profile {}", toReturnMetaDataProfileBean.getType());
|
|
logger.debug("with MetadataFields {}", toReturnMetaDataProfileBean.getMetadataFields());
|
|
logger.debug("Custom fields founds {}", customFieldsMap.keySet());
|
|
}
|
|
|
|
logger.info("returing the filled profile {}", profileBean.getType());
|
|
return mpfu;
|
|
}
|
|
|
|
/**
|
|
* Dataset id already exists.
|
|
*
|
|
* @param title the title
|
|
* @param orgName the org name
|
|
* @return true, if successful
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public boolean datasetIdAlreadyExists(String title, String orgName) throws Exception {
|
|
if (title == null || title.isEmpty())
|
|
return true; // it's an error somehow
|
|
try {
|
|
String scopeFromOrgName = getScopeFromOrgName(orgName);
|
|
String idFromTitle = CatalogueUtilMethods.fromProductTitleToName(title);
|
|
logger.debug(
|
|
"Evaluating if dataset with id " + title + " in context " + scopeFromOrgName + " already exists");
|
|
return getCatalogue(scopeFromOrgName).existProductWithNameOrId(idFromTitle);
|
|
} catch (Exception e) {
|
|
logger.error("Unable to check if such a dataset id already exists", e);
|
|
throw new Exception("Unable to check if such a dataset id already exists " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The method tries to retrieve the scope related to the organization using the
|
|
* map first, if no match is found, it retrieves such information by using
|
|
* liferay.
|
|
*
|
|
* @param orgName the org name
|
|
* @return the scope from org name
|
|
*/
|
|
private String getScopeFromOrgName(String orgName) {
|
|
|
|
logger.info("Request for scope related to orgName " + orgName + " [map that will be used is "
|
|
+ mapOrganizationScope.toString() + "]");
|
|
if (orgName == null || orgName.isEmpty())
|
|
throw new IllegalArgumentException("orgName cannot be empty or null!");
|
|
|
|
String toReturn = null;
|
|
|
|
if (isWithinPortal()) {
|
|
if (mapOrganizationScope.containsKey(orgName)) {
|
|
toReturn = mapOrganizationScope.get(orgName);
|
|
} else {
|
|
try {
|
|
String evaluatedScope = GenericUtils.retrieveScopeFromOrganizationName(orgName);
|
|
// see #20801
|
|
if (evaluatedScope == null || evaluatedScope.isEmpty()) {
|
|
logger.warn("Scope detected for OrganizationName: " + orgName
|
|
+ " is null or empty, skipping filling 'mapOrganizationScope' and returning null");
|
|
return toReturn;
|
|
}
|
|
mapOrganizationScope.put(orgName, evaluatedScope);
|
|
toReturn = evaluatedScope;
|
|
} catch (Exception e) {
|
|
logger.error("Failed to retrieve scope from OrgName for organization " + orgName, e);
|
|
}
|
|
}
|
|
} else {
|
|
// UPDATED By FRANCESCO
|
|
toReturn = GenericUtils.getCurrentContext(this.getThreadLocalRequest(), false);
|
|
mapOrganizationScope.put(orgName, toReturn);
|
|
}
|
|
logger.info("Returning scope " + toReturn);
|
|
return toReturn;
|
|
}
|
|
|
|
/**
|
|
* Gets the user groups.
|
|
*
|
|
* @param orgName the org name
|
|
* @return the user groups
|
|
*/
|
|
@Override
|
|
public List<OrganizationBean> getUserGroups(String orgName) {
|
|
|
|
List<OrganizationBean> toReturn = new ArrayList<OrganizationBean>();
|
|
|
|
if (isWithinPortal()) {
|
|
GCubeUser user = GenericUtils.getCurrentUser(getThreadLocalRequest());
|
|
String username = null;
|
|
if (user != null)
|
|
username = user.getUsername();
|
|
|
|
logger.debug("Request for user " + username + " groups. Organization name is " + orgName);
|
|
|
|
// get http session
|
|
HttpSession httpSession = getThreadLocalRequest().getSession();
|
|
String scope = orgName != null ? getScopeFromOrgName(orgName)
|
|
: GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
|
|
// check if they are in session
|
|
String keyPerScopeGroups = CatalogueUtilMethods
|
|
.concatenateSessionKeyScope(SessionCatalogueAttributes.CKAN_GROUPS_MEMBER, scope);
|
|
|
|
if (httpSession.getAttribute(keyPerScopeGroups) != null) {
|
|
toReturn = (List<OrganizationBean>) httpSession.getAttribute(keyPerScopeGroups);
|
|
logger.info("Found user's groups in session " + toReturn);
|
|
} else {
|
|
|
|
// Fixing Incident #12563
|
|
try {
|
|
DataCatalogue catalogue = getCatalogue(scope);
|
|
// Fixing Incident #12563
|
|
if (username != null && !username.isEmpty()) {
|
|
Map<String, Map<CkanGroup, RolesCkanGroupOrOrg>> mapRoleGroup = catalogue
|
|
.getUserRoleByGroup(username);
|
|
Set<Entry<String, Map<CkanGroup, RolesCkanGroupOrOrg>>> set = mapRoleGroup.entrySet();
|
|
for (Entry<String, Map<CkanGroup, RolesCkanGroupOrOrg>> entry : set) {
|
|
Set<Entry<CkanGroup, RolesCkanGroupOrOrg>> subSet = entry.getValue().entrySet();
|
|
for (Entry<CkanGroup, RolesCkanGroupOrOrg> subEntry : subSet) {
|
|
toReturn.add(new OrganizationBean(subEntry.getKey().getTitle(),
|
|
subEntry.getKey().getName(), false));
|
|
}
|
|
}
|
|
httpSession.setAttribute(keyPerScopeGroups, toReturn);
|
|
} else
|
|
logger.warn("The API_KEY for " + username + " is null or empty in the catalogue: "
|
|
+ catalogue.getCatalogueUrl());
|
|
} catch (Exception e) {
|
|
logger.error("Error on recovery the user groups for " + username, e);
|
|
}
|
|
}
|
|
} else {
|
|
logger.warn("Dev mode detected");
|
|
toReturn = Arrays.asList();
|
|
}
|
|
|
|
logger.info("Returning user's groups: " + toReturn);
|
|
return toReturn;
|
|
}
|
|
|
|
/**
|
|
* Checks if is publisher user.
|
|
*
|
|
* @return true, if is publisher user
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public boolean isPublisherUser() throws Exception {
|
|
|
|
String username = GenericUtils.getCurrentUser(getThreadLocalRequest()).getUsername();
|
|
logger.info("Checking if the user " + username + " can publish or not on the catalogue");
|
|
|
|
if (!isWithinPortal()) {
|
|
logger.warn("OUT FROM PORTAL DETECTED RETURNING TRUE");
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
|
|
HttpSession httpSession = this.getThreadLocalRequest().getSession();
|
|
|
|
// retrieve scope per current portlet url
|
|
String scopePerCurrentUrl = GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
|
|
// get key per scope
|
|
String keyPerScopeRole = CatalogueUtilMethods
|
|
.concatenateSessionKeyScope(SessionCatalogueAttributes.CKAN_HIGHEST_ROLE, scopePerCurrentUrl);
|
|
String keyPerScopeOrganizations = CatalogueUtilMethods.concatenateSessionKeyScope(
|
|
SessionCatalogueAttributes.CKAN_ORGANIZATIONS_PUBLISH_KEY, scopePerCurrentUrl);
|
|
String keyPerScopeGroups = CatalogueUtilMethods
|
|
.concatenateSessionKeyScope(SessionCatalogueAttributes.CKAN_GROUPS_MEMBER, scopePerCurrentUrl);
|
|
|
|
// check if this information was already into session(true means the user has at
|
|
// least in one org
|
|
// the role editor), false that he is just a member so he cannot publish
|
|
RolesCkanGroupOrOrg role = (RolesCkanGroupOrOrg) httpSession.getAttribute(keyPerScopeRole);
|
|
|
|
// if the attribute was already set..
|
|
if (role != null)
|
|
return !role.equals(RolesCkanGroupOrOrg.MEMBER);
|
|
else {
|
|
|
|
try {
|
|
|
|
GroupManager gm = new LiferayGroupManager();
|
|
String groupName = gm.getGroup(gm.getGroupIdFromInfrastructureScope(scopePerCurrentUrl))
|
|
.getGroupName();
|
|
|
|
// we build up also a list that keeps track of the scopes (orgs) in which the
|
|
// user has role ADMIN/EDITOR
|
|
List<OrganizationBean> orgsInWhichAtLeastEditorRole = new ArrayList<OrganizationBean>();
|
|
String gatewayURL = GenericUtils.getGatewayClientHostname(getThreadLocalRequest());
|
|
logger.info("The Gateway URL is: " + gatewayURL);
|
|
role = CatalogueRoleManager.getHighestRole(scopePerCurrentUrl, username, groupName, this,
|
|
orgsInWhichAtLeastEditorRole, gatewayURL);
|
|
|
|
// if he is an admin/editor preload:
|
|
// 1) organizations in which he can publish (the widget will find these info in
|
|
// session)
|
|
if (!role.equals(RolesCkanGroupOrOrg.MEMBER)) {
|
|
httpSession.setAttribute(keyPerScopeOrganizations, orgsInWhichAtLeastEditorRole);
|
|
String orgName = scopePerCurrentUrl.split("/")[scopePerCurrentUrl.split("/").length - 1];
|
|
httpSession.setAttribute(keyPerScopeGroups, getUserGroups(orgName));
|
|
}
|
|
} catch (Exception e) {
|
|
logger.error("Unable to retrieve the role information for this user. Returning FALSE", e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// set role in session for this scope
|
|
httpSession.setAttribute(keyPerScopeRole, role);
|
|
|
|
logger.info("Does the user have the right to publish on the catalogue? " + role);
|
|
return !role.equals(RolesCkanGroupOrOrg.MEMBER);
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Failed to check the user's role", e);
|
|
throw new Exception("Failed to check if you are an Administrator or Editor " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if is publisher owner or admin user.
|
|
*
|
|
* @param datasetIdOrName the dataset id or name
|
|
* @return true, if is publisher owner or admin user
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public boolean isPublisherOwnerOrAdminUser(String datasetIdOrName) throws Exception {
|
|
|
|
String username = GenericUtils.getCurrentUser(getThreadLocalRequest()).getUsername();
|
|
logger.info("Checking if the user " + username + " can publish or not on the catalogue");
|
|
|
|
boolean isPublisher = isPublisherUser();
|
|
|
|
if (isPublisher) {
|
|
RolesCkanGroupOrOrg role = null;
|
|
String scopePerCurrentUrl = GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
|
|
if (!isWithinPortal()) {
|
|
role = RolesCkanGroupOrOrg.EDITOR;
|
|
logger.warn("OUT FROM PORTAL SETTING HARD-CODED ROLE " + role);
|
|
} else {
|
|
String keyPerScopeRole = CatalogueUtilMethods
|
|
.concatenateSessionKeyScope(SessionCatalogueAttributes.CKAN_HIGHEST_ROLE, scopePerCurrentUrl);
|
|
HttpSession httpSession = this.getThreadLocalRequest().getSession();
|
|
role = (RolesCkanGroupOrOrg) httpSession.getAttribute(keyPerScopeRole);
|
|
}
|
|
|
|
// if the user is an EDITOT he/she must be also the owner of the dataset
|
|
if (role.equals(RolesCkanGroupOrOrg.EDITOR)) {
|
|
logger.info("The user {} is an {}", username, RolesCkanGroupOrOrg.EDITOR);
|
|
String loggedUserEmail = GenericUtils.getCurrentUser(getThreadLocalRequest()).getEmail();
|
|
logger.debug("Logged user email: {} ", loggedUserEmail);
|
|
DataCatalogue utils = getCatalogue(scopePerCurrentUrl);
|
|
CkanDataset dataset = utils.getDataset(datasetIdOrName, username);
|
|
String datasetOwnerEmail = dataset.getAuthorEmail();
|
|
logger.debug("Dataset Owner email: {} ", datasetOwnerEmail);
|
|
|
|
if (loggedUserEmail != null && datasetOwnerEmail != null
|
|
&& datasetOwnerEmail.compareTo(loggedUserEmail) == 0) {
|
|
logger.info("The user {} is owner of the dataset id {}, returning isOwnerOrAdminUser true ",
|
|
username, dataset.getId());
|
|
return true;
|
|
}
|
|
} else if (role.equals(RolesCkanGroupOrOrg.ADMIN)) {
|
|
logger.info("The user {} is an {}", username, RolesCkanGroupOrOrg.ADMIN);
|
|
return true;
|
|
}
|
|
}
|
|
logger.info("The user {} does not have the rights to update the dataset with id {}", username, datasetIdOrName);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks if is geo JSON valid.
|
|
*
|
|
* @param geoJson the geo json
|
|
* @return true, if is geo JSON valid
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public boolean isGeoJSONValid(String geoJson) throws Exception {
|
|
try {
|
|
new ObjectMapper().readValue(geoJson, GeoJsonObject.class);
|
|
return true;
|
|
} catch (Exception e) {
|
|
throw new Exception("GeoJSON field with value '" + geoJson + "' seems not valid!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Purge system fields.
|
|
*
|
|
* @param extras the extras
|
|
* @return the map
|
|
*/
|
|
public static Map<String, List<String>> purgeSystemFields(Map<String, List<String>> extras) {
|
|
logger.info("Purging extras from reserved fields {} ", SYSTEM_CUSTOM_FIELDS_PREFIXES);
|
|
if (extras == null)
|
|
return null;
|
|
|
|
Map<String, List<String>> extrasPop = new HashMap<String, List<String>>(extras);
|
|
for (String key : extras.keySet()) {
|
|
List<String> list = SYSTEM_CUSTOM_FIELDS_PREFIXES.stream().filter(scf -> key.startsWith(scf))
|
|
.collect(Collectors.toList());
|
|
|
|
if (list.size() > 0)
|
|
extrasPop.remove(key);
|
|
}
|
|
|
|
logger.debug("returning purged extras {} ", extrasPop);
|
|
return extrasPop;
|
|
|
|
}
|
|
|
|
/**
|
|
* Gets the public link for file item id.
|
|
*
|
|
* @param itemId the item id
|
|
* @param shortenUrl the shorten url
|
|
* @return the public link for file item id
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public String getPublicLinkForFileItemId(String itemId, boolean shortenUrl) throws Exception {
|
|
logger.debug("get Public Link For ItemId: " + itemId);
|
|
//String scopePerCurrentUrl = GenericUtils.getScopeFromClientUrl(getThreadLocalRequest());
|
|
String theLink = null;
|
|
try {
|
|
GenericUtils.getCurrentContext(getThreadLocalRequest(), true);
|
|
UriResolverManager resolver = new UriResolverManager("SHUB");
|
|
Map<String, String> params = new HashMap<String, String>();
|
|
params.put("id", itemId);
|
|
theLink = resolver.getLink(params, true);
|
|
logger.info("Returning public link: "+theLink);
|
|
} catch (UriResolverMapException e) {
|
|
logger.error("UriResolverMapException", e);
|
|
throw new Exception("Sorry an error occurred on getting the link " + e.getMessage());
|
|
} catch (IllegalArgumentException e) {
|
|
logger.error("Failed to check the user's role", e);
|
|
throw new Exception("Sorry an error occurred on getting the link " + e.getMessage());
|
|
} catch (Exception e) {
|
|
logger.error("Failed to check the user's role", e);
|
|
throw new Exception("Sorry an error occurred on getting the link " + e.getMessage());
|
|
}
|
|
|
|
return theLink;
|
|
|
|
}
|
|
|
|
/**
|
|
* Gets the reserverd system fields.
|
|
*
|
|
* @param extras the extras
|
|
* @return the reserverd system fields
|
|
*/
|
|
public static Map<String, List<String>> getReserverdSystemFields(Map<String, List<String>> extras) {
|
|
logger.info("Reading reserved fields from extras...");
|
|
if (extras == null)
|
|
return null;
|
|
|
|
Map<String, List<String>> reserverSystemExtras = new HashMap<String, List<String>>();
|
|
for (String key : extras.keySet()) {
|
|
List<String> list = SYSTEM_CUSTOM_FIELDS_PREFIXES.stream().filter(scf -> key.startsWith(scf))
|
|
.collect(Collectors.toList());
|
|
|
|
if (list.size() > 0)
|
|
reserverSystemExtras.put(key, extras.get(key));
|
|
}
|
|
logger.debug("returning reserverd extras {} ", reserverSystemExtras);
|
|
return reserverSystemExtras;
|
|
|
|
}
|
|
|
|
/**
|
|
* Clone list.
|
|
*
|
|
* @param list the list
|
|
* @return the list
|
|
*/
|
|
public static List<MetadataFieldWrapper> cloneList(List<MetadataFieldWrapper> list) {
|
|
List<MetadataFieldWrapper> listCloned = new ArrayList<MetadataFieldWrapper>(list.size());
|
|
|
|
Function<MetadataFieldWrapper, MetadataFieldWrapper> cloneWrapper = (mfw) -> {
|
|
|
|
MetadataFieldWrapper newMfw = new MetadataFieldWrapper();
|
|
newMfw.setAsGroup(mfw.getAsGroup());
|
|
newMfw.setAsTag(mfw.getAsTag());
|
|
List<String> listValues = mfw.getCurrentValues();
|
|
if (listValues != null) {
|
|
newMfw.setCurrentValues(listValues.stream().toArray(String[]::new));
|
|
}
|
|
newMfw.setDefaultValue(mfw.getDefaultValue());
|
|
newMfw.setFieldId(mfw.getFieldId());
|
|
newMfw.setFieldName(mfw.getFieldName());
|
|
newMfw.setFieldNameFromCategory(mfw.getFieldNameFromCategory());
|
|
newMfw.setMandatory(mfw.getMandatory());
|
|
newMfw.setMaxOccurs(mfw.getMaxOccurs());
|
|
newMfw.setMultiSelection(mfw.isMultiSelection());
|
|
newMfw.setNote(mfw.getNote());
|
|
newMfw.setOwnerCategory(mfw.getOwnerCategory());
|
|
newMfw.setType(mfw.getType());
|
|
newMfw.setValidator(mfw.getValidator());
|
|
newMfw.setVocabulary(mfw.getVocabulary());
|
|
|
|
return newMfw;
|
|
|
|
};
|
|
|
|
for (MetadataFieldWrapper item : list) {
|
|
MetadataFieldWrapper cloned = cloneWrapper.apply(item);
|
|
listCloned.add(cloned);
|
|
}
|
|
return listCloned;
|
|
}
|
|
|
|
} |