Java tutorial
/******************************************************************************* * Copyright (c) 2013 aegif. * * This file is part of NemakiWare. * * NemakiWare is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * NemakiWare is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along with NemakiWare. * If not, see <http://www.gnu.org/licenses/>. * * Contributors: * linzhixing(https://github.com/linzhixing) - initial API and implementation ******************************************************************************/ package jp.aegif.nemaki.cmis.factory.info; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import javax.annotation.PostConstruct; import jp.aegif.nemaki.model.NemakiPermissionDefinition; import jp.aegif.nemaki.util.PropertyManager; import jp.aegif.nemaki.util.YamlManager; import jp.aegif.nemaki.util.constant.PropertyKey; import org.apache.chemistry.opencmis.commons.data.PermissionMapping; import org.apache.chemistry.opencmis.commons.definitions.PermissionDefinition; import org.apache.chemistry.opencmis.commons.enums.AclPropagation; import org.apache.chemistry.opencmis.commons.enums.SupportedPermissions; import org.apache.chemistry.opencmis.commons.impl.dataobjects.PermissionDefinitionDataImpl; import org.apache.chemistry.opencmis.commons.impl.dataobjects.PermissionMappingDataImpl; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; public class AclCapabilities extends org.apache.chemistry.opencmis.commons.impl.dataobjects.AclCapabilitiesDataImpl { private static final long serialVersionUID = 8654484629504222836L; private static final Log log = LogFactory.getLog(AclCapabilities.class); private List<NemakiPermissionDefinition> nemakiPermissions; private PropertyManager propertyManager; @PostConstruct public void init() { nemakiPermissions = readPermissionDefinitions(); setSupportedPermissions(SupportedPermissions.BOTH); setAclPropagation(AclPropagation.PROPAGATE); setPermissionDefinitionData(buildPermissionDefinitions()); setPermissionMappingData(buildPermissionMaps()); } // ////////////////////////////////////////////////////////////////////////// // Permission Definitions // ////////////////////////////////////////////////////////////////////////// @SuppressWarnings("unchecked") private List<NemakiPermissionDefinition> readPermissionDefinitions() { List<NemakiPermissionDefinition> results = new ArrayList<NemakiPermissionDefinition>(); //Get definition file String definitionFile = ""; try { definitionFile = propertyManager.readValue(PropertyKey.PERMISSION_DEFINITION); } catch (Exception e) { log.error("Cannot read a permission definition file", e); } //Parse definition file YamlManager manager = new YamlManager(definitionFile); List<Map<String, Object>> yml = (List<Map<String, Object>>) manager.loadYml(); for (Map<String, Object> y : yml) { NemakiPermissionDefinition cp = new NemakiPermissionDefinition(y); results.add(cp); } return results; } private List<PermissionDefinition> buildPermissionDefinitions() { List<PermissionDefinition> permissions = new ArrayList<PermissionDefinition>(); for (NemakiPermissionDefinition np : nemakiPermissions) { permissions.add(createPermission(np.getId(), np.getDescription())); } return permissions; } public HashMap<String, String> getBasicPermissionConversion() { HashMap<String, String> result = new HashMap<String, String>(); for (NemakiPermissionDefinition np : nemakiPermissions) { result.put(np.getId(), np.getAsCmisBasicPermission()); } return result; } private PermissionDefinition createPermission(String permission, String description) { PermissionDefinitionDataImpl pd = new PermissionDefinitionDataImpl(); pd.setId(permission); pd.setDescription(description); return pd; } // ////////////////////////////////////////////////////////////////////////// // Permission Mappings // ////////////////////////////////////////////////////////////////////////// private LinkedHashMap<String, PermissionMapping> buildPermissionMaps() { LinkedHashMap<String, PermissionMapping> table = new LinkedHashMap<String, PermissionMapping>(); HashMap<String, ArrayList<String>> map = readPermissionMappingDefinitions(); //Build table for (Entry<String, ArrayList<String>> entry : map.entrySet()) { //FIXME WORKAROUND: skip canCreatePolicy.Folder if (PermissionMapping.CAN_CREATE_POLICY_FOLDER.equals(entry.getKey())) { continue; } PermissionMappingDataImpl mapping = new PermissionMappingDataImpl(); mapping.setKey(entry.getKey()); mapping.setPermissions(entry.getValue()); table.put(mapping.getKey(), mapping); } //Add customized permissions to table for (NemakiPermissionDefinition custom : nemakiPermissions) { customizeTable(custom, table); } return table; } private void customizeTable(NemakiPermissionDefinition custom, LinkedHashMap<String, PermissionMapping> table) { for (Entry<String, PermissionMapping> entry : table.entrySet()) { String k = entry.getKey(); PermissionMapping pm = entry.getValue(); //Add where base exists if (CollectionUtils.isNotEmpty(custom.getBase())) { //Check if any base is contained boolean baseContained = false; for (String base : custom.getBase()) { if (pm.getPermissions().contains(base)) { baseContained = true; break; } } //Check mapped flag Boolean mapped = custom.getPermissionMapping().get(k); //Default to true if (custom.getPermissionMapping().containsKey(k) && mapped == null) { mapped = true; } //Customize table if (Boolean.TRUE == mapped || ((mapped == null) && baseContained)) { //Add without duplicate boolean duplicate = pm.getPermissions().contains(custom.getId()); if (!duplicate) { List<String> permissions = new ArrayList<String>(pm.getPermissions()); permissions.add(custom.getId()); PermissionMappingDataImpl pmdi = new PermissionMappingDataImpl(); pmdi.setKey(k); pmdi.setPermissions(permissions); table.put(k, pmdi); } } } } } @SuppressWarnings("unchecked") private HashMap<String, ArrayList<String>> readPermissionMappingDefinitions() { //Decide base definition file String definitionFile = ""; try { definitionFile = propertyManager.readValue(PropertyKey.PERMISSION_MAPPING_DEFINITION); } catch (Exception e) { log.error("Cannot read a permission mapping definition file", e); } //Get mapping info YamlManager ymgr = new YamlManager(definitionFile); Object yaml = ymgr.loadYml(); HashMap<String, ArrayList<String>> map = new HashMap<String, ArrayList<String>>(); try { map = (HashMap<String, ArrayList<String>>) yaml; } catch (Exception e) { log.error(definitionFile + " is not well-formatted.", e); } return map; } public void setPropertyManager(PropertyManager propertyManager) { this.propertyManager = propertyManager; } }