Archive for July 2016

Home Archive for July 2016

There are lots of tool available which can be integrated with alfresco for performing PDF to PDF conversation with OCR.The best tool which i used so far is PDFsandwich.Any one can download it as its an open source.Another tool which can be integrated is tesseract.Internally pdfsandwich is using tesseract only, but i prefer pdfsandwich.

Technically, its doesn't matter which tool you are selecting, the thing which differ is output only.There is not much change in development if you want to change the tool.So for this things what we are going to do is we will create one shell script which is going to fire this command and generate output.We will fetch that out put and will overide existing file in alfresco.

Let's go further in development.

The first step for developing this is to create shell script and executing it and testing it.

Create file called transformation.sh and before adding your command in it you have to add below line in it.If you are using windows you need to create batch file accordingly.

unset LD_LIBRARY_PATH

If you are not setting above in the script file you will face an error while conversation.You can find that bug details on below link of alfresco.Its registered issue in alfresco.

https://issues.alfresco.com/jira/browse/ALF-19946

Once you create script in linux , you have to create action-executor in alfresco which fire script which we have created.You will be able to create action-executor by following below steps.

TransformerAction.java

package com.ocr;


import java.io.File;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.alfresco.repo.content.transform.ContentTransformerHelper;
import org.alfresco.repo.content.transform.ContentTransformerWorker;
import org.alfresco.service.cmr.repository.ContentIOException;
import org.alfresco.service.cmr.repository.ContentReader;
import org.alfresco.service.cmr.repository.ContentWriter;
import org.alfresco.service.cmr.repository.MimetypeService;
import org.alfresco.service.cmr.repository.TransformationOptions;
import org.alfresco.util.TempFileProvider;
import org.alfresco.util.exec.RuntimeExec;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class TransformerAction extends ContentTransformerHelper implements ContentTransformerWorker {

    private static final Log logger = LogFactory.getLog(TransformerAction.class);

    private static final String VAR_SOURCE = "source";
    private static final String VAR_TARGET = "target";
    
    private RuntimeExec executer;
    
    
    private RuntimeExec checkCommand;
    
    //Injected
    private MimetypeService mimetypeService;
    
    
    private boolean available=true;
    private Date lastChecked = new Date(0l);
    private int checkFrequencyInSeconds=120;
    
    public void setCheckFrequencyInSeconds(int frequency) {
     checkFrequencyInSeconds=frequency;
    }
    
   
    public boolean isAvailable() {
     Date refreshAvailabilityDate = new Date(lastChecked.getTime()+1000l*checkFrequencyInSeconds);
     if (new Date().after(refreshAvailabilityDate)) {
      test();
     }
     return available;
    }
    
    public void setMimetypeService(MimetypeService ms) {
     mimetypeService=ms;
    }
    
   
    public void setTimeout(long timeout) {
     pdfTimeout=timeout;
    }
    public long pdfTimeout=60000l;
    
    
    public void setExecuter(RuntimeExec executer) {
        this.executer = executer;
    }
    
    public void setCheckCommand(RuntimeExec checkCommand) {
        this.checkCommand = checkCommand;
    }
    
    protected void test() {
     try {
      logger.debug("Testing availability");
      RuntimeExec.ExecutionResult result = checkCommand.execute();
      available=result.getSuccess();
      logger.info("Is tesseract available? "+available);
     }
     catch (Exception e) {
      available=false;
      logger.warn("Check command ["+checkCommand.getCommand()+"] failed.  Registering transform as unavailable for the next "+checkFrequencyInSeconds+" seconds");
     }
    }
    
    public final void transform(ContentReader reader, ContentWriter writer, TransformationOptions options) throws Exception
    {
     try {
   logger.debug("Beginning transform for "+reader.getContentData().getContentUrl());

   String sourceMimetype = getMimetype(reader);
         String targetMimetype = getMimetype(writer);
         String sourceExtension = mimetypeService.getExtension(sourceMimetype);
         String targetExtension = mimetypeService.getExtension(targetMimetype);
 
         File sourceFile = TempFileProvider.createTempFile(getClass().getSimpleName() + "_source_", "." + sourceExtension);
         File targetFile = TempFileProvider.createTempFile(getClass().getSimpleName() + "_target_","."+targetExtension);
         
         logger.debug("Temp files created");
         reader.getContent(sourceFile);
         
         logger.debug("Source file written");
         Map properties = new HashMap(5);
 
         properties.put(VAR_SOURCE, sourceFile.getAbsolutePath());
         properties.put(VAR_TARGET, targetFile.getAbsolutePath());
         RuntimeExec.ExecutionResult result = executer.execute(properties, pdfTimeout);
         File actualLocation = new File(targetFile.getAbsolutePath());
         actualLocation.renameTo(targetFile);
         
         if (result.getExitValue() != 0 && result.getStdErr() != null && result.getStdErr().length() > 0) {
             throw new ContentIOException("Failed to perform OCR transformation: \n" + result);
         }
         logger.debug("Transform executed");
         
         writer.putContent(targetFile);
         logger.info("Transform complete");
     }
     catch (Exception e) {
      logger.error("Exception during transform",  e);
      throw e;
     }
    }

 @Override
    public boolean isTransformable(String sourceMimetype, String targetMimetype, TransformationOptions options) {
  if (targetMimetype.equals("application/pdf")) {
   if (sourceMimetype.equals("application/pdf")) {
    return true;
   }
  }
  return false;
 }

 
 @Override
 public String getVersionString() {
  return "Tesseract Transformer V1.0 - this method not implemented yet";
 }
}

transformer-context.xml



 
  
   
  
  
   
    
     
      image/png
     
     
      text/plain
     
    
    
     
      image/jpeg
     
     
      text/plain
     
    
    
     
      image/gif
     
     
      text/plain
     
    
   
  
 


 
  
   
  
  
   
    
     
      
       
        /usr/bin/scriptname.sh
        ${source}
        ${target}
       
      
     
    
   
  
  
   
    
     
      
       
        /usr/bin/scriptname.sh
        -v

OCR.properties

transformer.pdf.title=PDF OCR
transformer.pdf.description=Content file will be converted to PDF and OCR process will produce a searchable PDF file.
transformer.pdf.continue-on-error.display-label=Continue on error

Once you create this files in your project, you will be able to see action under rule called PDF OCR.Select it as a rule and do other configuration as per your requirement.You will be able to perform PDF to PDF conversation. Hope this helps.

Dashlet is part of alfresco share dashboard.Alfresco provides some out of box dashlets like "My Task", "RSS Feed", "Web View","My Calendar", "My Sites" and many other dashlets are available.You can test all this dashlet by adding it in your dashboard.User can add dashlets on two places. One of them is User Dashboard and other is Site Dashboard.

Technically , Dashlet is nothing but webscript.Webscript which created in alfresco share.

Developer can create both kind of dashlet which can be added on both places User Dashboar as well as SiteDashboard.

For creating dashlet you will need to have basic knowledge of webscript. If you dont have any knowledge regarding same you can follow below link for deep knowledge.

https://wiki.alfresco.com/wiki/Web_Scripts

For creating dashlet in alfresco share you will need to create below files, Its not required to create all files.It depends on you requirement, and how you want to make behave your share dashlet. The importance of all files is explained as below.

FileType	Description	Suffix
Descriptor	Dashlet descriptor contains the definition of dashlet.For example ,family of dashlet,URL of dashlet etc…	*get.desc.xml
Javascript Controller	Controller of dashlet from where information are passed to template engine(freemarker)	*.js
Template Type	It renderes the output.	.html.ftl
Header	Includes style sheet and client side javascript.(deprecated)	*.head.ftl
YUI Script	Client side javascript module.	SampleDashlet.js

Above are the files which are used for creating dashlet. Below is an simple dashlet.

sample.get.desc.xml

sample.get.js

sample.get.html.ftl

sample.get.head.ftl(deprecated)

sample.js

Here please not the difference between sample.js and sample.get.js. sample.js is client side javascript file while sample.get.js is server side javascript file. Many people get confused in this.This is the first thing which you should remember while developing a dashlet.

Below is an example for simple dashlet in alfresco.

sample.get.desc.xml




    Sample Dashlet

    Provide Search of people and display in a list

    user-dashlet

    /components/dashlets/member-directory

sample.get.js

model.name="Krutik";

SampleDashlet.js

model.name="Krutik";

sample.get.html.ftl


<#assign id = args.htmlid?html>
<@markup id="js">

  <@script type="text/javascript" src="${url.context}/res/components/sample-dashlet/SampleDashlet.js" group="dashlets"/>
</@>

<@markup id="widgets">
    <@createWidgets group="dashlets"/>
</@>

<@markup id="html">

        



Sample Dashlet




Click me



The user dashboard displays when users arrive to a dashboard of user, and contains dashlets. A dashlet offers a quick view into the content or activities of the user. You can use the out-of-the-box dashlets or add your own custom dashlets in to your dashboard.

    





By ${name}

    






</@>

SampleDashlet.js


(function()
{
   /**

    * YUI Library aliases
*/

      Event = YAHOO.util.Event;
var Dom = YAHOO.util.Dom,


    * Alfresco Slingshot aliases
/**
    */

   var $html = Alfresco.util.encodeHTML,
$combine = Alfresco.util.combinePaths;


   Alfresco.dashlet.SampleDashlet = function SampleDashlet_constructor(htmlId)
{

   };
return Alfresco.dashlet.SampleDashlet.superclass.constructor.call(this, "Alfresco.dashlet.SampleDashlet", htmlId);


   YAHOO.extend(Alfresco.dashlet.SampleDashlet, Alfresco.component.Base,
/**
    * Extend from Alfresco.component.Base and add class implementation
    */
   {
      /**

      options:
* Object container for initialization options
       *
       * @property options
       * @type object
       */
      {
       
      },
      

        Event.addListener(this.id + "-link", "click", this.onLinkClick, this, true);
onReady: function SampleDashlet_onReady()
      {

     var link = Dom.get(this.id + "-link");     
        console.log("Dashlet Ready");



},
      onLinkClick: function SampleDashlet_onLinkClick(e)
      {
       alert("Clicked...");
       return false;
      }
   });
})();

Once user clicks on click me link.

Hibernate

Introduction

Hibernate is an Object-Relational Mapping(ORM) solution for JAVA and it raised as an open source persistent framework .

Hibernate maps Java classes to database tables and from Java data types to SQL data types and relieve the developer from 95% of common data persistence related programming tasks.

Hibernate sits between traditional Java objects and database server to handle all the work in persisting those objects based on the appropriate O/R mechanisms and patterns.

Advantages:

· Hibernate takes care of mapping Java classes to database tables.

· Provides simple APIs for storing and retrieving Java objects directly to and from the database.

· Abstract away the unfamiliar SQL types and provide us to work around familiar Java Objects.

· Manipulates Complex associations of objects of your database.

· Minimize database access with smart fetching strategies.

· Provides Simple querying of data.

Hibernate Architecture:

The Hibernate architecture is layered to keep you isolated from having to know the underlying APIs. Hibernate makes use of the database and configuration data to provide persistence services (and persistent objects) to the application.

Following is a very high level view of the Hibernate Application Architecture.

Following is a detailed view of the Hibernate Application Architecture with few important core classes.

Hibernate uses various existing Java APIs, like JDBC, Java Transaction API(JTA), and Java Naming and Directory Interface (JNDI). JDBC provides a rudimentary level of abstraction of functionality common to relational databases, allowing almost any database with a JDBC driver to be supported by Hibernate. JNDI and JTA allow Hibernate to be integrated with J2EE application servers.

Following section gives brief description of each of the class objects involved in Hibernate Application Architecture.

Configuration Object:

The Configuration object is the first Hibernate object you create in any Hibernate application and usually created only once during application initialization. It represents a configuration or properties file required by the Hibernate. The Configuration object provides two keys components:

· Database Connection: This is handled through one or more configuration files supported by Hibernate. These files are hibernate.properties and hibernate.cfg.xml.

· Class Mapping Setup. This is achieved by using hbm.xml file or by Annotations.

This component creates the connection between the Java classes and database tables.

SessionFactory Object:

Configuration object is used to create a SessionFactory object which intern configures Hibernate for the application using the supplied configuration file and allows for a Session object to be instantiated. The SessionFactory is a thread safe object and used by all the threads of an application.

The SessionFactory is heavyweight object so usually it is created during application start up and kept for later use. You would need one SessionFactory object per database using a separate configuration file. So if you are using multiple databases then you would have to create multiple SessionFactory objects.

· Read

· Check db

· Connection into memory

· Parse all hbm files

· Corresponding tables exist

Session Object:

A Session is used to get a physical connection with a database. The Session object is lightweight and designed to be instantiated each time an interaction is needed with the database. Persistent objects are saved and retrieved through a Session object.

The session objects should not be kept open for a long time because they are not usually thread safe and they should be created and destroyed them as needed.

Transaction Object:

A Transaction represents a unit of work with the database and most of the RDBMS supports transaction functionality. Transactions in Hibernate are handled by an underlying transaction manager and transaction (from JDBC or JTA).

This is an optional object and Hibernate applications may choose not to use this interface, instead managing transactions in their own application code.

Query Object:

Query objects use SQL or Hibernate Query Language (HQL) string to retrieve data from the database and create objects. A Query instance is used to bind query parameters, limit the number of results returned by the query, and finally to execute the query.

Criteria Object:

Criteria object are used to create and execute object oriented criteria queries to retrieve objects.

Hibernate Relationships:

Using hibernate, if we want to put relationship between two entities [objects of two pojo classes], then in the database tables, there must exist foreign key relationship, we call it as Referential integrity.

One-To-One

A one-to-one relationship occurs when one entity is related to exactly one occurrence in another entity.

@Entity

public class Body {

@Id

    private Long id;

    @OneToOne(cascade = CascadeType.ALL)

    @PrimaryKeyJoinColumn

    private Heart heart;

...

@Entity

public class Heart {

@Id

    public Long getId() { ...}

One-To-Many

It is a type of relationship in which each record in one table is linked to multiple records in another table.

@Entity

public class Troop {

    @OneToMany(mappedBy="troop")

    private Set<Soilder> soldiers;

...

@Entity

public class Soldier {

    @ManyToOne

    @JoinColumn(name="troop_fk")

    Private Troop troop;

...

Many-to-one

Many-to-one associations are declared at the property level with the annotation @ManyToOne:

@Entity

public class Flight implements Serializable {

 @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )

 @JoinColumn(name="COMP_ID")

 private Company company();

...

Many-to-Many

It is a logical data relationship in which the value of one data element can exist in combination with many values of another data element, and vice versa.

@Entity

@Table(name="EMPLOYEE")

public class Employee {

    @ManyToMany(cascade = {CascadeType.ALL})

    @JoinTable(name="EMPLOYEE_MEETING",

    joinColumns={@JoinColumn(name="EMPLOYEE_ID")},

    inverseJoinColumns={@JoinColumn(name="MEETING_ID")})

    private Set<Meeting> meetings = new HashSet<Meeting>();

...

@Entity

@Table(name="MEETING")

public class Meeting {

    @ManyToMany(mappedBy="meetings")

    private Set<Employee> employees = new HashSet<Employee>();

...

Hibernate Annotations:

@Entity

This annotations is used to mark a class as an Entity bean.

@Table

The @Table annotation allows you to specify the details of the table that will be used to persist the entity in the database.

@ID and @Generated Value

Each entity bean will have a primary key, which you annotate on the class with the @Id annotation. The primary key can be a single field or a combination of multiple fields depending on your table structure.

By default, the @Id annotation will automatically determine the most appropriate primary key generation strategy to be used but you can override this by applying the @GeneratedValue annotation which takes two parameters strategy and generator. Preferred way is to use only default the default key generation strategy. Letting Hibernate determine which generator type to use makes your code portable between different databases.

@Column

The @Column annotation is used to specify the details of the column to which a field or property will be mapped. You can use column annotation with the following most commonly used attributes:

· name attribute permits the name of the column to be explicitly specified.

· length attribute permits the size of the column used to map a value particularly for a String value.

· nullable attribute permits the column to be marked NOT NULL when the schema is generated.

· unique attribute permits the column to be marked as containing only unique values.

Example:

@Entity

@Table(name = "EMPLOYEE")

public class Employee {

@Id

@GeneratedValue

@Column(name = "id")

private int id;

@Column(name = "first_name")

private String firstName;

@Column(name = "last_name")

private String lastName;

@Column(name = "salary")

private int salary;

public Employee() {}

public int getId() {

return id;

}

public void setId( int id ) {

this.id = id;

}

public String getFirstName() {

return firstName;

}

public void setFirstName( String first_name ) {

this.firstName = first_name;

}

public String getLastName() {

return lastName;

}

public void setLastName( String last_name ) {

this.lastName = last_name;

}

public int getSalary() {

return salary;

}

public void setSalary( int salary ) {

this.salary = salary;

}

Subscribe to: Posts ( Atom )

Navigation

Krutik Jayswal

OCR on pdf file in alfresco

Share Dashlet Using YUI

Hibernate and Relationship