Google Summer of Code 2014

Organization - Mifos Initiative 

Mifos is a diverse community of microfinance institutions, technology professionals, business people, volunteers, and contributors. The Mifos Initiative is a 501(c)3 non-profit incorporated in Washington state whose mission is to speed the elimination of poverty by enabling financial service providers to more effectively and efficiently deliver responsible financial services to the world’s 2.5 billion poor and unbanked

Project - Client Impact Portal 

For a Microfinance institution it is useful to have a way of presenting overall client details and other institution details in a high level manner. This information may be useful to external parties that involve with the institutions such as funders and investors. Idea of this project is to provide such a capability to Mifos using a Client Impact Portal. This project consists of both the backend support and frontend for the user who intend to retrieve high level detail of the institutions. Project wiki page

Summer of code Interns in Mifos

This year Mifos have seven interns from four different countries who will be working under the leadership of  mentors from six different countries. They'll be working on a wide spectrum of projects that range from the back-end platform to the front-end community app, on down to mobile apps used directly in the field. By the end of the summer, Mifos community will benefit from a native Android app dedicated to making field staff more efficient, a mobile app for enabling Pay as you Go Solar Energy transactions, a vastly improved user experience for  community app, enhancements to  data migration tool, a batching API that will unlock performance improvements across the entire platform, as well as a powerful ad-hoc reporting tool and evolutions to the client impact portal to a production-ready release.

2014 Google Summer of Code Class of Interns

A Light-hearted Look at  2014 GSOC Interns
2014 Google Summer of Code – Bigger and Better than Ever

File Uploading with Spring

In web applications that uses Spring framework some times we may need to add functionality to upload file to server. This can be done easily as follows.



First create a form to select a  file,

<!--  Form -->

<i>Uploading File With Ajax</i><br/>

<form id="form" method="post" action="/fileUpload/upload/" enctype="multipart/form-data">

  <!-- File input -->   

  <input name="file" id="file" type="file" /><br/>

</form>

<button value="Submit" onclick="uploadJqueryForm()" >Upload</button><i>Using JQuery Form Plugin</i><br/>

<div id="result"></div>

</body>

</html>

when the button clicks, it calls uploadJqueryForm() function. In that function we can submit the file to the respective controller method. Here is the uploadJqueryForm() function

function uploadJqueryForm(){
    $('#result').html('');
   $("#form").ajaxForm({
    success:function(data) { 
          $('#result').html(data);
     },
     dataType:"text"
   }).submit();
}

This fuction will submit the file and calls the path specified in the "action" tag in the above form. Then we need to write a controller method to handle that request from the function uploadJqureyForm()

@RequestMapping(value = "fileUpload/upload", method = RequestMethod.POST)
    public @ResponseBody String upload(MultipartHttpServletRequest request, HttpServletResponse response,Model model) {                 
 
      Iterator itr =  request.getFileNames();
  
      MultipartFile mpf = request.getFile(itr.next());
      System.out.println(mpf.getOriginalFilename() +" uploaded!");
      String fullFileName="";
      String filePath="";
  
      try {
                
         ufile.length = mpf.getBytes().length;
         ufile.bytes= mpf.getBytes();
         ufile.type = mpf.getContentType();
         ufile.name = mpf.getOriginalFilename();
         
         
             InputStream in= mpf.getInputStream();    
             String fileName = mpf.getOriginalFilename();            
             
             String fileExtension = fileName.substring(fileName.indexOf(".")+1,fileName.length());
                
          
           filePath="D:\\DEV\\work\\files\\Temp\\";
           fullFileName = "D:/DEV/work/files/Temp/"+fileName;
          File files = new File(filePath);
          if (!files.exists()) {
           if (files.mkdirs()) {
            System.out.println("Multiple directories are created!");
           } else {
            System.out.println("Failed to create multiple directories!");
           }
          }
          writeFile(in,fullFileName);
          
      
  
     } catch (IOException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
     }
  
      
      return "home"; //or whatever the model you need
  
   }

In that methode we get the file as a Multipart request.

Inside this method we call writeFile() method. Here is that method.
this method will write the file into the server folder which we created in the above controller method.

private void writeFile(InputStream in,String fileName){
   
    File file = new File(fileName);
    FileOutputStream fo;
    logger.info("Saving File "+fileName);
   try {
    fo = new FileOutputStream(file);
      byte[] buf = new byte[512]; // optimize the size of buffer to your need
        int num;
        while ((num = in.read(buf)) != -1) {
         fo.write(buf, 0, num);
        }
      fo.flush(); 
        fo.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   
    }

References : Reference 1, Reference 2
   

Simple Web Service with JBoss AS

Introduction

What is a Web Service?

Web service is a application that provide client application to use server applications methods. Assume you have a simple java programme with several classes. You can use those classes only inside your programme( or you have to include them as lib files). If you develop your programme as web service and host it in a application server, then client programms can use those classes( actually the methods inside those classes) via a network. Special thin about web services is it is platform independent. That means you may develop your web service using java, but clients that use the web service need not to be java, it may be .Net or any other language. 

How it works

When we publish a web service to a application server, we can get a xml document called WSDL(there are several technologies, but for this article I make things simple). This is the key to the web service, it contains all the method signatures, what is the address that web service can access, what are the protocols used etc. When creating client side we use this document to specify way of communication with the server application. Then how the platform independence comes into action? When we sending messages we use a protocol, that means both sides knows what they are sending and receiving. When a client needs to request something from server it converts its message to that protocol, when server side get the request it converts it back to original version that the server application can understands. Same thing happens with the other way of communication. Most popular protocol is SOAP. You can read more from here

Things we need

• JDK 1.5 (or higher).
• JBoss App Server.
• Apache Maven (Read this how to install maven)
• IDE (I used Intellij Idea 12.0)

If you are using JBoss 5.0.0 or lesser version please make sure you install JBoss WS framework to your application server. Read this article to install those applications on to your pc.


For the rest of this article I assume you have installed and configured above things correctly.

Folder structure for web application (war)

Server can identify our application as web application, if we bundle the classes and other necessary files in the following manner. At the end of the this article I'm going to bundle all the necessary files into .war file using Maven build tool.

• classes folder contains all the classes in our application.
• lib folder contains all the libraries that need for the application
• web.xml file contains instructions to the server that which classes need to be loaded when web service is in action.
• for our discussion let's forget about other files/folders

Implementation

•  Create a java project (make sure you don't select any project modules such as web services, web services clients etc. for the first time we are going to start from the scratch)
• Then right click on the project name in Intellij and select add framework support, select maven and click ok.
• Now you have a clean maven java project. 

Now you have a project with pom.xml file. Folder structure should look like this.

• Right click on your java folder (in Intellij project tab) and select New > Package
• Give your package a name. ( I gave com.webservice)
• Now right click on main folder and select New>Directory. create a directory called webapp and inside that create a directory called WEB-INF (this is the folder that contains web.xml file so give names exactly as above)

Now we are ready to go.

Create a class in com.webservice package

This is the class that our web service methods are implemented.

Now we can implement methods for our web service. Let’s create helloworld method that returns a string.

Now we need to make this class a web service class and this method a web service method. We can do it by adding annotations.  Just before your class name add @WebClass and before your method name add @Webmethod. After adding those annotations it will not recognize by our program, put cursor on those words and press Alt+enter to import  javax.jws.WebMethod and javax.jws.WebService.

Here is the WebClass

 package com.webservice;  
 import javax.jws.WebMethod;  
 import javax.jws.WebService;  
 /**  
  * Created by IntelliJ IDEA.  
  * User: Chann  
  * Date: 1/15/14  
  * Time: 9:58 PM  
  * To change this template use File | Settings | File Templates.  
  */  
 @WebService  
 public class WebClass {  
     @WebMethod  
    public String helloWebService(String name){  
      return "Hello "+ name;  
    }  
 } 

Now create a file named web.xml inside WEB-INF folder and add followings to that file. This is the file that contains details about our web service to server. <servlet-class> tag defines the classes that are related to web service. Let’s postpone to discuss about url-patterns and other stuff.

 <web-app>  
   <servlet>  
     <servlet-name>HelloWebService</servlet-name>  
     <servlet-class>com.webservice.WebClass</servlet-class>  
   </servlet>  
   <servlet-mapping>  
     <servlet-name>HelloWebService</servlet-name>  
     <url-pattern>/*</url-pattern>  
   </servlet-mapping>  
 </web-app>  

Now it’s almost done coding our web service. Now we need to build these classes and package them to a war file to deploy in JBoss server

We use maven to build our project. We have a pom.xml file in our project. Let’s modify it to do our job.

We need to package our web service as a war file. That is done through the <packaging> tag.

 <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemalocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
   <modelversion>4.0.0</modelversion>  
   <groupid>groupId</groupid>  
   <artifactid>WebService</artifactid>  
   <version>1.0-SNAPSHOT</version>  
   <packaging>war</packaging>  
   <dependencies>  
     <dependency>  
       <groupid>com.sun.xml.bind</groupid>  
       <artifactid>jaxb-core</artifactid>  
       <version>2.2.8-b01</version>  
     </dependency>  
     <dependency>  
       <groupid>com.sun.xml.bind</groupid>  
       <artifactid>jaxb-impl</artifactid>  
       <version>2.2-promoted-b65</version>  
     </dependency>  
   </dependencies>  
   <build>  
     <plugins>  
       <plugin>  
         <artifactid>maven-war-plugin</artifactid>  
         <version>2.4</version>  
         <configuration>  
           <packagingexcludes>WEB-INF/lib/*.jar</packagingexcludes>  
         </configuration>  
       </plugin>  
     </plugins>  
   </build>  
 </project> 

we need to add the war plugin to make a war using maven. That is the reason to add maven-war-plugin to our pom.xml file. We need to add <packagingExcludes> tag to bundle our WEB-INF folder without addional jar files(some times it gives errors if we keep those jar lib files inside WEB-INF folder). And additionally we need to add two dependencies to work properly. Now we can make our project. Either click package in maven life-cycle in Intellij idea(in left side) or open project folder via cmd prompt ( open cmd prompt and navigate to project folder) and then type maven clean install, press enter. You can find the war file in target folder inside project folder.

Now you can put this war file inside JBoss>Server>default>deploy folder. And run the Start.bat file inside JBoss > bin folder to start the server.

Now your web service is in action.