Othman

This Guide describes the steps to setup a jbilling version 2.x development environment. This guide applies to current settings:

• Operating System : Linux (or any  *nix OS system).
• Java version : Java 6 or higher.
• Database system : PostgreSQL 8 or higher.
• JBilling version 2 (this doesn’t apply to jbilling 3 where you can find instructions to build jbilling 3  here).

1-Database System Setup :

follow the steps below to set up a postgresql database system for use with jbilling:

• download and install PostgreSQL open source database engine from this page .
• in most linux systems when postgresql is instqlled user postgres has no password set. you can set one using this command:

• $passwd postgres (assign the new user a password)
  

• Initialize postgresql cluster by running the following commands:

root# mkdir /usr/local/pgsql/data
root# chown postgres /usr/local/pgsql/data
root# su postgres
postgres$ initdb -D /usr/local/pgsql/data

Now you need to enable pg_hba  config file for permissions configuration:

• locate file pg_hba.conf.sample (usually in /usr/share/postgresql . sometimes you could find another file in folder /var/lib/postgresql/data/ so you need to change both files).

• activate file pg_hba.conf using this command:

 $sudo cp pg_hba.conf.sample  pg_hba.conf

• Edit the PostgreSQL pg_hba.conf file and change the “local” and “IPv4″ localhost connection types:

# "local" is for Unix domain socket connections only
local all all trust
# IPv4 local connections:
host all all 127.0.0.1/32 trust

• start the database server using:

$  postgres -D /usr/local/pgsql/data

or

  $  pg_ctl -D /usr/local/pgsql/data -l logfile start

• To prevent having to retype the full command every time we start or stop the database, create a start script and a stop script in the postgres user’s home directory named pg_start and pg_stop. Below are the contents of the pg_start file. Make sure to create these files as the postgres user in the home directory:

$ sudo su - postgres

$ vim ./pg_start

#!/bin/sh

pg_ctl -D /user/local/pgsql/data -l /user/local/pgsql/log/postgres.log start &

• Below are the contents of the pg_stop file:

$ vim ./pg_stop

#!/bin/sh

pg_ctl -D /user/local/pgsql/data  -l /user/local/pgsql/log/postgres.log stop

• Don’t forget to make them executable:

$ chmod +x ./pg_start

$ chmod +x ./pg_stop

• Now use the pg_start script to start up PostgreSQL. Execute it as the postgres user (sudo su – postgres) I tend to cat the log file just to make sure it’s running correctly:

$ ./pg_start

$ server starting

$ cat ../../log/postgres.log

LOG: database system is ready to accept connections

LOG: autovacuum launcher started

• There is a Mac OS X way of starting PostgreSQL using launchctl . for those using Mac OS X you can use either lauchctl or simply the pg_ctl method. see this page  for details on how to “Create a launchd Launch Agent” to automatically start postgres for you. The instructions look right for Tiger, Leopard, and Snow Leopard. (Beyond that, google for “postgres launchd”).

• the next step is to use the following commands to create user “jbilling” and database “jbilling_test” :

• change user to postgres using command :

$su -postgres

• at postgesql shell issue the following two commands:

postgres=#CREATE ROLE jbilling WITH LOGIN SUPERUSER CREATEDB CREATEROLE PASSWORD 'jbilling';

postgres=#CREATE DATABASE jbilling_test WITH OWNER jbilling;

Now you have a Postgresql database ready to use with the jbilling system.

2-JBilling System Setup:

To build jbilling from sources follow these instructions from jbilling website.  after you complete these steps you will need some extra steps not mentioned in previous instructions to get your jbilling development envirenment setup correctly:

The extra steps you need to do :

•   copy file   ~/jbilling/src/jars/postgresql.jdbc4.jar  to   ~/jbilling/lib/ (in case it is not already there)

• change this line in file  ~/jbilling/conf/jbilling.properties:

# time interval for scanning cached rules bases for updates
rules_scanner_interval=5

• rename file “~/jbilling/src/build.properties.sample”  (remove .sample )

• set BASEDIR envirement variable :

export BASEDIR= YOUR_JBILLING_INSTALLATION_DIR
(example :
export BASEDIR=/home/othman/Development/Java/workspace/jbilling/
)

• If you use  eclipse  IDE  see instructions on how to use eclipse with jbilling here

• select eclipse output directory as “jbilling/src/build/classes”.

The steps described above should get you a correctly setup jbilling 2 development environment.

Happy JBilling coding!

---

Recommended Links:

• Building JBilling 3 from source.

Authentication and Authorization for Google APIs is a common feature in today’s applications requiring integration and information exchange with Google services. while most of this Google authentication process is tailored for web applications, it is also available for desktop and installed applications. for Desktop applications Google recommends using an authentication method called ClientLogin.

ClientLogin method Caution:
Google no more recommands using ClientLogin method for Authorization. here is a quote from google documentation:

ClientLogin is a Google proprietary authorization API, available as an alternative to OAuth for most Google APIs. You should avoid using ClientLogin if possible. If you already have applications that use ClientLogin, you should migrate to OAuth or the hybrid protocol.

Thus, ClientLogin is for use only when there is a high level of trust between the application and the owner of the protected data. It is mostly commonly recommend for cases where the application owns the protected data. If users of your application are worried about supplying their passwords for security and privacy reasons then ClientLogin authorization method is not suited for this situation.

How ClientLogin authorization works?
The ClientLogin method works mainly by sending HTTP Post requests to Google service using specific parameters as described in Google documentation. In this article we will use a different approach to implement ClientLogin authorization process. We will use Google APIs Client Library for Java, which is a powerful java library for accessing Google’s HTTP-based API’s on the web. The most important class in this library is , Obviously, the ClientLogin class.

Anatomy of the ClientLogin class:
ClientLogin class provides a single method authenticate() which handles the details of authentication process. it also provides an important internal class ErrorInfo which could be used to handle authentication errors and captcha challenge logic.
In this post we present a clean wrapper class for ClientLogin which handles the complete ClientLogin authorization process including authentication errors parsing and captcha challenge handling.

google-api-java-client Maven Dependencies:
we chose to use maven for building our project example. Maven provides dependencies for the Google APIs Client Library for Java. just add the following maven dependencies to your pom.xml file:

 <dependency>
      <groupId>com.google.api.client</groupId>
      <artifactId>google-api-client-googleapis-auth-clientlogin</artifactId>
      <version>1.2.3-alpha</version>
    </dependency>
    <dependency>
    <groupId>com.google.api.client</groupId>
    <artifactId>google-api-client-javanet</artifactId>
    <version>1.2.3-alpha</version>
  </dependency>

after that use maven:install to install the required jars to be included in our project classpath.

GoogleClientLogin wrapper class:
Our wrapper class obviously contains a reference to ClientLogin . it provides public methods implementing the important functions of the authentication process.
GoogleClientLogin has a constructor that takes a String representing the Google service you’re requesting authorization for ( for example “cl” for Google Calendar). The constructor looks like this:

/**
	 * @param service
	 */
	public GoogleClientLogin(String service) {
		super();
		this.service = service;
		authenticator = new ClientLogin();
		transport = GoogleTransport.create();
		authenticator.authTokenType = service;
	}

The main method is authenticate(username,password) that takes two arguments representing the username and password input by user:

/**
	 * @param username
	 * @param password
	 * @throws ClientLoginException
	 */
	public void authenticate(String username, String password)
			throws ClientLoginException {

		try {

			// authenticate with ClientLogin
			authenticator.username = username;
			authenticator.password = password;
			Response response = authenticator.authenticate();
			this.authToken = response.auth;

		} catch (HttpResponseException e) {
			parseError(e);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

this method sets ClientLogin variables (username and password) then calls ClientLogin.authenticate() which returns a Response instance. if the ClientLogin.authenticate() call is successful we store the Authentication token ‘Response.auth’. The advantage of the authenticate(username,password) wrapper method is its intelligent handling of authentication errors.

Parsing Authentication errors:
We distinguish two Error categories that could be thrown during the call to Clientlogin.authenticate(): a-unrecoverable Errors for which we use a ClientLoginException class
b-a recoverable error thrown when Google service requires a captcha challenge. for this later we use a separate Exception class CaptchaRequiredException which extends the first ClientLoginException class.
Clientlogin.authenticate() throws a HttpResponseException if the authentication response has an error code. we provide a helper method for parsing this exception class as follows:

/**
	 * @param e
	 * @throws ClientLoginException
	 */
	private void parseError(HttpResponseException e)
			throws ClientLoginException {
		try {

			ClientLogin.ErrorInfo errorInfo = e.response.parseAs(ClientLogin.ErrorInfo.class);
			errorMessage = errorMsg.get(errorInfo.error);
			if (errorInfo.error.equals(CaptchaRequired)) {
				captchaToken = errorInfo.captchaToken;
				captchaUrl = errorInfo.captchaUrl;
				throw new CaptchaRequiredException(errorMessage, e);

			} else
				throw new ClientLoginException(errorMessage, e);
		} catch (IOException e1) {
			
			throw new ClientLoginException(e1);
		}
	}

we Call HttpResponseException.response.parseAs(ClientLogin.ErrorInfo.class) to parse the response. if the error code is “CaptchaRequired” we store errorInfo.captchaToken and errorInfo.captchaUrl then throw CaptchaRequiredException. for the rest of Error codes we just throw ClientLoginException.

Authentication with CAPTCHA Challenge:
in the case of a CAPTCHA challenge we provide a second authenticate() method which provides an extra argument ‘captchaAnswer’ representing the captcha key entered by user during a CAPTCHA challenge:

/**
	 * @param username
	 * @param password
	 * @param captchaAnswer
	 * @throws ClientLoginException
	 */
	public void authenticate(String username, String password,
			String captchaAnswer) throws ClientLoginException {
		authenticator.username = username;
		authenticator.password = password;
		authenticator.captchaToken = this.captchaToken;
		authenticator.captchaAnswer = captchaAnswer;
		try {
			Response response = authenticator.authenticate();			
			this.authToken = response.auth;
		} catch (HttpResponseException e) {
			parseError(e);
		} catch (IOException e) {
			throw new ClientLoginException(e);
		}
	}

before calling authenticator.authenticate() this method sets two extra fields authenticator.captchaToken and authenticator.captchaAnswer. Error handling for this method is the same as the main authenticate(username,password) method.
Finally we provide a method to retrieve the CAPTCHA image that will be displayed to user:

/**
	 * @return the captchaImage
	 */
	public BufferedImage getCaptchaImage() {

		BufferedImage image = null;
		try {
			URL url = new URL("https://www.google.com/accounts/"+ getCaptchaUrl());
			image = ImageIO.read(url);
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}

		return image;
	}

You can view the complete GoogleClientLogin class source file here.

Testing GoogleClientLogin wrapper class:
GoogleClientLoginDialog is a swing Dialog which presents an example of how to use GoogleClientLogin wrapper class. It provides a feature to force Google service to send a CAPTCHA challenge. we implement this test using a thread that keeps sending random passwords until Google responds with a CAPTCHA challenge:

 private class ForceCaptchaRunnable implements Runnable{

		public void run() {
			Random r = new Random();
			boolean isCaptcha = false;
			while (!isCaptcha) {
				try {
					client.authenticate(textField.getText().trim(),
							passwordField.getText().trim()+ r.nextInt(100));
					showMessage("Auth Token: "+client.getAuthToken());
				} catch (CaptchaRequiredException e1) {
					
					isCaptcha = true;
					showCaptcha(true);
					
				} catch (ClientLoginException e1) {
					
				}
			}
			
		}
		
	}

You can view and download the complete source code of this sample project at Google code project: google-apis-utils .

---

Resources:
Google code project: google-apis-utils.

GWT developers will notice an annoying problem running the basic default GWT app locally in web mode in IE every time i try this I get a red warning message: “Your web browser must have JavaScript enabled in order for this application to display correctly”. I had to allow the active content  in order to see the web app screen. running in GWT dev mode seems not to raise this warning message. So what’s this all about? it seems IE doesn’t like people opening JavaScript-laced web pages from the local drive for security concern. there is a detailed article here that speaks about this issue  of Microsoft blocking local domain for web applications .

The article above speaks about a new concept introduced by Microsoft called Mark of the web. i tried the method of Mark of the web by adding these two lines at the begining of my GWT html file :

 
<!-- saved from url=(0014)about:internet -->
<!-- saved from url=(0016)http://localhost --> 

but when i add these two lines and then compile GWT app and open the html file with IE the web app doesn’t show even though the warning message is gone . The reason probably is that -by default- a GWT app is loaded within an iframe, i.e. as another HTML page (*.cache.html), which doesn’t contain the MotW (Mark of the web).
to overcome this problem we can try using the “xs” or “xsiframe” linker, i.e. add one of these lines to our *.gwt.xml:

<add-linker name="xs" />
<add-linker name="xsiframe" />

Those linkers use *.cache.js” files, so the MotW in our host page should be enough. adding the linker to GWT xml module file makes IE warning message go away and I can run the GWT web app locally with IE.
but The “xs” linker has one drawback : it prevents us from using GWT DevMode . another annoyance that we can overcome by using two *.gwt.xml module files: one for web mode testing with ‘xs’ linker and the other without the linker for testing in GWT DevMode.

This may give you an Idea about the coding acrobatics one should go through to overcome the weired Microsoft decision to block totally the Machine local zone for web applications!

Like hundreds of GWT developers I stepped into the annoying GWT KeyPressEvent.getCharCode() bug problem described here
To turn around this bug i tried using:

event.getNativeEvent().getKeyCode()

the purpose is to access the native event to get the unprocessed code. However if you try the

event.getNativeEvent().getKeyCode()

you will knock your head against browser-specific inconsistencies. For example the getCharCode() from NativeEvent works for me in FireFox 3 but it doesn’t work in Chrome . in Chrome if i press “ENTER” key

 event.getNativeEvent().getKeyCode()=10

But

 KeyCodes.KEY_ENTER=13

in FF3 the two values are equal (’13′).
It appears that a fix for KeyPressHandler was completed and reviewed for this issue . but it is not clear when we could expect it to be released. The fix appears fairly complex, with different browser-specific implementations.
it turns out that this change set is actually exactly what causes the current behavior in Firefox. See the rationale and a workaround/fix (i.e. only use getNativeEvent() when getCharCode returns 0).
the workaround above works but we need to replace ’13′ with ’10′ in the fix code portion below :

} else if (charCode == 13) {

    doOnEnterKeyPressed();
  }

using ’10′ instead of ’13′ in the else if conditional:

} else if (charCode == 10) {

    doOnEnterKeyPressed();
  }

with this new change code works both in chrome and FF3.

Hope this could be helpful for anyone experiencing these GWT keyPress getCharCode() problems.

I have been encountering a problem installing GWT eclipse plugin using the update site :

http://dl.google.com/eclipse/plugin/3.6

using this update url seems to raise an error:

Unable to Read repository at http://dl.google.com/eclipse/plugin/3.6/content.xml.
Connection reset

A workaround that works for me is to replace gwt eclipse update site with:

https://dl-ssl.google.com/eclipse/plugin/3.6

I have eclipse Helios installed in a opensuse 10.3 box. it seems the eclipse editor keeps crashing eclipse application every time i type a dot ‘.’ to access object methods.
if you experience same problem you can try the following two fixes:

• if you don’t have xulrunner package then install it (example using Yast2 in opensuse).
  make sure you only install latest xulrunner version. if you install two different xulrunner versions in your linux OS the two versions might conflict and cause eclipse to crash again. this was my problem. when i removed old xulrunner 191 and only kept xulrunner 192 then eclipse helios stops crashing and works well.
• The second fix (that doesn’t require to install xulrunner but seamonkey) is to specify to the Java VM the location of xulrunner .
  To do this :
  1-Edit file : ~/eclipse/eclipse.ini
  2- add the following text below the ‘-vmargs’ line :
  

  -Dorg.eclipse.swt.browser.XULRunnerPath=/usr/lib/seamonkey 

  
  For further information on this second fix see this thread discussion.

mod_pagespeed is a New Google Tool which is supposed to Make Websites Twice as Fast.
Further Reading :

• New Google Tool Makes Websites Twice as Fast
• Google Soups Up Apache With New Speed Module

After Sun Inc had been acquired by Oracle ; and because of some clashes between Sun’s open source projects communities and the -somewhat unfriendly- Oracle attitude towards Sun’s open source projects; OpenOffice has been forked to LibreOffice. This Effort is being Led by document foundation probably with joint efforts to come from major Linux companies Like Novel ,Ubuntu and RedHat .

For Java OpenOffice API developers , the move to Libreoffice should be straightforward. just follow these simple steps:
1- Get netbeans IDE 6.8 and then install plugin “OpenOffice API Plugin” from netbeans IDE plugins dialog.
2- Downlaod and Install Libreoffice and Libreoffice SDK.
3-In Netbeans IDE select “Tools->Options->Miscellaneous”. select Tab “OOo API Plugin”. then in fields “Openoffice.org installation” and “Openoffice.org SDK installation” browse to the folder where you installed Libreoffice and libreoffice SDK respectively as described in image below:

That’s it ! you can now start doing Java Libreoffice API development using the netbeans OpenOffice API plugin.

---

• Browse this blog’s OpenOffice API Posts.

The collapse of Sun Inc. , steward of Java technology, was a saddening and frightening event. After Oracle bought Sun and addressed java community with their optimistic plans for advancing Java; most community looked forward for happier times. they hoped that java developers lives would return to normal after the trauma of Sun collapse. they hoped that once again Java development would make sense in the familiar pre-Oracle terms of openness, community participation and freedom. These hopes were in vain. The Break of Sun, dismantling of multiple open source java/Sun based projects and the patent war that waged between giant software building competitors had mangled too many things beyond repair. Java Development would no longer fit neatly into the old molds.
Great numbers of us feel themselves increasingly adrift in a strange , uncertain and uncontrollable world. even the father of Java has expressed these same feelings in very similar words : Quite the firestorm!. No doubt Java is living now in an age of anxiety, an age of continual crisis.

In fact i used Java as an example to express a wider and broader sentiment of the return of the so called Age of Anxiety. In almost every area of human experience today , people are searching for ways to put meaning back into life. am i the only one who have this sentiment? or is it a realistic fact?
I hate to be pessimistic but that’s how i see the world today ;and i hope deeply I’m wrong.

SugarCRM provides Web Services API via the NuSOAP PHP implementation of the SOAP protocol. The SugarSoap API are built using the NuSOAP library and included in the Sugar Community Edition, Sugar Professional Edition and Sugar Enterprise Edition.
This guide leads you through the steps of creating sugarsoap clients stubs In java using Xfire .Codehaus XFire is a next-generation java SOAP framework. We will use it to consume the SugarSoap webservice in Java clients.

1- Locate The SugarSoap WSDL file:

This guide suppose you already have a working sugarcrm installation. If you don’t have one, download and install the free Sugar Community Edition . Refer to section Installing and Upgrading Sugar to guide you through the installation procedure.
For example, In my Linux machine I unpacked the Sugar Community Edition 5.5.0 bundle into my apache server web apps directory ‘/srv/www/htdocs/SugarCE-Full-5.5.0′ . After completing the installation, I access my local sugarcrm application by browsing to URL : http://localhost/SugarCE-Full-5.5.0/. This URL could vary depending on your own choices of server, host and port. For the rest of this guide I’ll use the reference $sugar_base_url to refer to the base URL you use to access your sugarcrm installation (for me, $sugar_base_url =http://localhost/SugarCE-Full-5.5.0/ ).

The SugarSoap WSDL (Web Services Description Language) is located at:
$sugar_base_url/soap.php?wsdl

in my case it’s located at http://localhost/SugarCE-Full-5.5.0/soap.php?wsdl . Mark well this sugarsoap WSDL URL because we will need it for generating the sugarsoap clients stubs.

2- Getting XFire and other libraries:

To use Xfire we need the necessary library files. Go to xfire web site download page and download the file xfire-distribution-x.x.x.zip ( replace ‘x.x.x’ by the version number .the latest xfire version is xfire-distribution-1.2.6.zip at the time of writing this guide).
unzip it in a local folder. add the xfire-all-1.2.6.jar file from the distribution and its lib directory into your project classpath.
If you are using eclipse IDE, you can get the Xfire Eclipse plugin which is a nice and easy to use tool for generating Xfire clients stubs from WSDL files.

3.Generating SugarSoap Clients stubs with Xfire:

Ant is a useful and flexible tool to automate the building of your java project. Most java IDE generates a build.xml file for you , so why not use Ant to generate our sugarsoap clients stubs?

Edit your build .xml file and add the following ant target at the end of the file :

<target name="wsGen">

        <!-- Replace ${basedir} by your project base directory  and ${sugar_base_url} by your sugar URL (ex : http://localhost/SugarCE-Full-5.5.0-->

        <property name="dependencyfinder.home" value="${basedir}"/>
        <path id="dependencyfinder">
            <pathelement location="${basedir}/lib"/>
            <fileset dir="${basedir}/lib">
                <include name="**/*.jar"/>
            </fileset>
        </path>

        <taskdef name="wsgen">
                 classname="org.codehaus.xfire.gen.WsGenTask"
                 classpathref="dependencyfinder"/>

        <wsgen overwrite="true"
               package="com.sun.star.addon.sugarcrm.sugarsoap"
               outputDirectory="${basedir}/src"
               wsdl="${sugar_base_url}/soap.php?wsdl"
               />
    </target>

${basedir}/lib points to the directory where you copied all your xfire distribution jar files and xfire distribution lib folder jars.

From your command line change to your build.xml file directory and run command :

$ ant wsGen

this will generate the SugarSoap clients stubs under src directory in java package : com.sun.star.addon.sugarcrm.sugarsoap
package com.sun.star.addon.sugarcrm.sugarsoap holds the main sugarsoap java stubs classes mainly the class Sugarsoap

4.Writing a SugarSoap Java client:

Now it’s time to write a simple java client to test our sugarsoap service. Below is a java code snippet that demonstrates how to login to your sugarcrm web application :

import java.net.MalformedURLException;
import java.net.URL;
import javax.xml.rpc.ServiceException;
import com.sun.star.addon.sugarcrm.sugarsoap.Sugarsoap;
import com.sun.star.addon.sugarcrm.sugarsoap.SugarsoapLocator;
import com.sun.star.addon.sugarcrm.sugarsoap.SugarsoapPortType;

public class SugarTest {

	Sugarsoap service = new SugarsoapLocator();
	SugarsoapPortType soap = null;
	public static void main(String[] arg) {

		try {
			soap = service.getsugarsoapPort(new URL("http://localhost/SugarCE-Full-5.5.0/"));
			String session = soap.login("your username", "your password",
					" sugarsoap test");
			if (session == null)
				System.err
						.println("there was an error connecting to sugarcrm service");
			else
				System.out
						.println("login to sugar service successfull. sessionId="
								+ session);

		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			_logger.error(e);
			return;

		} catch (ServiceException e) {
			// TODO Auto-generated catch block
			_logger.error(e);
			return;

		}

	}

	/**
	 * Logs the user into the Sugar application.
	 *
	 * @param username
	 * @param password
	 * @param application
	 * @return sugar session id
	 */
	String login(String username, String password, String application) {

		Set_entry_result loginRes = null;
		String session = null;

		try {

			_logger.info("connecting to " + this.sugarURL + " as " + username);
			User_auth user_auth = new User_auth(username,
					MD5.getHashString(password), "1");
			loginRes = this.soap.login(user_auth, application);

			if (loginRes == null) {
				// null result means something wrong went with authentication
				return null;
			}
			session = loginRes.getId();
			String userid = this.soap.get_user_id(session.getId());
			boolean error = (!loginRes.getError().getNumber().equals("0"));

			if (error) {

				if (userid == "-1") {
					String text = "Error connecting to "
							+ this.sugarURL
							+ ": Connection is available, but SOAP is not responsive due to PHP configuration.";
					_logger.error("Error initializing connection:" + text);

					return null;

				}

				_logger.error("sugar login error :"
						+ loginRes.getError().getNumber() + " "
						+ loginRes.getError().getName() + " "
						+ loginRes.getError().getDescription());
				return null;

			} else {
				// sugar login successful
				_logger.info("login to sugar application successful");

			}

		} catch (Exception e) {

			// Caught an unexpected exception!
			_logger.error(e.getMessage(), e);
			return null;

		}
		return session;
	}

}

this snippet simply create a service instance and use it to create a soap Object instance. soap Object is the entry class for all sugarsoap methods.
The login() method snippet describe how to connect to your sugarcrm instance and returns the sugar session id if login is successfull.Note that you need to encode your sugar password using the MD5 algorithm.

5.Conclusion:

Once you complete the previous steps in setting up sugarsoap java stubs clients with xfire, you can start exploring and using the power of the sugarcrm services by calling the various sugarsoap API methods .
xfire is not the only java webservice library to generate sugarsoap client. you can also use other java webservice tools like axis and CXF and others. in a comming post I’ll describe a simple method to generate sugarsoap client using eclipse IDE and axis2.
The supported calls in the official sugarsoap API are listed and described in this section of the Sugar Developer Guide: Web Services