Como usar Tags Programables

jbanuelosm — Fri, 17 Jan 2014 18:57:44 GMT

Buen dia compañeros, trabajo en Java y estoy haciendo unos procesos de subir doctos al Repositorio Alfresco, lo hago con ATOM (openCMIS), por esta parte no hay problema, solo que al querer integrarle Tags al documento, estos previamente ya deben de estar creados en el repositorio y asignarle el uuid

Re: Como usar Tags Programables

jbanuelosm — Fri, 21 Feb 2014 19:48:00 GMT

Investigando y buscando por aca y por alla sin hayar algo especifico en cuanto a los tags, desarrolle este estos procedimientos, probados. espero que a alguien le ayuden o los modifique para agregar funcionalidad

saludos.

nota: el esquelo del codigo es uno que me ayudo a entender como funciona la RestApi, la cual aqui esta presente, mas el codigo que agregue para el manejo de Tags ( etiquetas )

<java>
package main.java.org.apache.chemistry.opencmis.doc;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.StringTokenizer;

import org.alfresco.webservice.authentication.AuthenticationFault;
import org.alfresco.webservice.repository.RepositoryServiceSoapBindingStub;
import org.alfresco.webservice.repository.UpdateResult;
import org.alfresco.webservice.types.CML;
import org.alfresco.webservice.types.CMLAddAspect;
import org.alfresco.webservice.types.CMLCreate;
import org.alfresco.webservice.types.NamedValue;
import org.alfresco.webservice.types.ParentReference;
import org.alfresco.webservice.types.Store;
import org.alfresco.webservice.util.AuthenticationUtils;
import org.alfresco.webservice.util.Constants;
import org.alfresco.webservice.util.Utils;
import org.alfresco.webservice.util.WebServiceFactory;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.DeleteMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PutMethod;
import org.apache.commons.httpclient.methods.StringRequestEntity;
import org.apache.commons.httpclient.methods.multipart.ByteArrayPartSource;
import org.apache.commons.httpclient.methods.multipart.FilePart;
import org.apache.commons.httpclient.methods.multipart.MultipartRequestEntity;
import org.apache.commons.httpclient.methods.multipart.Part;
import org.apache.commons.httpclient.methods.multipart.StringPart;
import org.json.JSONObject;

public class AlfrescoManager {

   public static Store STORE = new Store(Constants.WORKSPACE_STORE, "SpacesStore");


   private String user;
   private String pass;
   private String server;
   //
   private String ticket = null;

   public AlfrescoManager(String user, String pass, String server) {
      this.user = user;
      this.pass = pass;
      this.server = server;
   }

   public void startSession() throws Exception {
      createTicket();
      try {
         WebServiceFactory.setEndpointAddress(server + "/api");
         AuthenticationUtils.startSession(user, pass);
      } catch (AuthenticationFault e) {
         destroyTicket();
         throw new Exception("Autentificacion invalida o no pudo ser realizada");
      }
   }

   private void createTicket() throws Exception {
      try {
         String url = server + "/service/api/login";
         String jsonInput = "{ \"username\" : \"" + user + "\", \"password\" : \"" + pass + "\" }";

         PostMethod method = new PostMethod(url);
         StringRequestEntity requestEntity = new StringRequestEntity(jsonInput, "application/json", "UTF-8");
         method.setRequestEntity(requestEntity);
         HttpClient client = new HttpClient();

         int status = client.executeMethod(method);
         if (status == HttpStatus.SC_OK) {
            String jsonResponse = method.getResponseBodyAsString(1000);
            JSONObject jsonObj = new JSONObject(jsonResponse);
            JSONObject data = (JSONObject) jsonObj.get("data");
            this.ticket = data.get("ticket").toString();
         } else {
            throw new Exception("Autentificacion invalida, status: " + HttpStatus.getStatusText(status));
         }
      } catch (Exception e) {
         throw new Exception("Error al obtener ticket", e);
      }
   }

   public void endSession() {
      try {
         destroyTicket();
      } catch (Exception e) {
         e.printStackTrace();
      }
      AuthenticationUtils.endSession();
   }

   private void destroyTicket() throws Exception {
      try {
         String url = server + "/service/api/login/ticket/" + ticket + "?alf_ticket=" + ticket;

         DeleteMethod method = new DeleteMethod(url);
         HttpClient client = new HttpClient();

         int status = client.executeMethod(method);
         if (status == HttpStatus.SC_OK) {
            //                log.debug("ticket borrado");
         } else {
            throw new Exception("Error al eliminar ticket, status: " + HttpStatus.getStatusText(status));
         }
      } catch (Exception e) {
         throw new Exception("Error al eliminar el ticket: " + ticket, e);
      }
   }

   public static byte[] fileToBytes(File file) throws Exception {
      FileInputStream fis = null;
      try {
         fis = new FileInputStream(file);

         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         byte[] buf = new byte[1024];
         for (int readNum; (readNum = fis.read(buf)) != -1 {
            bos.write(buf, 0, readNum);
         }
         return bos.toByteArray();
      } catch (Exception ex) {
         throw new Exception("El archivo no existe");
      } finally {
         if (fis != null) {
            try {
               fis.close();
            } catch (IOException e) {
               e.printStackTrace();
            }
         }
      }
   }

   public String serializaNombre(String nombreArchivo){
      String nombreArchivoSerializado;

      if ( nombreArchivo == null || nombreArchivo.isEmpty() ){
         System.out.println("Nuevo Archivo Original    : " + "Error en el nombre del archivo" );
         return null;
      }else{
         List<String> partesArchivo = new ArrayList<String>();
         partesArchivo = stringToList(nombreArchivo,".");

         Date fechaActual = new Date();
         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmSS"); // 20140219085419
         String date = sdf.format(fechaActual);

         if ( partesArchivo.size() == 1 ){
            nombreArchivoSerializado = ( nombreArchivo + "_" + date );
         }else if( partesArchivo.size() == 2 ){
            nombreArchivoSerializado = ( partesArchivo.get(0) + "_" + date + "." + partesArchivo.get(1) );
         }else{
            nombreArchivoSerializado = partesArchivo.get(0);
            for( int i = 1; (i < partesArchivo.size() - 1); i++ ){
               nombreArchivoSerializado = ( nombreArchivoSerializado + "." + partesArchivo.get(i) );
            }
            nombreArchivoSerializado = ( nombreArchivoSerializado + "_" + date + "." + partesArchivo.get(partesArchivo.size()-1) );
         }
         System.out.println("Nuevo Archivo Original    : " + nombreArchivo);
         System.out.println("Nuevo Archivo Serializado : " + nombreArchivoSerializado);
      }
      return nombreArchivoSerializado;
   }

   public static List<String> stringToList(String cadena,String separador){
      if (cadena == null || "".equals(cadena))
         return null;

      StringTokenizer st = new StringTokenizer(cadena,separador);
      List<String> s = new ArrayList<String>();

      while (st.hasMoreTokens()) {
         s.add(st.nextToken());
      }

      return s;
   }


   /*
    public List<String> jsonToTagList(String json){

        json = json.replaceAll("\\s+", "");
        json = json.replaceAll(".*\\[|\\].*", "");

        List<String> tags = Arrays.asList(json.split("\\s*,\\s*"));

        ArrayList listTag = new ArrayList();
        for (String tag : tags){
            Tag t = new Tag(tag);
            listTag.add(t);
        }
        TagList tl = new TagList();
        tl.setList(listTag);

        return tl;
    }
    */


   public String tagListToJson(List<String> tagList){
      String jsonInput = "";

      if( tagList != null && !tagList.isEmpty() ){
         jsonInput = ( "[\"" + tagList.get(0) + "\"" );
         for( int i = 1; i < tagList.size(); i++ ){
            jsonInput = ( jsonInput + "," + "\"" + tagList.get(i) + "\"" );
         }
         jsonInput = ( jsonInput + "]" );
      }
      return jsonInput;
   }


   /*
    * PUT /alfresco/upload/{store_type}/{store_id}/{id}
    */

   public String upload(String parentUuid, byte[] bytes, String filename, String desc) throws Exception {
      try {

         // SUBIENDO ARCHIVO VIA API RESTFUL
         String url = server + "/upload/workspace/SpacesStore/" + parentUuid + "/";
         PutMethod putMethod = new PutMethod(url + filename + "?ticket=" + ticket);

         Part[] parts = new Part[3];
         parts[0] = new FilePart("filedata", new ByteArrayPartSource(filename, bytes));
         parts[1] = new StringPart("filename", filename);
         parts[2] = new StringPart("description", desc);
         putMethod.setRequestEntity(new MultipartRequestEntity(parts, putMethod.getParams()));

         HttpClient client = new HttpClient();
         int status = client.executeMethod(putMethod);
         if (status == HttpStatus.SC_OK) {
            String content = putMethod.getResponseBodyAsString(1000);

            // ACTUALIZANDO EL CONTENIDO VIA WEBSERVICES CON CMI
            ParentReference parentRef = new ParentReference(STORE, parentUuid, null, Constants.ASSOC_CONTAINS, null);
            parentRef.setChildName("cm:" + filename);

            NamedValue[] properties = new NamedValue[2];
            properties[0] = Utils.createNamedValue(Constants.PROP_NAME, filename);
            properties[1] = Utils.createNamedValue(Constants.PROP_CONTENT, content);
            CMLCreate create = new CMLCreate("1", parentRef, null, null, null, Constants.TYPE_CONTENT, properties);

            NamedValue[] titledProps = new NamedValue[2];
            titledProps[0] = Utils.createNamedValue(Constants.PROP_TITLE, "titulo");
            titledProps[1] = Utils.createNamedValue(Constants.PROP_DESCRIPTION, "descripcion");
            CMLAddAspect aspect = new CMLAddAspect(Constants.ASPECT_TITLED, titledProps, null, "1");

            CML cml = new CML();
            cml.setCreate(new CMLCreate[] { create });
            cml.setAddAspect(new CMLAddAspect[] { aspect });

            RepositoryServiceSoapBindingStub repositoryServiceStub = WebServiceFactory.getRepositoryService();
            UpdateResult[] update = repositoryServiceStub.update(cml);

            System.out.println("UUID   : " + update[0].getDestination().getUuid());
            System.out.println("TICKET : " + ticket.toString());

            return update[0].getDestination().getUuid();

         } else {
            throw new Exception("Error al subir fichero'" + filename + "', status: " + HttpStatus.getStatusText(status));
         }
      } catch (Exception e) {
         throw new Exception("Error al subir archivo", e);
      }
   }

   /*
    * GET /alfresco/service/api/tags/{store_type}/{store_id}/{tag}/nodes
    */
   public String listaNodosxEtiqueta(String etiqueta)throws Exception {
      String url = server + "/service/api/tags/workspace/SpacesStore/"+etiqueta+"/nodes";
      String urlTicket = ( url + "?alf_ticket=" + ticket );
      String data = "";

      GetMethod method = new GetMethod(urlTicket);
      HttpClient client = new HttpClient();

      int status = client.executeMethod(method);
      System.out.println(" Estatus = " + status);

      if (status == HttpStatus.SC_OK) {
         data = method.getResponseBodyAsString(1000);
      } else {
         data = "ERROR";
         throw new Exception("No se listaron las etiquetas: " + HttpStatus.getStatusText(status));
      }

      return data;
   }


   /*
    * GET /alfresco/service/api/tags/{store_type}/{store_id}
    */
   public String listaEtiqueta()throws Exception {
      String url = server + "/service/api/tags/workspace/SpacesStore";
      String urlTicket = ( url + "?alf_ticket=" + ticket );
      String data = "";

      GetMethod method = new GetMethod(urlTicket);
      HttpClient client = new HttpClient();

      int status = client.executeMethod(method);
      System.out.println(" Estatus = " + status);

      if (status == HttpStatus.SC_OK) {
         data = method.getResponseBodyAsString(1000);
      } else {
         data = "ERROR";
         throw new Exception("No se listaron las etiquetas: " + HttpStatus.getStatusText(status));
      }

      return data;
   }

   public String listaEtiquetaxNodo(String nodoReferencia)throws Exception {
      String url = server + "/service/api/node/workspace/SpacesStore/"+nodoReferencia+"/tags";
      String urlTicket = ( url + "?alf_ticket=" + ticket );
      String data = "";

      GetMethod method = new GetMethod(urlTicket);
      HttpClient client = new HttpClient();

      int status = client.executeMethod(method);
      System.out.println(" Estatus = " + status);

      if (status == HttpStatus.SC_OK) {
         data = method.getResponseBodyAsString(1000);

      } else {
         data = "ERROR";
         throw new Exception("No se listaron las etiquetas: " + HttpStatus.getStatusText(status));
      }

      return data;
   }

   /*
    * POST /alfresco/service/collaboration/tagActions
    * Nota: Entra correctamente pero da resultado fallido
    */
   public String agregaUnaEtiqueta(String nodoReferencia, String etiqueta)throws Exception {
      String url = server + "/service/collaboration/tagActions";
      String jsonInput = "{\"a\" : \"add\", \"n\" : \"" + nodoReferencia + "\", \"t\" : \"" + etiqueta + "\"}";
      String urlTicket = ( url + "?alf_ticket=" + ticket );
      String data = "";

      PostMethod method = new PostMethod(urlTicket);
      StringRequestEntity requestEntity = new StringRequestEntity(jsonInput, "application/json", "UTF-8");
      method.setRequestEntity(requestEntity);
      HttpClient client = new HttpClient();

      int status = client.executeMethod(method);
      System.out.println(" Estatus = " + status);

      if (status == HttpStatus.SC_OK) {
           data = method.getResponseBodyAsString(1000);

      } else {
         data = "ERROR";
         throw new Exception("No se Agrego el tag: " + HttpStatus.getStatusText(status));
      }

      return data;
   }

   /*
    * POST /alfresco/service/api/node/{store_type}/{store_id}/{id}/tags
    * POST /alfresco/service/api/path/{store_type}/{store_id}/{id}/tags
    */
   public String agregaEtiquetas(String nodoReferencia, List<String> etiquetas)throws Exception {
      String url = server + "/service/api/node/workspace/SpacesStore/"+nodoReferencia+"/tags";
      String urlTicket = ( url + "?alf_ticket=" + ticket );
      String jsonInput = "";
      String data = "";

      if( etiquetas != null && !etiquetas.isEmpty() ){
         jsonInput = ( "[\"" + etiquetas.get(0) + "\"" );
         for( int i = 1; i < etiquetas.size(); i++ ){
            jsonInput = ( jsonInput + "," + "\"" + etiquetas.get(i) + "\"" );
         }
         jsonInput = ( jsonInput + "]" );
         System.out.println("Cadena Json: " + jsonInput);

         PostMethod method = new PostMethod(urlTicket);
         StringRequestEntity requestEntity = new StringRequestEntity(jsonInput, "application/json", "UTF-8");
         method.setRequestEntity(requestEntity);

         HttpClient client = new HttpClient();
         int status = client.executeMethod(method);
         System.out.println(" Estatus = " + status);

         if (status == HttpStatus.SC_OK) {
                data = method.getResponseBodyAsString(1000);
         } else {
            data = "ERROR";
            throw new Exception("No se Agrego el tag: " + HttpStatus.getStatusText(status));
         }

      }else{
         data = "ERROR";
      }

      return data;
   }


   /*
    * PUT /alfresco/service/api/tags/{store_type}/{store_id}/{tagName}
    *   PUT /alfresco/service/api/tags/{tagName}
    */
   public String modificaEtiqueta(String etiqueta, String etiquetaMod)throws Exception {
      String url = server + "/service/api/tags/workspace/SpacesStore/"+etiqueta;
      String urlTicket = ( url + "?alf_ticket=" + ticket );
      String jsonInput = ( "[\"" + etiquetaMod + "\"]" );
      String data = "";

      System.out.println("Etiqueta : " + etiqueta);
      System.out.println("Etiqueta : " + etiquetaMod);
      System.out.println("jsonInput : " + jsonInput);

      PostMethod method = new PostMethod(urlTicket);
      StringRequestEntity requestEntity = new StringRequestEntity(jsonInput, "application/json", "UTF-8");
      method.setRequestEntity(requestEntity);

      HttpClient client = new HttpClient();
      int status = client.executeMethod(method);

      System.out.println(" Estatus = " + status);
      if (status == HttpStatus.SC_OK) {
         data = method.getResponseBodyAsString(1000);
      } else {
         data = "ERROR";
         throw new Exception("No se modifico la Etiqueta: " + HttpStatus.getStatusText(status));
      }

      return data;
   }

   public static void main(String[] args) {
      // Parametros de conexion
      String user = "admin";
      String pass = "admin";
      String server = "http://192.168.0.145:8080/alfresco";
      String data = "";

      AlfrescoManager alfresco = new AlfrescoManager(user, pass, server);
      try {
         alfresco.startSession();

         // subre Archivo en una ruta especifica, se puede usar node o path, aqui va node
         File file = new File("E:\\fotosistemas.png");
         byte[] fileToBytes = fileToBytes(file);
         String companyHomeUuid = "a96ca18f-9399-49b6-a488-713ae8ac60df"; //Carpeta padre donde se van a colocar los archivos
         String uuid = alfresco.upload(companyHomeUuid, fileToBytes, alfresco.serializaNombre(file.getName()) , "descripcion");
         System.out.println( alfresco.serializaNombre( file.getName() ) );
         System.out.println(uuid);


         // Se lista todas las etiquetas que contiene el nodo
         // el nodo puede ser el mismo que se optiene en uuid, aqui lo deje fijo para efectos de prueba
         System.out.println("Listando Etiquetas para el nodo :");
         String nodoReferencia = "bb9f495a-dd63-44cd-83dc-9d0acd52fae0";
         data = alfresco.listaEtiquetaxNodo(nodoReferencia);
         System.out.println(data);

         // Lista todas las etiquetas que existen en el repositorio Alfresco
         System.out.println("Listando todas las etiquetas :");
         data = alfresco.listaEtiqueta();
         System.out.println(data);

         // Lista todos los nodos a los cuales esta agregada la etiqueta
         System.out.println("Listando Nodos por etiqueta : ");
         String etiqueta = "solicitudid";
         data = alfresco.listaNodosxEtiqueta(etiqueta);
         System.out.println(data);

         // Agrega una o mas etiquetas a un nodo
         System.out.println("Agregando nuevas etiquetas al nodo, si existe la etiqueta se queda con el mismo nombre");
         List<String> etiquetas = new ArrayList<String>();
         etiquetas.add("new");
         etiquetas.add("new2");
         etiquetas.add("new3");

         data = alfresco.agregaEtiquetas(nodoReferencia,etiquetas);
         System.out.println(data);


         System.out.println("NOTA: LAS SIGUIENTE FUNCIONES NO TRABAJAN CORRECTAMENTE");


         // agrega una etiqueta usando el metodo POST collections, pero no funciona
         // el nodo puede ser el mismo que se optiene en uuid, aqui lo deje fijo para efectos de prueba
         System.out.println("Agregando Etiqueta: ….. ");
         nodoReferencia = "bb9f495a-dd63-44cd-83dc-9d0acd52fae0";
         data = alfresco.agregaUnaEtiqueta(nodoReferencia, "nueva");
         System.out.println(data);

         // modifica el nombre de una etiqueta, en este punto al parecer no funciona
         // necesito verificar si la cadena enviada esta en el formato correcto
         etiqueta = "new3";   // etiqueta a modificar
         String etiquetaMod = "new3_modificada";
         data = alfresco.modificaEtiqueta(etiqueta, etiquetaMod);
         System.out.println("datos devueltos : " + data);

      } catch (Exception e) {
         e.printStackTrace();
      } finally {
         alfresco.endSession();
      }
   }
}
</java>

topic Re: Como usar Tags Programables in Alfresco Archive

Como usar Tags Programables

Re: Como usar Tags Programables