Welcome to the future, everyone. Just let it sink in a little…

United States – Percentage of Population on Facebook in 2009

Tables are essentially just spreadsheets in their presentation. But in function they are actually more like SQL tables that you interact with via an API. You can store your own data on here and interact with it–read: you really don’t need a local SQL installation on your web server to create powerful web apps. Perhaps the most interesting thing of all is that there are also public tables, many of which include valuable socially and politically relevant data.

From within the Google Fusion tables account, you can also generate on-the-fly interactive charts, graphs and maps.

There are a couple methods for this actually. One modification collapses subpanels by default, stores which ones are expanded during a user’s session, and then resets them to collapsed on the next login. The other method, and the one I prefer, is to collapse all subpanels by default, but also keep expanded subpanels open on the next login. I think most users will prefer the latter option, but I encourage you to experiment and share your feedback below. (These snipits come from this SugarCRM’s wiki post.)

To have all sub-panels collapsed by default

With the following code, all sub-panels are collpased by default. Sub-panels that have been opened by the user will stay open through the session, but once the user logs out, all sub-panels will be collapsed on their next login.

Edit config_override.php (if it doesn’t exist, create it in Sugar’s root directory) to include the following code:

// Always hide subpanels when a user views a detail record
$sugar_config['hide_subpanels'] = true;

//When a user first visits a detail view hide all subpanels for a module. Then whatever subpanels are opened in that module stay open throughout the session regardless of what the record id is.
$sugar_config['hide_subpanels_on_login'] = true;

To have all sub-panels collapsed by default except the user’s chosen sub-panels

With the following code, all sub-panels are collapsed by default on initial login. Sub-panels that have been opened by the user will stay open through the session, and will be automatically expanded every time the user logs in.

Note: This change is not upgrade safe, and may need to be repeated after patching or upgrading an instance.

Edit the include/Subpanel/SubPanelTiles.php file. Locate the following code:

    $tabs = array();
    $default_div_display = 'inline';
    if(!empty($sugar_config['hide_subpanels_on_login'])){
    if(!isset($_SESSION['visited_details'][$this->focus->module_dir])){
    setcookie($this->focus->module_dir . '_divs', '' );
    unset($_COOKIE[$this->focus->module_dir . '_divs']);
    $_SESSION['visited_details'][$this->focus->module_dir] = true;

    }
    $default_div_display = 'none';
    }
    $div_cookies = get_sub_cookies($this->focus->module_dir . '_divs');

Replace the above with the following code:

    $tabs = array();
    $default_div_display = 'inline';
    if(!empty($sugar_config['hide_subpanels_on_login'])){
    if(!isset($_SESSION['visited_details'][$this->focus->module_dir])){
    setcookie($this->focus->module_dir . '_divs', '' );
    unset($_COOKIE[$this->focus->module_dir . '_divs']);
    $_SESSION['visited_details'][$this->focus->module_dir] = true;

    }
    $default_div_display = 'none';
    }

    //Have the subpanel choices saved between sessions
    //If 'hide_subpanels_session_only' is set to 'true' then the old functionality is retained
    if(empty($sugar_config['hide_subpanels_session_only'])){
    $up_cookies=$current_user->getPreference('subpanel_cookie_'.$this->focus->module_dir);
    }
    $div_cookies = get_sub_cookies($this->focus->module_dir . '_divs');
    if(!empty($up_cookies)) {
    if(empty($div_cookies)) {
    $div_cookies=$up_cookies; //If there are no cookies, then use the UserPrefs copy of the previous cookie
    }
    }
    if(empty($sugar_config['hide_subpanels_session_only'])){
    //Save a copy of the cookie to the UserPrefs so that any new choices get saved
    $current_user->setPreference('subpanel_cookie_'.$this->focus->module_dir, $div_cookies, 0, 'global', $current_user);
    }

As it turns out, she’s yet to figure out how to disable the automatic posting of Tweets and other such “Connected Sites,” which seems to have the default setting of integrating everything. Well, Nadia, this one’s for you and everyone else out there who would rather read instructions than click around and break stuff. (Webbies around the world salute you.)

Removing integration for Google Buzz’s “Connected Sites” feature/annoyance is easy. Just follow these steps:

1. While logged into your GMail, click on Buzz.
2. At the top of the page, you’ll see your personal Buzz area–the place where you would type a post. Click on Connected Sites near your name. A tasteful lightbox window pops up.
3. Click on Edit and then Remove Site on any and all of the Connected Sites you want to remove.
4. Click Save at the bottom.

That’s all there is to it! Happy buzzing, Nadia.

Oh, and do visit her blog at postmatterpostings.wordpress.com because it’s pretty awesome.

]]> http://systemsconsciousness.com/2010/03/03/want-google-buzz-to-buzz-off-heres-how-to-disable-connected-sites-in-google-buzz/feed/ 0 http://systemsconsciousness.com/2009/11/24/sugarcrm-soap-examples-pt-3-upload-a-file-via-soap-api/ http://systemsconsciousness.com/2009/11/24/sugarcrm-soap-examples-pt-3-upload-a-file-via-soap-api/#comments Tue, 24 Nov 2009 19:56:53 +0000 Dean Haddock http://systemsconsciousness.com/?p=1055 This is my third tutorial on the SugarCRM SOAP API. It’s slightly more advanced than the last two, so if you are new to the SOAP API, you should probably start with this one. If you are looking for more tutorials on SugarCRM SOAP API, (as always) LornaJane’s blog is a great intro, and the Sugar Developer Forum is tops. Enough plugs. Let’s get started! (And if you find the post useful, please visit one of my sponsors!)

Today I’m going to write about sending a file attachment to SugarCRM via the SOAP API. The setup, as in previous posts, is a LAMP web server running our main web site on WordPress–and the cForms plugin to process form input data. You don’t need cForms, but it’s a great plugin that will help you manage multiple types of forms on your WordPress site. It also has its own API, which allows you to run PHP code when a form is submitted. If you’re not using WordPress or cForms, that’s ok, too.

I’m going to skew the code for the non-WordPress users. But it will be almost identical if you are using WordPress/cForms. You’ll just need to substitute in the cForms variables. For easy setup, create a simple POST form with text fields of my_form_firstname and my_form_lastname, and with a file field.

We’re going to send a document through the web form on our web server to a Sugar server (which is also a web server, but you get the idea).

To begin, we’ll need to initialize our SOAP connection. This means connect to the Sugar server from our web server with our IP, username and password. The code (again) looks like this:

$location = ‘http://YOUR.SUGARSERVER.WEB.ADDRESS/yoursugarcrmdirectory/soap.php’;

// set up options array with SugarCRM location, etc
$options = array(
“location” => $location,
“uri” => ‘http://www.sugarcrm.com/sugarcrm’,
“trace” => 1
);

// user authentication array
$user_auth = array(
“user_name” => ‘YOUR_USERID’,
“password” => MD5(‘YOUR_PASSWORD’),
“version” => ‘.01′
);

// connect to soap server
$client = new SoapClient(NULL, $options);

// Login to SugarCRM
$response = $client->login($user_auth,’SOME_KEY’);

$session_id = $response->id;

$user_id = $client->get_user_id($session_id);

print_r($response);

The last line can be commented out. It’s just there to indicate to you that your connection was successful. If it wasn’t successful, make sure:

• Your username and password are correct.
• The URL for your Sugar server is correct.
• Your user has access to write to the Contacts and Notes modules.
• Your firewall has a web port open.

If it worked, great! Let’s move on to the next step. (If not, hit up Google!) Let’s add data to a module. In this case, we’re going to use the Contacts module because it already has a built-in many-to-many relationship to the Notes module, where our attachment will ultimately reside–linked to our Contact! Here’s the code to write some data to the Contacts module:

$response = $client->set_entry($session_id, ‘Contacts’, array(
array(“name” => ‘first_name’,”value” => $_POST['my_form_firstname']),
array(“name” => ‘last_name’,”value” => $_POST['my_form_lastname']),
array(“name” => ‘assigned_user_id’,”value” => $user_id)
));

Simple enough. When you run this code, combined with the code above, you should find a new contact in your Contacts module. If you get in trouble, var_dump() and print_r() will be your best friends. Our next step will be to grab the uploaded document and insert it into the Notes module:

$insert_contact_id = $response->id;

// create the note
$response = $client->set_entry($session_id, ‘Notes’, array(
array(‘name’=>’name’,'value’=>$_POST['my_form_firstname'].’ ‘.$_POST['my_form_lastname'].’ Document’),
array(‘name’=>’description’,'value’=>’An attachment for ‘.$_POST['my_form_firstname'].’ ‘.$_POST['my_form_lastname']),
array(‘name’=>’parent_type’,'value’=>’Contacts’),
array(‘name’=>’parent_id’,'value’=>$insert_contact_id)
));

$note_id = $response->id;

Note the first and last lines. Every time you issue a $response call, that is, when you reference your SoapClient class, you get a new $response->id. This way you can interact with SOAP at different stages in your application. In this instance, first we wrote a new Contact to Sugar, then we’re getting the $response->id of this call to create and attach a Note to the Contact. This occurs in this little bit above:

array(‘name’=>’parent_type’,'value’=>’Contacts’),
array(‘name’=>’parent_id’,'value’=>$insert_contact_id)

Then, likewise, we get the $note_id, which is the $response->id for the Note attachment.

What we’ve yet to do at this point is get our file from our form and upload it as an attachment to the Notes record that we just created. If you’re not familiar with uploading documents via PHP and forms, then you’ll want to brush up on that. If you’re using cForms especially this will be very helpful because cForms requires you to be a little bit more strict with how you work with files than, say, if you’re just working with your own ground-up app. What I mean is–you need to know what the difference is between tmp_name, name and so forth.

Here we go… we’re going to get the target path of the file, open it to get its content, and then close it:

// get the path from of your file
$target_path = $_FILES['my_form_file']['tmp_name'][0];

// Un-comment this code to see if the file exists
//if (file_exists($target_path)) {
//echo “The file “.$_FILES['my_form_file']['name'][0].” exists”;
//} else {
//echo “The file “.$_FILES['my_form_file']['name'][0].” does NOT exist”;
//}$fp = fopen($target_path, ‘rb’);
$file = base64_encode(fread($fp, filesize($target_path)));
fclose($fp);

Our final step is going to be to attach (and relate) the file to the new record in the Notes module. See what we’re doing? Creating a Contact, relating a Note to it, and relating an attachment to that Note. Exciting! This code is simple. If you are convinced the above is working, proceed by adding this:

//create the attachment that you will put into sugar
$attachment=array(
‘id’=>$note_id,
‘filename’=>$_FILES['my_form_file']['name'][0],
‘file’=>$file
);

$response = $client->set_note_attachment($session_id,$attachment);

By now you should be getting the hang of it. We’re creating an attachment just like we created the other two records. The $note_id variable will tell the attachment record which Note to relate to. The Note, remember, is already attached to our Contact. Then we’re using the set_note_attachment() function to put the attachment on the server.

That’s all there is to it!

Just as in any other module, we have at least one date field. In this case, an “Expected Start Date” field for various fee-for-service inquiries is the culprit. Our original insert code for this field looked like this:

array(“name” => ‘expected_start_date_c’,”value” => $POSTdataClean['cf2_field_18']),

This didn’t work though because the date that’s coming in from cForms is of the format MM/DD/YYYY. What Sugar expects though is, “YYYY-MM-DD H:M:S.” So if you are going to insert a date into Sugar via the SOAP API, and you want it to work, you will want to use the following code:

array(“name” => ’start_date_c’,”value” => date(‘Y-m-d H:i:s’, strtotime($POSTdataClean['cf2_field_18']))),

If you’re looking for a deeper explanation, check out the PHP manual for strtotime and date.

After manually entering all of my contacts (and taking a few minutes to delete a few), I began playing around with the calendar. I loved its sleek and shiny Apple appeal. It’s really quite easy to use. But one thing was missing: the ability to sync with Google Calendar. (I’ve taken to GCal after using it at my day job–I was raised on Exchange, but the IT manager before me implemented Google Mail, and there really hasn’t been a reason to change. I haven’t looked back, to be honest.) But for eight months I lamented my purchase for this one fatal flaw, despite the fact that it mostly surpassed all of my other needs and expectations.

I’m happy to report now that with the new 3.0 iPhone OS, syncing with Google Calendar–even multiple calendars–is so very easy. You will not have to sync your contacts with Google, nor will you run the risk of deleting important information. You just set it up and it works. It takes about three minutes.

Visit this link and follow the instructions: http://justanotheriphoneblog.com/wordpress/general/google-calendar-speaks-caldav-to-the-iphone

Thanks to Just Another iPhone Blog for this post.

1. In the modules folder of your SugarCRM install directory, find the folder for the module that is giving you the problem.

2. Open the metadata folder, and then open the file “dashletviewdefs.php”.

3. On the second line of the file you should see something like $dashletData['xxx_SomeModule']['searchFields'] = array ( where xxx_SomeModule is the SugarCRM name for your new module. This is probably what is causing your error. If this xxx_SomeModule is not the same as the module name giving you the error, change it to the correct SugarCRM name for the module. For example, change it to read xxx_TheRightModuleDashlet. You have to add Dashlet to the end, as well.

4. Do a find/replace on the file to change any of the variable names that read xxx_SomeModule to xxx_TheRightModuleDashlet.

5. Remove and re-add the dashlet to your home page in SugarCRM.

If you’re new to the SugarCRM Community Edition, then you may have noticed that there is very little support built in for reporting. While the CE version is incredibly full in terms of features, it does lack some of the expanded functionality provided by paid version of the software. Have a look at this chart, if you haven’t already. You’ll notice that most of the features you get when you upgrade to a paid version of SugarCRM relate to reporting. This is because a CRM system is great if it simply prevents you from passing around Excel files and Access or FileMaker databases, but it’s almost useless if it still doesn’t give you a high-level view of your data. The goal of this article is to provide some entry-level examples of querying your data so that ultimately you can create your own reports, save thousands of dollars for your project and impress your friends. If you like what you see, and you want to see more, please consider visiting one of our sponsors. Each click makes us a few cents.

Getting Started

First, you’ll need to create your PHP document and add the components mentioned previously to connect to your database via the SOAP API. Again, you’ll find this explained in detail here. In the previous example I integrated my custom PHP with WordPress’ cForms plug in. This time I’m going to forgo the extra step of integration and focus on the queries themselves. So, after you’ve created your PHP document, you should put it somewhere like the htdocs\sugarcrm\custom on your SugarCRM server. Of course, you don’t have to do this. Since you’re connecting via SOAP, you can keep this file on any web server. For reporting purposes though you may want to keep it on your SugarCRM server so that you can link to it and access it easily from within Sugar.

Second, you’ll need to get familiar with the Google Charts API. This API is one of the most amazing utilities to come out of Google. If this is the first time you’ve encountered the API, you’ll want to take a minute to look over the documentation here. Google Charts works by passing in a URL with certain GET variables for the image SRC declaration in your HTML tag. Got it? Good.

The Bad News First

Let me get it out of the way and say that Sugar’s SOAP API is weak. They are purported to have enhanced this functionality in the upcoming version 5.5, which is currently in its beta release. I’ve already mentioned in my previous post that the documentation for such is lacking, too. It’s highly problematic when a blogger such as myself is an authority on something I had no part in writing–I’ve just brute-forced my way into it. So the approaches I am taking now to achieve the level of functionality I need with Sugar are substandard, but I’m hoping that their promises of a better API in version 5.5 will indeed be upheld.

Yann Tiersen on the headphones. Let’s get down to business. If you haven’t seen LornaJane’s PHPDocumentor dump, go ahead and check that out here. It will at least tell you the components that make up the many SugarCRM SOAP calls. But not much more than that. Speaking of time, though, you’ll need to add the following two lines of code to the top of your php page so that your queries don’t eat up all the memory and your page doesn’t time out while loading.

ini_set(“memory_limit”,”80M”);  // fix for soap
set_time_limit(120);  // another fix

The get_entries_count() Call

The get_entries_count() call (thanks Joe!) is a simply query that just counts the number of records specified and returns that integer. This is a very useful query because SugarCRM’s SOAP API is really slow when used to return actual records lists. If you’re just building a report, then you’re probably mostly interested in record counts anyway. This query will run in less than half the time of the get_entry_list() call, which I explain in more detail below.

Let’s start by creating a simple query. Let’s query the Opportunities table and find out how many new records were created in April of 2009. You’ll need LornaJane’s documentation and a little experience with SQL.

$startdate=”2009-04-01″;
$enddate=”2009-04-30″;
$month_response = $client->get_entries_count($session_id,’Opportunities’, ‘date_entered between “‘.$startdate.’” and “‘.$enddate.’”‘, FALSE);
$month_num = $month_response->result_count;

print $month_num;

It’s pretty easy to see what’s happening here. The get_entries_count() function requires the Session ID, declared in your authentication statement, as well as the table you’re querying. Then there’s the SQL query WHERE statement. You’ll inevitably find it annoying that only the WHERE statement goes into the function. This removes a ton of functionality and makes it difficult to retrieve data efficiently. SQL has a COUNT parameter, for instance, and if I could specify more of the SQL text then there wouldn’t be the need for this get_entries_count() function at all. The “FALSE” statement at the end tells Sugar not to include deleted records. If no records were entered in the Opportunities table in April, then this will output 0. Otherwise you should see an integer.

Now let’s make it fun. Say you had several different sales stages specified in your Opportunities table. In our company’s Sugar implementation, we have five sales stages: Active, Dormant, Closed, Closed Won, and Closed Lost. Let’s say that we want to make a pie chart of this using the Google Charts API. We’ll need to make several different calls to count the different sales stages, then we’ll need to perform some basic mathematical operations to get some percentages.

// get data for the OUTCOME pie chart
$active_response = $client->get_entries_count($session_id,’Opportunities’, ’sales_stage like “Active”‘, FALSE);
$active_num = $active_response->result_count;
$dormant_response = $client->get_entries_count($session_id,’Opportunities’, ’sales_stage like “Dormant”‘, FALSE);
$dormant_num = $dormant_response->result_count;
$closed_response = $client->get_entries_count($session_id,’Opportunities’, ’sales_stage like “Closed”‘, FALSE);
$closed_num = $closed_response->result_count;
$closedwon_response = $client->get_entries_count($session_id,’Opportunities’, ’sales_stage like “Closed Won”‘, FALSE);
$closedwon_num = $closedwon_response->result_count;
$closedlost_response = $client->get_entries_count($session_id,’Opportunities’, ’sales_stage like “Closed Lost”‘, FALSE);
$closedlost_num = $closedlost_response->result_count;

// do some math
$active_percent=round($active_num/$total_num*100);
$dormant_percent=round($dormant_num/$total_num*100);
$closed_percent=round($closed_num/$total_num*100);
$closedwon_percent=round($closedwon_num/$total_num*100);
$closedlost_percent=round($closedlost_num/$total_num*100);

The first thing you should notice is that this is highly inefficient. In normal SQL land we would have used the COUNT and GROUP BY calls to get this information in a few lines. There should be a better way to do this, and I’m convinced there is–I just haven’t been able to find it yet because Sugar’s documentation and API are just so thin. Imagine, for instance, if I wanted to return the total number of Opportunities for each country. It would take hours to list all of the necessary queries to do that, and it would take minutes to run.

Now, to display this data in a pretty Google Chart, just add the following bits.

print ‘<img src=”http://chart.apis.google.com/chart?chs=325×165&chts=333333,12&chco=5DA4A4,cccccc,666666,65C665,C36464&chtt=’.$total_num.’ Opportunities as of ‘.$today.’|&chd=t:’.$active_percent.’,’.$dormant_percent.’,’.$closed_percent.’,’.$closedwon_percent.’,’.$closedlost_percent.’&cht=p&amp;chl=Active ‘.$active_num.’ (‘.$active_percent.’%)|Dormant ‘.$dormant_num.’ (‘.$dormant_percent.’%)|Closed ‘.$closed_num.’ (‘.$closed_percent.’%)|Won ‘.$closedwon_num.’ (‘.$closedwon_percent.’%)|Lost ‘.$closedlost_num.’ (‘.$closedlost_percent.’%)” alt=”Opportunity Outcomes” />’;

You should see this, but with your own numbers, of course:

The best example I have found is here: http://www.lornajane.net/posts/2008/SugarCRM-SOAP-API-Examples. LornaJane’s examples were an excellent start, and I thought I’d go ahead and provide you some more details. The upside of these examples is that you won’t need to install nusoap in order for them to work. If you like what you see, and you want to see more, please consider visiting one of our sponsors. Each click makes us a few cents.

Setup: LAMP web server running the latest version of WordPress with tons of plugins and customization. I also use cForms. It’s not important that you are using WordPress or that you have cForms installed. I just happen to like cForms, and I think it’s a fun challenge to integrate all these different systems. If you do use WP and cForms, just follow the instructions in the cForms documentation for customizing my-functions.php in your plugins/cforms-custom directory. The only real difference will be that you will use $POSTdata['varname'] instead of the regular $_POST['varname']. You’ll also need to use stripslashes() and pay attention to the variable names that cForms passes. I won’t be going into the specific details of cForms-to-SugarCRM here, but you should be able to infer how to implement that from this explanation.

This example uses a simple web form POST calling a PHP document as an action. For simplicity, let’s assume you have a web form with the following fields: first_name, last_name, email_address, phone_number and message.

When you submit the form, it calls “form-action.php”. You will implement the examples here in this PHP file.

Getting Started

To get started, let’s just get a basic example going. Copy and paste the following code in your form-action.php document. If you want to look at the SugarCRM documentation for these SOAP calls, go here: http://sugarcrm.openapp.org/2006/04/24/using-sugarcrm-soap/ Part of the reason I’m writing this post is because they don’t provide any examples for these calls. Once you get the hang of it though, that link will be quite helpful to you.

<?php

// set up options array
$options = array(
“location” => ‘http://your.website.here/sugarcrm/soap.php’,
“uri” => ‘http://www.sugarcrm.com/sugarcrm’,
“trace” => 1
);

//user authentication array
$user_auth = array(
“user_name” => ‘YOUR_SUGAR_USERNAME’,
“password” => MD5(‘YOUR_SUGAR_PASSWORD’),
“version” => ‘.01′
);

// connect to soap server
$client = new SoapClient(NULL, $options);

// Login to SugarCRM
$response = $client->login($user_auth,’test’);

$session_id = $response->id;

// look what modules sugar exposes
$response = $client->get_available_modules($session_id);

// look in more detail at the fields in a module
//$response = $client->get_module_fields($session_id, ‘Accounts’);

var_dump($response);

?>

So what’s going on here? Your options array is storing some variables that you’ll use a few lines later in the SoapClient call. The options array is where you specify the connection parameters to the server that has your SugarCRM installation. Naturally, you’ll want to make sure you enable port 80 access through your router/firewall because that’s the default port for HTTP and also SOAP. The next array of interest is $user_auth, which is where you specify your user name, password and SOAP version. After that you pass the connection options into the SoapClient() call and then log in via the login() call. The ‘test’ parameter is a required application name, which can be most anything you want to call it. Once you pass the authentication, the $session_id variable grabs the session id for your current SOAP connection. You’ll need this with most, if not all, calls that you make from this point forward.

The next few lines of code are the fun part. The “$response = $client->get_available_modules($session_id);” line is grabbing all of the modules in your SugarCRM installation. This is very useful, for instance, when you want to know if the particular module you are attempting to write to is exposed. It’s also helpful when you’re trying to debug your SOAP calls and you’ve used the wrong module name, and so on. Below that is another example call that, if you uncomment the line, will return all of the fields that are exposed in a specific module, in this example–Accounts. Finally, var_dump($response) echos out whatever your $response variable has collected above.

Play around with it and get a feel for how it works. Notice that any custom modules you create show up in the list of available modules. Notice also that some modules, like Users, don’t return any available fields at all.

Inserting a Record

Now that you’ve made your first SOAP call to SugarCRM, you’ll want to try to insert a record or two into a module. This, like the previous example, is pretty simple and straight forward, but there are a few quirks like anything else in SugarCRM.

Let’s take the previous example to the next level. Under your $session_id variable declaration, add this line: “$user_id = $client->get_user_id($session_id);” You’ll need this eventually to assign a given record to a user. In this case we’re going to use the authenticated user’s id. Now the fun part! Remove or comment out the get_available_modules and get_module_fields lines and replace them with this:

$response = $client->set_entry($session_id, ‘Leads’, array(
array(“name” => ‘first_name’,”value” => $_POST['first_name']),
array(“name” => ‘last_name’,”value” => $_POST['last_name']),
array(“name” => ‘email1′,”value” => $_POST['email_address']),
array(“name” => ‘work_phone’,”value” => $_POST['phone_number']),
array(“name” => ‘description’,”value” => $_POST['message']),
array(“name” => ‘assigned_user_id’,”value” => $user_id)
));

Here, we’re inserting the data passed from our form into the Leads module in SugarCRM. One thing you may notice instantly is that some of the variable names for the SugarCRM module have different names than the POSTed variables from our form. The email address, for instance, gets inserted into the email1 field for SugarCRM. This is because SugarCRM has its own way of dealing with multiple (primary, secondary, etc.) email addresses. The $_POST['message'] variable is being inserted into the description field in the Leads module for simplicity because SugarCRM includes a description field in this module by default. The last line inserts the authenticated user’s id into the record and associates your new Lead with this user. This can be really helpful, say, if you have a team of people using SugarCRM to correspond with clients, and each person deals with a different type of incomming Lead. Your form-action.php file should now look something like this:

<?php

// set up options array
$options = array(
“location” => ‘http://your.website.here/sugarcrm/soap.php’,
“uri” => ‘http://www.sugarcrm.com/sugarcrm’,
“trace” => 1
);

//user authentication array
$user_auth = array(
“user_name” => ‘YOUR_SUGAR_USERNAME’,
“password” => MD5(‘YOUR_SUGAR_PASSWORD’),
“version” => ‘.01′
);

// connect to soap server
$client = new SoapClient(NULL, $options);

// Login to SugarCRM
$response = $client->login($user_auth,’test’);

$session_id = $response->id;
$user_id = $client->get_user_id($session_id);

// write our form data to the Leads module
$response = $client->set_entry($session_id, ‘Leads’, array(
array(“name” => ‘first_name’,”value” => $_POST['first_name']),
array(“name” => ‘last_name’,”value” => $_POST['last_name']),
array(“name” => ‘email1′,”value” => $_POST['email_address']),
array(“name” => ‘work_phone’,”value” => $_POST['phone_number']),
array(“name” => ‘description’,”value” => $_POST['message']),
array(“name” => ‘assigned_user_id’,”value” => $user_id)
));

var_dump($response);

?>

When you execute this code, you get something that looks like this:

object(stdClass)#61 (2) { ["id"]=> string(36) “7e084ce3-8ccb-1a73-4e82-49df645ff06a” ["error"]=> object(stdClass)#58 (3) { ["number"]=> string(1) “0″ ["name"]=> string(8) “No Error” ["description"]=> string(8) “No Error” } }

Believe it or not, this means it worked. More evidence that it worked will be when the record pops up in your SugarCRM Leads module and you scream eureka and everyone in your office turns around to stare at you. When you’re ready to publish your form to a live website, just comment out the var_dump line and add something like, echo “Your form worked, and I’m awesome.”;.

Relating Two Records in Different Modules

This example was a little tricky to figure out, but ultimately it’s pretty simple. You will inevitably need to relate a record with another record, say, for example, if you’re using the ITHelpDesk module created by the good folks at StoryCorps. You could easily create a web form for your users to enter a support request on your company’s intranet site and have it go straight into the ITHelpDesk module. You’d just need to backtrack through these examples a bit to get the right module and field names, and then tweak the examples provided herein to write the appropriate data to the appropriate places. Then you could append the following bit of code to associate, say, the Support record with the Inventory record as its entered into SugarCRM.

But for simplicity sake, we’re just going to create an Account record and a Contact record and relate them instead of creating a Lead. Start by adding another field to your form, called organization_name. Then refer back to the previous example and edit the Leads insert example to insert into the Contacts table instead. Copy and paste the Contacts $response insert lines and modify it to add a record to the Accounts table. For this part, just add the organization_name variable to the Accounts module, which is stored as the “name” field in SugarCRM. If you stop at this point, you’ll just have a new account and a new contact in SugarCRM, but they won’t be related. They also won’t be related if you just put the organization_name in as the associated account in your Contacts $response insert. Don’t waste your juice trying to do this. Instead, you’ll need this little bit of code, which you’ll insert after your two $response inserts:

$relationship = array(
‘module1′ => ‘Contacts’,
‘module1_id’ => “$contact_id”,
‘module2′ => ‘Accounts’,
‘module2_id’ => “$account_id”,
);

// call set_relationship()
$response = $client->set_relationship($session_id, $relationship);

Pretty simple, right? This won’t work without the $contact_id and $account_id variables though, so you’ll need to call $contact_id = $response->id and $account_id = $response->id after each of your $response inserts. The final result will look something like this:

<?php

// set up options array
$options = array(
“location” => ‘http://your.website.here/sugarcrm/soap.php’,
“uri” => ‘http://www.sugarcrm.com/sugarcrm’,
“trace” => 1
);

//user authentication array
$user_auth = array(
“user_name” => ‘YOUR_SUGAR_USERNAME’,
“password” => MD5(‘YOUR_SUGAR_PASSWORD’),
“version” => ‘.01′
);

// connect to soap server
$client = new SoapClient(NULL, $options);

// Login to SugarCRM
$response = $client->login($user_auth,’test’);

$session_id = $response->id;
$user_id = $client->get_user_id($session_id);

// write our form data to the Contacts module
$response = $client->set_entry($session_id, ‘Contacts’, array(
array(“name” => ‘first_name’,”value” => $_POST['first_name']),
array(“name” => ‘last_name’,”value” => $_POST['last_name']),
array(“name” => ‘email1′,”value” => $_POST['email_address']),
array(“name” => ‘work_phone’,”value” => $_POST['phone_number']),
array(“name” => ‘description’,”value” => $_POST['message']),
array(“name” => ‘assigned_user_id’,”value” => $user_id)
));

$contact_id = $response=>id;

// write our form data to the Accounts module
$response = $client->set_entry($session_id, ‘Contacts’, array(
array(“name” => ‘name’,”value” => $_POST['organization_name']),
array(“name” => ‘assigned_user_id’,”value” => $user_id)
));

$account_id = $response=>id;

$relationship = array(
‘module1′ => ‘Contacts’,
‘module1_id’ => “$contact_id”,
‘module2′ => ‘Accounts’,
‘module2_id’ => “$account_id”,
);

// call set_relationship()
$response = $client->set_relationship($session_id, $relationship);

//var_dump($response);

?>

Now if neither of us has made any blunders you should have a working web-to-SugarCRM form that creates a related Account record and a Contact record, both of which are assigned to the authenticated user. Clearly this is very useful technology because it allows your team to respond to web inquiries directly from SugarCRM. With creative use of such modules as the Google Calendar connector (which works, but you can’t uninstall it after you run a Repair or upgrade), you can do some pretty creative stuff to cut down on extraneous software and procedures.

Long live integration! And good luck!

I first implemented SugarCRM about a year ago when my Information Technology team was looking for a help desk and inventory management solution. SugarCRM isn’t designed for this out-of-the-box, but it does allow you to create and modify modules to suit a wide array of data management needs. I was impressed at the “Fast Stack” installers that unpacked and configured Apache, MySQL and Sugar’s source files (more or less) automatically. I had SugarCRM running on a development server in minutes, and I quickly moved to installing and creating modules. While I found it overall a great application with a lot of promise, we chose to go with Microsoft SharePoint because, with the exception of myself, our IT team militantly supported MS.

But recently I’ve taken over the IT operations of a fantastic non-profit that embraces open source software, and in three weeks we’ve already implemented SugarCRM to track our IT hardware and software inventory, licenses and support issues. This was made easier by the IT coordinator keeping up with existing inventory so well. Our goal was to centralize the data in order to begin working with it, as opposed to merely logging the data in a FileMaker database. The goal in our IT implementation of SugarCRM is to not only keep a record of all computer and network equipment, but also associate this data with software, licenses and technical support issues. In doing this we could then produce reports and track buggy or defective products.

Getting Started

After evaluating a few other CRM’s, like DrupalCRM and SalesForce.com, we chose SugarCRM because the price for the Community Edition–free–was in our budget. We also felt that SugarCRM offered more to us in terms of developing custom modules and taking advantage of modules that others have developed. Furthermore, if we do at some point require more assistance from SugarCRM for development, hosting or support, we can upgrade to one of the paid levels of service. This is very appealing to organizations who cannot or do not want to spend a lot of money on a CRM solution, and I hope to see more SaaS products adopt similar models in the future.

Overall the end-user side of SugarCRM is pretty stable, with the exception of a few annoying little bugs. But developers beware: The module builder is very flaky, and it is possible to totally destroy your SugarCRM installation with a few wrong clicks. I’ve rebuilt the help desk module I designed at least four times, and I’ve had to reinstall the entire SugarCRM package at least three times. We finally elected to implement parallel installations on a development server, where we build modules to deploy on a production SugarCRM server. This has been pretty agreeable so far, and the low application overhead makes it affordable to do this. Once we are convinced of the robustness of a particular custom module, we publish it from within the module builder and then install it on the production server. Certainly it’s not the best idea to develop on a production server, if you have the resources for it. But also it shouldn’t be the case that a few wrong clicks will tank an application.

Installing and Creating Modules

Before creating modules from scratch, it’s a good idea to join the Sugar Forums and mill around SugarForge to see what is already available. Currently there are 472 modules available for SugarCRM, which seems like a huge amount. But one thing you will find is that these modules are not compatible with all versions of SugarCRM. We are currently using version 5.1.0b, which only supports 59 of the 472 existing modules (give or take). To give you an example of how disruptive this problem is I’ve found several really good modules that I’d like to install on our production server, but almost none of them are compatible with the latest release.

This is annoying for several reasons, but most importantly it is a huge disincentive to create new modules. Why should I create and publish a help desk module if it will be obsolete upon the next release? Is it fair of SugarCRM to expect me to rebuild the module every time I upgrade? What if I retire or transition to a new organization that doesn’t use SugarCRM? It’s obvious that a lot of developers have invested time in creating some pretty interesting plugins that are completely irrelevant now. This also makes new releases of SugarCRM something to dread rather than something to look forward to. There must be a better way, and I hope the developers at SugarCRM are working to meet this lofty but important obstacle.

Since we were unable to find a module for exactly what we need, we opted to build our own. The help desk module we created is comprised of four tables: Inventory, Software, Licenses and Support. We have each inventory item associated with a user. (The user table is built-in to the original installation, and the Community Edition does not grant you access to this within the application.) When we add a new computer, for instance, we input details like CPU speed, serial number, manufacturer, model, and so on. We can then click a select box and choose the user to assign the equipment to. We have another form to add new software inventory, like Microsoft Office, FileMaker, and anti-virus utilities. We then associate each piece of sofware to the computer inventory by license instances. These assets are also associated with the built-in Accounts table, which is in turn associated with the Contacts table.

If a user notifies us of a problem, we can create a support instance, which is attached to the specific machine and software giving the problem. Depending on the nature of the problem, we may need to contact the vendor or a third-party warranty provider. To this end each inventory and software item is associated with an account contact and warranty contact, if applicable. From a management perspective, this type of data can help us track our assets and workload, and it ultimately assists us in retiring (and ceasing to purchase) defective equipment.

Beyond the Help Desk

In the past few weeks our IT department has been meeting with different units within our organization to explore their data and tracking needs. Now that the Help Desk module is complete we are developing/revising a module that another department will use to track business contacts and sales leads. This is quite exciting because it is exactly what SugarCRM was designed to do. One thing most SugarCRM users will ultimately notice is that this application will offer way more than your organization probably needs. The module studio comes in extremely handy here so you can remove unnecessary fields and organizes tables in ways that are optimal for a particular department’s work flow.

This presents another issue though, namely user rights management. SugarCRM allows you to associate users with specific roles, much like Microsoft’s Active Directory. It’s not nearly as powerful as network level security policies, but it’s handy because you can assign specific rights to specific roles. If IT does not need to see the Opportunities and Leads tables, for instance, you can remove these tabs from the menu. Unfortunately, it’s not yet possible to omit data within specific tables based upon roles. By this I mean that there may be specific leads or contacts that only one role needs to see. Currently I would have to build a parallel module and store data in separate tables to satisfy this need.

Another limitation we’ve experienced is that there is no reporting module available in the Community Edition. Why they do not offer this baffles me, and I can only speculate that it’s because they want to up-sell their open source users to the paid version. There may be no reason to do this other than wanting clean and customizable reports. I can’t fault them for this from a business perspective, but it’s an artificial way to upsell me considering that the module clearly exists already. That is, there is no real cost limitation in providing this in the Community Edition. They just don’t offer it.

The Future of SugarCRM

This leads me to consider the future of SugarCRM. First let me state that my educational background is in institutional economics rather than computer science or any technologically related field. I’m trained academically to identify incentive structures within organizations and markets, rather intended or unintended. A practical example of this is something like downloading free mp3s as opposed to purchasing them outright. As an institutionalist, I look at the probability of actual enforcement of the DMCA for music theft and the ease of downloading free music illegally. I also scrutenize competing institutional structures, like the individual’s right to privacy, that may infringe upon the abilities of law enforcement agents to enforce a particular institutional arrangement.

With that bias in mind I have to admit that I’m not optimistic about the future of SugarCRM. Although they are clearly the market leader of open source CRM vendors, they have serious limitations in terms of their development policies. As I mentioned previously, the lack of compatibility among modules and version strongly discourages expanding their module-building community. A better approach to this would be to release a future version of SugarCRM that would adhere to the same module structure indefinitely. It is posisble to do this with a little bit of foresight, but in the five or so versions of SugarCRM that have been released there has been no evidence of them moving this direction.

Another future project that I would like to see SugarCRM implement is a very simple, blank PHP page generator that would let me click a few buttons and be editing a new PHP document. This seems like a very simple addition, but so far the SugarCRM development team has completely rejected this idea. For some reason the developers and even most of the community cannot see the utility in being able to interface with the database like this. Some of the debate has been quite heated, and I invite you to read the exchange between myself and a forum member, SugarDev.net, here. I admit that I thought I was conversing with an actual SugarCRM Developer rather than an unhelpful fellow user, and I was shocked as to his responses. But as soon as I learned he was just another user, I was certainly more accepting of his opinion, which is mainly that SugarCRM can’t or shouldn’t offer this PHP enhancement because it would be too difficult.

As far as I see it, SugarCRM Community Edition is just that–it exists for the community of users, which includes myself and my organization. If one of the community members has a need, it’s the responsibility of SugarCRM to help us meet that need. Even if SugarCRM cannot devote the development hours to implement the change for us, they should at the very least assure that their platform offers us the ability to enhance the system ourselves. Sure, there is a way to implement this little PHP enhancement on my own. But I’m not nearly familiar enough with the source code to do this. I doubt very seriously that SugarCRM will ever implement this for me, but I can tell you what I would do with it: I would create a PHP page that read data from SugarCRM’s database and presented it in a form-like manner on a page. I would even impement a solution to export tables (or parts of tables) as CSV and PDF. I would take full advantage of the Google Charts API to present clean graphical representations of the data in our SugarCRM implementation. I could even create my own custom forms and further integrate our SugarCRM installation with other databases in our network.

Conclusion

It’s obvious to me that not every organization is ready to take the non-linear leap that enables the product to grow beyond its original intent. Surely, SugarCRM was designed to be exactly what it is–a Customer Relationship Management tool. And it does this very, very well considering its occassional hangups. On the other hand, this web application is so close to being useable for greater data management needs that it seems criminal to hold it back

There are certainly many bugs floating around SugarCRM, but most of them are addressed very quickly via uprades and new releases. I definitely cannot complain about where the project is now compared to my first attempt at using it. But perhaps my perspective of the project, coming from two distinct times and organizations in which I used it, makes it more apparent to me than most that SugarCRM is far below its potential.

So what am I going to do about it? I will continue to contribute my opinions on the forums and otherwise in hopes that eventually my needs will be heard. I’ll continue to develop modules and deploy them for other organizations to use. At the time of writing this article our corporate attorneys are evaluating the logistics of deploying our first module for the public, namely the help desk module mentioned herein. Ultimately it will be published, but the current question is whether it is done so under my monicer or the company for which I work. I’m really looking forward to giving back to the SugarCRM community though, and I hope that by participating in this way they’ll be more likely to listen to recommendations.

I definitely recommend giving SugarCRM a try, but not without some degree of caution. It is very easy to install and use, but I encourage any new users of the application to spend some time trying to break it. As a developer, you will be able to break it very quickly. Just try making a new module and playing with the table relationships. Eventually you’ll delete a variable or field and find the error with which many of us have become very familiar. Fortunately though the application is pretty solid from the end user’s perspective, so when you are comfortable with it you’ll find it a powerful edition to your organization’s data management resources.

If you have any questions or feedback, join the SugarCRM Forum! Or feel free to contact me directly.