Set unique document name based on metadata

Each time a new document is uploaded, the Automation action sets a unique document name based in metadata values. 

The tables used in this sample is defined as:

-- LastID table
create table UNIQUE_ID (UN_ID INT, primary key(UN_ID));

insert into UNIQUE_ID (UN_ID) values (1);


-- Customer table
create table CUSTOMER (CUS_ID varchar(2),CUS_NAME varchar(32), primary key(CUS_ID));


insert into CUSTOMER (CUS_ID, CUS_NAME) values ('01', 'Customer 01');
insert into CUSTOMER (CUS_ID, CUS_NAME) values ('02', 'Customer 02');
insert into CUSTOMER (CUS_ID, CUS_NAME) values ('03', 'Customer 03');

Metadata group definition:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE property-groups PUBLIC "-//OpenKM//DTD Property Groups 3.10//EN"
"http://www.openkm.com/dtd/property-groups-3.10.dtd">
<property-groups>
    <property-group label="Datos" name="okg:data">
        <input label="Id" type="text" name="okp:data.id" width="200px" readonly="true"/>
        <input label="Project code" type="text" name="okp:data.code" width="200px">
            <validator type="req"/>
            <validator type="num"/>
            <validator type="maxlen" parameter="6"/>
            <validator type="minlen" parameter="6"/>
        </input>
        <select label="Customer" name="okp:data.customer" type="simple" 
                optionsQuery="select CUS_ID, CUS_NAME from CUSTOMER order by CUS_NAME">
            <validator type="req"/>
        </select>
        <input label="Description" type="text" name="okp:data.description" width="200px">
            <validator type="req"/>
            <validator type="maxlen" parameter="150"/>
        </input>
  </property-group>
</property-groups>

Automation action:

package com.openkm.plugin.automation.action;

import com.google.gson.Gson;
import com.openkm.core.DatabaseException;
import com.openkm.db.bean.*;
import com.openkm.db.service.LegacySrv;
import com.openkm.module.db.DbDocumentModule;
import com.openkm.plugin.BasePlugin;
import com.openkm.plugin.automation.Action;
import com.openkm.plugin.automation.AutomationException;
import com.openkm.plugin.automation.AutomationUtils;
import com.openkm.util.FileUtils;
import com.openkm.util.PathUtils;
import net.xeoh.plugins.base.annotations.PluginImplementation;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@PluginImplementation
public class SetUniqueName extends BasePlugin implements Action {
	private static final Logger log = LoggerFactory.getLogger(SetUniqueName.class);
	private static final String PROPERTY_GROUP_NAME = "okg:data";
	private static final String PROPERTY_FIELD_ID_NAME = "okp:data.id";
	private static final String PROPERTY_FIELD_CODE_NAME = "okp:data.code";
	private static final String PROPERTY_FIELD_CUSTOMER_NAME = "okp:data.customer";
	private static final String CODE_PATTERN = "%06d";


	private static final ArrayList<AutomationRule.EnumEvents> EVENTS_AT_PRE = Stream.of(AutomationRule.EnumEvents.EVENT_PROPERTY_GROUP_ADD).collect(Collectors.toCollection(ArrayList::new));

	private static final ArrayList<AutomationRule.EnumEvents> EVENTS_AT_POST = new ArrayList<>();

	@Autowired
	private AutomationUtils automationUtils;

	@Autowired
	private LegacySrv legacySrv;

	@Autowired
	private DbDocumentModule dbDocumentModule;

	@Override
	public List<AutomationRule.EnumEvents> getValidEventsAtPre() {
		return EVENTS_AT_PRE;
	}

	@Override
	public List<AutomationRule.EnumEvents> getValidEventsAtPost() {
		return EVENTS_AT_POST;
	}

	@Override
	public void executePre(Map<String, Object> env, Object... params) throws AutomationException {
		// Pre stage, here the metadata still has not been created and it is set the unique code in the map of values
		NodeBase node = automationUtils.getNodeBase(env);
		String propertyGroupName = automationUtils.getPropertyGroupName(env);
		try {
			if (node instanceof NodeDocument && PROPERTY_GROUP_NAME.equals(propertyGroupName)) {
				// Set the property in the map of values
				Map<String, String> proceedingProperties = automationUtils.getPropertyGroupProperties(env);
				proceedingProperties.put(PROPERTY_FIELD_ID_NAME, getUniqueCode());
				// Rename document based in metadata values
				String currentName = PathUtils.getName(node.getPath());
				String currentExtension = FileUtils.getFileExtension(currentName); // Extension must not be replaced
				// Getting values
				String id = proceedingProperties.get(PROPERTY_FIELD_ID_NAME);
				String code = proceedingProperties.get(PROPERTY_FIELD_CODE_NAME);
				String jsonValueOfCustomer = proceedingProperties.get(PROPERTY_FIELD_CUSTOMER_NAME);
				Gson gson = new Gson();
				List<String> customerValues = gson.fromJson(jsonValueOfCustomer, List.class);
				String customerValue = customerValues.get(0);
				// Setting the new name
				String newName = code + "-" + id + "-" + customerValue;
				if (!currentExtension.isEmpty()) {
					newName += "." + currentExtension;
				}
				dbDocumentModule.rename(null, node.getUuid(), newName);
			}
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new AutomationException(e.getMessage(), e);
		}
	}

	private synchronized String getUniqueCode() throws DatabaseException {
		Integer maxCode = 0;

		StringBuilder query = new StringBuilder("SELECT UN_ID FROM UNIQUE_ID");

		for (List<String> row : legacySrv.executeSQL(query.toString())) {
			maxCode = new Integer(row.get(0));
		}

		// increment value
		legacySrv.executeSQL("UPDATE UNIQUE_ID SET UN_ID = UN_ID +1");

		return String.format(CODE_PATTERN, maxCode);
	}

	@Override
	public void executePost(Map<String, Object> env, Object... params) throws AutomationException {
	}

	@Override
	public String getName() {
		return "Set Unique Name";
	}

	@Override
	public String getParamType00() {
		return Automation.PARAM_TYPE_EMPTY;
	}

	@Override
	public String getParamSrc00() {
		return Automation.PARAM_SOURCE_EMPTY;
	}

	@Override
	public String getParamDesc00() {
		return "";
	}

	@Override
	public String getParamType01() {
		return Automation.PARAM_TYPE_EMPTY;
	}

	@Override
	public String getParamSrc01() {
		return Automation.PARAM_SOURCE_EMPTY;
	}

	@Override
	public String getParamDesc01() {
		return "";
	}

	@Override
	public String getParamType02() {
		return Automation.PARAM_TYPE_EMPTY;
	}

	@Override
	public String getParamSrc02() {
		return Automation.PARAM_SOURCE_EMPTY;
	}

	@Override
	public String getParamDesc02() {
		return "";
	}
}

Create automation rule. Go to Administration > Automation and register a new rule:

• Rule-based on "add metadata" event at the "pre" stage.
• Set action named "SetUniqueName" in the actions.