nl2br

The basic function for converting new-lines to HTML line breaks, nl2br in PHP 5.3 incorporates the ability to use (X)HTML-tailored tag ending (i.e. <br /> instead of <br>). But if you’re on 5.2 or under, the second parameter isn’t available and attempting to use it will result in errors.

if(version_compare(PHP_VERSION,'5.3.0') > 1){
  $html = nl2br($text,1);
} else {
  $html = nl2br($text);
}

DateTime Objects and Methods

PHP 5.3 has awesome new functionality for meddling with DateTime objects that just doesn’t exist in PHP 5.2. Just check out createFromFormat(), diff(), add() and sub().

Here’s a work-around I use in place of diff():

 // start with two DateTime objects
$datetime_one = new DateTime();
$datetime_two = new DateTime();

// the necessary way using PHP 5.2
$datetime_one_string = $datetime_one->format('U');
$datetime_two_string = $datetime_two->format('U');
// get a difference represented as an int, number of seconds
$difference = abs($datetime_one_string - $datetime_two_string);

// the fun way using PHP 5.3, returning a DateInterval obj
$difference = $datetime_one->diff($datetime_two);

The benefit of having $difference as a DateInterval object is that you can then modify and format however you want. The PHP 5.2 return above is simply an integer as a number of seconds, which can be converted in a few more steps, but is more cumbersome.

Please don’t go blindly run these snippits against your production system. This post is meant to be a guiding hand to cleaning up your system in case-specific ways that may or may not be applicable to your needs. And remember, always, always, always back up your system (and maybe even try these on a separate backup before your run them against production).

Drop Accounts that don’t have any recorded history or Opportunities

delete accounts from accounts
LEFT JOIN accounts_cstm on accounts.id = accounts_cstm.id_c
LEFT JOIN accounts_opportunities on accounts.id = accounts_opportunities.account_id
LEFT JOIN calls on accounts.id=calls.parent_id
LEFT JOIN meetings on accounts.id=meetings.parent_id
LEFT JOIN tasks on accounts.id=tasks.parent_id
where
(
accounts_opportunities.id is null
and leads.id is null
and calls.id is null
and meetings.id is null
and tasks.id is null
)

Delete Activities that are older than a given date

delete from calls where date_start <= '2008-01-01';
delete from meetings where date_start <= '2008-01-01';
delete from tasks where date_start <= '2008-01-01';

Analyze and Prune Deleted Data

SugarCRM has a great feature of not actually deleting things. When you click the delete button on a record (or even a relationship), that record’s deleted field is set to true, and it’s ignored forever. This acts like your Windows Recycle Bin, so that your developer or DBA (or even you, using our unDelete module) can restore records for you when you didn’t actually mean to click delete (and then didn’t mean to click “Yes” on the delete confirmation…).

The side-effect of this is that nothing is ever actually deleted and things pile up, using more of your storage and causing more and more overhead on your database queries. So once you’ve gotten your backup completed, you can use a script like this one to analyze how much deleted data Sugar hasn’t actually deleted, and then go ahead and actually delete it.

Drop this file into /custom/modules/Accounts/DeleteAnalysis.php:

<?php
global $db;
$query = "show tables;";
$result = $db->query($query);
$tables = array();
while($row = $db->fetchByAssoc($result)){
$tables[] = $row['Tables_in_database_name']; // database_name being the name of your database...
}

echo "<table><tbody>";
echo "<tr><th>Table Name</th><th>Total Records</th><th>Deleted Records</th></tr>";
$sum_all = $sum_del = 0;
foreach($tables as $table){
echo "<tr><td>$table</td>";
$count_all = $count_del = null;
$query = "select count(*) as count from $table;";
$result = $db->query($query);
while($row = $db->fetchByAssoc($result)){
$count_all = $row['count'];
}
$query_del = "select count(*) as count from $table where deleted = 1;";
$result_del = $db->query($query_del);
while($row = $db->fetchByAssoc($result_del)){
$count_del = $row['count'];
}
if(!is_null($count_del) && ($count_del != $count_all) && $_REQUEST['delete'] == 1){
$query = "delete from $table where deleted = '1';";
$db->query($query,"dropping deleted records from $table");
}

echo "<td>$count_all</td><td>$count_del</td></tr>";
$sum_all += $count_all;
$sum_del += $count_del;

}
echo "</tbody></table>";

// totals
echo "Totals";
echo "<ul><li>$sum_all</li><li>$sum_del</li></ul>";

To invoke it for analysis, simply navigate to index.php?module=Accounts&action=DeleteAnalysis. When you’re ready to start dropping data out, append the additional GET parameter on the URL &delete=1.

This may be a long process, depending on the size of the database. You may need to extend your PHP configuration’s max_exeuction_time property.

Identify Contacts with an Assigned User different than their Related Accounts’ Assigned User

I said case-specific, right? Our client needed to update the database to ensure that all contacts had an assigned user to match their parent accounts’ assigned user. It was a several-step process:

First we established a benchmark to see how many records we’d be changing with this:

select accounts.id,accounts.name,accounts.assigned_user_id,
contacts.id,contacts.first_name,contacts.last_name,contacts.assigned_user_id
from accounts
join accounts_contacts on accounts_contacts.account_id = accounts.id and accounts_contacts.deleted = 0
join contacts on contacts.id = accounts_contacts.contact_id and contacts.deleted = 0
where accounts.deleted = 0
and accounts.assigned_user_id <> contacts.assigned_user_id

Then we update all of the contacts in a basic way…

update accounts
join accounts_contacts on accounts_contacts.account_id = accounts.id and accounts_contacts.deleted = 0
join contacts on contacts.id = accounts_contacts.contact_id and contacts.deleted = 0
set contacts.assigned_user_id = accounts.assigned_user_id
where accounts.deleted = 0;

We then realized that some of our Contacts were related to multiple accounts, so making them match got tricky. We decided to take these leftovers and assign them to a particular user, a staff supervisor, so she could sort things out manually:

update accounts
join accounts_contacts on accounts_contacts.account_id = accounts.id and accounts_contacts.deleted = 0
join contacts on contacts.id = accounts_contacts.contact_id and contacts.deleted = 0
set contacts.assigned_user_id = '1'
where accounts.deleted = 0 and accounts.assigned_user_id <> contacts.assigned_user_id
and contacts.assigned_user_id <> '1';

Running the benchmark again, but adding an additional clause to filter by this user account, we should find zero rows.

select accounts.id,accounts.name,accounts.assigned_user_id,
contacts.id,contacts.first_name,contacts.last_name,contacts.assigned_user_id
from accounts
join accounts_contacts on accounts_contacts.account_id = accounts.id and accounts_contacts.deleted = 0
join contacts on contacts.id = accounts_contacts.contact_id and contacts.deleted = 0
where accounts.deleted = 0
and accounts.assigned_user_id <> contacts.assigned_user_id
and contacts.assigned_user_id <> '1'

Update Contacts with values from related Accounts

Similar to the above, but using custom fields:

update
accounts
join accounts_cstm on accounts.id = accounts_cstm.id_c
join accounts_contacts on accounts.id = accounts_contacts.account_id
join contacts on contacts.id = accounts_contacts.contact_id
join contacts_cstm on contacts_cstm.id_c = contacts.id
set contacts_cstm.account_type_c = accounts_cstm.type_c

And to check:

select accounts.name,accounts_cstm.type_c,contacts.last_name,contacts_cstm.account_type_c from
accounts
join accounts_cstm on accounts.id = accounts_cstm.id_c
join accounts_contacts on accounts.id = accounts_contacts.account_id
join contacts on contacts.id = accounts_contacts.contact_id
join contacts_cstm on contacts_cstm.id_c = contacts.id
where contacts_cstm.account_type_c <> accounts_cstm.type_c;

First, know that there are three sets of labels within the system, $mod_strings is an array that carries the labels for a given module (e.g. Contacts or Accounts), while $app_strings and $app_list_strings contain system labels like translated module names, dropdown lists and system button labels (e.g. the “Print” link at the bottom of nearly every page). I find that $app_strings and $app_list_strings seem to have a bit of overlap, so the point to understand is consistency; if you define a label in $app_list_strings, you’ll want to call it from $app_list_strings.

$mod_strings

Let’s start with the module-specific labels. You’ll find the original, vanilla labels are stored in the module-specific directories. For Contacts, that would be /modules/Contacts/language/. Language files are prefixed with the international language identifier, and SugarCRM supports 22 languages (and more are available around the ‘net). An example would for American English would be en_us, or Spanish (Español) as es_ES.

That said, the English language file would be en_us.lang.php. In that file is a single array, $mod_strings. The array keys are code references, always in CAPS and usually prefixed by LBL_. The values are the translated labels. For example,

$mod_strings = array(
     ...
     'LBL_FIRST_NAME' => 'First Name:',
     ...
);

This directory holds the stock language files, but to maintain an upgrade-safe system we don’t want to touch these files. Instead, we have two options for placing custom language definitions.

The easiest option for custom language files mirrors the original directory in the custom directory, again using Contacts that would be /custom/modules/Contacts/language/en_us.lang.php. This file will be structured the exact same way as the original file; the two arrays are merged when the screen is being generated for the user. If there are conflicts, the custom definition takes precedence. This method of custom language definition is ideal if you’re customizing a single system, i.e. not packaging changes up for mass-distribution and not having to work via Module Loader for a hosted system. Changes to language files made in Studio will write to this directory.

The second option for custom language files makes use of the Custom Extension directory and the cascading file-merge performed by Repair and Rebuild. If you’re not familiar, I’ll give an example. Let’s modify the LBL_FIRST_NAME label in Contacts. Create a file at /custom/Extension/modules/Contacts/Ext/Language/en_us.PSI_TopLevelLanguageChange.php. The file name itself is arbitrary, anything is allowed so long as you provide the proper language-determining prefix. It’s a good idea to also prepend an author key (similar to creating a module) to avoid collisions. Within that file we’ll create individual pieces of the $mod_strings array:

<?php
$mod_strings['LBL_FIRST_NAME'] = 'Forename';

Notice how we are explicit about setting the key and value within the already-existing array. Do not create the entire array. This array is not merged into the master language list the same way that /custom/modules/Contacts/language/ is. It is actually lower-priority, because it is intended for mass-distribution. You may notice that when exporting changes from Studio, the generated module uses this method to load the language files.

Also realize that merely creating this file did nothing. What we’ve done is placed the file in a directory that Repair and Rebuild will scan and create a compiled language definition from all files within the directory. The Repair and Rebuild process will create /custom/modules/Contacts/Ext/Language/en_us.lang.ext.php which holds the compiled field-explicit language adjustments from the Extension language definitions. You’ll also notice that in this file is a repeated warning message, “WARNING: The contents of this file are auto-generated.” Heed this warning; adjustments to this direct file will be wiped out on the next Repair and Rebuild.

So the hierarchy is this, in order of precedence:

1. custom/modules/<ModuleName>/language/en_us.lang.php
2. custom/modules/<ModuleName>/Ext/Language/en_us.lang.ext.php
3. modules/<ModuleName>/language/en_us.lang.php

$app_list_strings and $app_strings

With an understanding of the hierarchy for $mod_strings, $app_strings and $app_list_strings make pretty good sense. These work similarly to $mod_strings, but base all custom definitions in slightly different directories:

• /custom/include/language/en_us.lang.php for Studio-created or basic changes.
• /custom/Extension/application/Ext/Language/en_us.PSI_ArbitraryName.php for the more easily-distributed field-specific or labels-specific, explicit changes. Remember that creating this file doesn’t actually affect anything until you perform the Repair and Rebuild, which creates…
• /custom/application/Ext/Language/en_us.lang.ext.php for the compiled language files.
• Default/Stock language definitions are kept in /include/language/en_us.lang.php.

The 2011 Partner of the Year Award was granted to Opensymbol. Each year, the award is given to one SugarCRM partner. The criteria for the award is based on the company having more than one year of SugarCRM experience, as well as success in new customer acquisition and customer retention, consistent growth and active participation in SugarCRM’s sponsored events. The partner must also be in good standing and nominated by a regional vice president.

W Systems, based in Ramsey, New Jersey received the Rookie of the Year Award. The company was selected because of their ability to engage quickly with SugarCRM and achieve major milestones since signing their agreement with SugarCRM in November 2011. Within 60 days of signing on with SugarCRM, W Systems secured more than 20 new customers and became a primary evangelist for SugarCRM by becoming the first partner to participate in a partner case study.

The Top Performer Awards were given to 29 companies by region. Each company achieved growth from 2010 to 2011 and secured at least $20,000 in new customer subscriptions with SugarCRM.

In North America, the winners were: Profiling Solutions, Cynergy Solutions, OA Solutions, ATCORE Systems, ApexTwo, Faye Business Systems Group, Technology Advisors, Inc., Concentrix, Highland Solutions, and Plus Consulting. In EMEA, the winners were: Smile Open Source Solutions Group, Corenet, Hubstone, OpenSymbol, Captivea, CS2, Ysance, Dupaco, and dotBase. In Latin America, the winners were: DISYTEL openConsulting, Palmtree Consulting, QuanticVision, and GrowIT. In Australia and New Zealand, the winners were: Innovent, CRM Online, and CRMLogic. In Asia, the winners were: Bhea Technologies Pte Ltd., CRMWorks Asia, and Signify.

The Most Valuable Player Awards were granted to 10 companies by region. Partners were nominated by a Regional Vice President based on their significant customer acquisition year over year and their ability to achieve customer retention of 80% or higher. In North America, the winners were: BrainSell, Epicom, ATCORE Systems, and Levementum. In EMEA the winners were: EnableIT Technologies, Insignio CRM, Synolia, and Jacobsons Direct Marketing. In Latin America, the winner was GrowIT. In Australia and New Zealand, the winner was InsightfulCRM. In Asia, the winner was BHEA Technologies Pte Ltd..

“We are thrilled to see a record number of top performers awarded and want to congratulate all our partners on their achievements,” said Jeff Campbell, Vice President of Worldwide Sales. “They have been diligent in 2011 to meet their business goals and deserve recognition for their accomplishments. We are looking forward to continued success in the channel in 2012.”

Special Recognition Awards were given to BrainSell, Epicom, Highland Solutions, InsightfulCRM, Insignio CRM, iZeno, Lampada Global Services, Levementum, OpenSymbol, Palmtree Consulting, REDK, and Synolia. Both iZeno and Epicom received multiple Partner of the Month Awards in 2011. Amanda Anderson of Epicom was the recipient of the Most Creative Marketer Award.

Please see other SugarCRM announcements from SugarCon about the company’s Q1 2012 momentum, the latest Sugar 6.5 product release, and additions to the company’s channel partner program.

More About SugarCon 2012

SugarCon 2012’s theme is “Explore the Possibilities of CRM,” inspiring attendees to dig deeper into the vast capabilities that CRM offers. In keeping with SugarCRM’s open approach to business, the CRM community, not SugarCRM, built the conference schedule based on attendee suggestions and online voting. The event will offer eight tracks with more than 80 breakout sessions, as well as separate UnCon and training programs.

For more information on SugarCon 2012, visit the event web site. To register for the event, visit the registration page.

About SugarCRM

SugarCRM makes CRM simple. As the world’s fastest growing customer relationship management (CRM) company, SugarCRM applications have been downloaded more than ten million times and currently serve over 1,000,000 end users in 192 countries. Over 7,000 organizations have chosen SugarCRM’s On-Site and Cloud Computing services over proprietary alternatives. SugarCRM has been recognized for its customer success and product innovation by CRM Magazine, InfoWorld and Customer Interaction Solutions.

For more information, call (408) 454-6900 or 1 87 SUGARCRM toll-free in the US, email contact@sugarcrm.com, or visit www.sugarcrm.com. You can also connect with SugarCRM on Facebook, Twitter and YouTube.

http://www.sys-con.com/node/2260364

But suppose you didn’t want to hide all of the subpanels for a given module, but just to remove it from a particular view? For a real-life example, we recently had a need to remove the default Opportunities subpanel from the Accounts DetailView. Because it’s only for this view that we want to drop the Opportunity subpanel, the above dialog doesn’t fit the need, and Studio cannot help us either. We must go through code.

Subpanel layouts are defined originally within metadata, e.g. /modules/Accounts/metadata/subpaneldefs.php. These files hold the original, default layout of subpanels and the fields within them. They are overridden in custom Extension data, e.g. custom/Extension/modules/Accounts/Ext/Layoutdefs/accounts_opps.php. After a repair & rebuild, you’ll find the data from the arbitrarily named files are merged and placed in /custom/modules/Accounts/Ext/Layoutdefs/layoutdefs.ext.php.

In these files we can define new subpanels or re-define existing ones. To actually remove one, we can use PHP’s unset function:

<?php
unset($layout_defs["Accounts"]["subpanel_setup"]['opportunities']);

For further example, here is the described code, packaged and ready for distribution via Module Loader:
Accounts DetailView Hide Opp Subpanel

As it often does, the SugarCRM Forums held the question and answer. In extending the 30 minutes session timeout forum user Duzoid posts the question and it is eventually correctly answered by user Sunside. The solution is to modify the PHP configuration variable session.gc_maxlifetime. Sunside suggests placing the changed configuration in an .htaccess file due to accessibility and hosting environment limitations, but having access to my core php.ini I went ahead and changed our local Sugar instance globally.

If it is allowed on your host, then you may very well change this in the .htaccess file:

php_value session.gc_maxlifetime 14400

This should set the session lifetime to 4 hours.

Please note that if session files are shared between different scripts in different directories on your server, then you need to make this setting in each of the script directories’ .htaccess file. That is because other scripts may erase your Sugar session files if they have a shorter session lifetime.

You could also create a separate directory for Sugar session files and set this with

php_value session.save_path /my/new/sugarsessiondir

in the .htaccess that you put in your Sugar root directory. You should NOT create this directory anywhere under your htdocs, but further up in the directory structure, so that these files cannot be accessed by the webserver for security reasons.

The preferred way of setting the garbage collector’s maxlifetime would be to do it serverwide in the php.ini, but this may not be possible in some shared hosting environments.

Following some instructions I piece-milled from a few web sites, here is the process I used:

1. Within the Debian Squeeze Server (assuming Apache2 is already set up and running)
1. a2enmod ssl
2. mkdir /etc/apache2/ssl
3. cd /etc/apache2/ssl
4. openssl req -new -newkey rsa:2048 -nodes -keyout sugar.profilingsolutions.com.key -out sugar.profilingsolutions.com.csr
5. chmod 600 /etc/apache2/ssl/*
6. cat /etc/apache2/ssl/sugar.profilingsolutions.com.csr (copy the output of this so that you can provide it to GoDaddy later on)
2. In your GoDaddy.com Account
1. Click My Account, expand the SSL Certificates section and click the green Launch button by the certificate you want to set up (assuming you’ve already purchased one).
2. Follow prompts to select your certificate, server type and provide the CSR you copied from the server
3. wait… GoDaddy will take a few hours. In the mean time, you may be require to verify the domain. This typically involves setting up an specific and obscurely-named HTML file in the root directory of your server. Check your Pending Certificates page every 30 minutes or so to see if there is a “hold up” that you need to resolve.
4. Note that my domain wasn’t automatically verifying with their tool, so I had to request manual verification which may take up to 24 hours.
3. Once the domain is verified, download your certificate from the GoDaddy SSL Certificates section.
4. Upload the certificate package bundle (zip archive) to your server at /etc/apache2/ssl/
5. unzip package with unzip -qq *zip
6. **edit the file /etc/apache2/sites-available/default-ssl and adjust the CertificatesFile parameter to point to your new file.**
7. Again in your GoDaddy account, download your new Certificate file (.crt)
8. a2ensite default-ssl
9. service apache2 restart

Larry Ellison is the founder of Oracle Software, the second largest applications provider in the world.   First and foremost he is a sales representative.  His quote is very much posturing and positioning.

I reference the quote only because as a consultant, I empathize with my customers being bombarded with statements and promises by Sales people. But how do you make an informed decision?

Many CRM sales representatives want you to buy the system without knowing what’s under the hood.  It would be like buying a car based solely on color and design only to find out afterwards that the engine does not have enough horsepower.

Every CRM has accounts, contacts, opportunities, activity management, leads, a few have quotes, most have custom reporting and dashboards, most integrate with other systems.  Whether you’re considering SugarCRM, SalesForce, Zoho or a plethora others, the basic CRM functionality is generally the same.  So, you might ask, what is the difference? Well, there’s a lot of difference that may not be seen. Here are 4 questions you should ask before buying a CRM system so you know what’s ‘under the hood’ and away from ‘the roach motel’.

1. Multi-tenant or Single tenant?  Do I own my data?
2. Is there additional cost for additional CRM functionality?
3. Are there restrictions regarding the number of custom modules, fields, workflows, etc?
4. What is the exit plan? How do I get my data back?

Answer 1: Multi-tenant are systems in which multiple ‘customers’ use the same database.  Information is segmented through database security.  A single-tenantsystem is a system were the ‘customer’ has their own database.  Single tenant systems allow you to customization the system more extensively without the restrictions of multi-tenant systems.  In a multi-tenant system, you are sharing a database with others.  Multi-tenant systems place restrictions on the number of fields, modules, integrations, workflows that can be supported.

SugarCRM Answer 1: SugarCRM is a single-tenant system.  Each company has their own database.    And with SugarCRM, you have you choose of where you want to have SugarCRM hosted: the SugarCRM cloud, private cloud, or your own network.

Answer 2:  With almost any other CRM system, the answer is yes.  Extra CRM functionality is additional cost.

SugarCRM Answer 2: With SugarCRM regardless of the SugarCRM version, the CRM functionality is the same.    Differences in  versions is based upon additional support, storage, mobile, and platform options.  But not CRM functionality.

Answer 3: Yes

SugarCRM Answer 3:  There are no limits of any kinds: unlimited modules, unlimited fields, unlimited workflows, unlimited API calls/webservices.

Answer 4:  Some companies will charge you to get a copy of your data or give you a collection of CSV files 4 to 6 weeks later.  Some require that you run reports for each entity and export to Excel.  And some have no way of getting your data back to you.

SugarCRM Answer 4: On request, SugarCRM will give you a copy of your database (not CSV files) and a copy of all the files associated to SugarCRM and at no charge!

First, I’d like to plug a really great software called WAMP Server. WAMP is a pre-packaged Apache Web Server, MySQL Server, and PHP installation. It’s intended for development purposes, but it can just as easily be sat on a production box after some minor configuration changes. The neat feature in WAMP is that you can download additional versions of PHP; switching between versions is easily done via right-clicking an icon in the Windows system tray. Additionally, PHP extensions can be toggled on or off from the same menu. That’s a big deal if you want to make sure your code works in PHP 5.1, 5.2 and 5.3, or even check PHP 4 support. That said, XAMPP is a similar tool that has all of the functionality of Apache, MySQL and PHP bundled up, but it’s a little less easy to drop in support for separate versions of PHP.

Note that both of those software come packaged with MySQL Database Server. The point here is to use MSSQL, so you’ll probably want to disable the mysqld service.

Option 1, mssql

PHP actually has a pre-bundled extension mssql or php_mssql. This gives the developer the ability to connect to a database, run queries and return query results. Very nice, if you can get it to work. I’ve found that recent versions of PHP running on WAMP (specifically 5.2.9, 5.3.1, 5.3.4, 5.3.5) simply will not connect to my locally-installed MSSQL Server running 2008. Some versions don’t appear to have the php_mssql extension packaged. I don’t really know if this is a failure to compile things from the distributors of WAMP or if there’s a more-upstream issue, but it doesn’t work. What does work for me is WAMP and PHP Version 5.2.11. Grab it from WAMP’s Sourceforge Page.

Switching to PHP 5.2.11 and enabling the php_mssql extension via the UI is all I had to do to make my mssql_connect and mssql_query functions work. The down-side is that I’m stuck in PHP 5.2 and miss out on some of the cool new functions in 5.3.

I have probably 10 different versions of PHP installed on my machine, and 5.2.11 is the only one that works. Your mileage may vary, I’m guessing drastically based on your version of SQL Server.

Option 2, ODBC

ODBC support is built in to every version of PHP since PHP4. It’s basically a standardized way of connecting to and working with databases, and it works great. The down side of ODBC is that it’s said to be slower than the new OLE-DB. I maintain one PHP-based portal using ODBC and customers do not complain; like everything else, performance very depends on your resources and requirements.

Using ODBC, you’ll have to specify a specific connection string. Here’s a quick way of doing that:

function db_connect($host,$user,$pass,$db){
	// This connection string is used on the production box, Windows Server 2003
	// and SQL Server (hosted spearately but also Win 2003) version 2005
	$dsn = "Driver={SQL Native Client};Server=$host;Database=$db; Uid=$user;Pwd=$pwd;";
	// This is a more generic one I use with to dev with, Windows 7 and SQL Server 2008
	$dsn = "Driver={SQL Server};Server=$host;Database=$db"; // only for dev. purposes

	try{
		$conn = odbc_connect($dsn, $user, $$pass);
	}catch (Exception $e){
		die('Could not connect to database.');
	}
	return $conn;
}

Option 3, OLE DB and/or Application-Specific Providers

I recently worked with a Sage SalesLogix portal that needed to take advantage of some application-specific functions within an OLE DB Provider shipped from Sage. I was capable of using the MSSQL database functions directly with ODBC or mssql with above methods, but to access the extra functions I had to use their provider. This can only be done using Windows boxes because we must leverage the PHP COM Class. This works similarly to the ODBC connection but methods’ names are a bit different and, in my opinion, less intuitive. Here’s a sample from my database-connecting class that used an OLE DB-based COM Connection.

class oledb_database{
	var $user;
	var $pass;
	var $db;
	var $connection_string = 'Provider=SLXOLEDB.1;Data Source=localhost;Initial Catalog=$db;User Id=$user;Password="$pass";Persist Security Info=True;Extended Properties="PORT=1706;LOG=ON;"';
    var $rows_count;

    function connect(){
        if(!class_exists('COM')){
            die("COM Class could not be found. Please run system from a Windows-based PHP system.");
        }
        $conn = new COM("ADODB.Connection") or die("Cannot start ADO");
        global $config;
        try {
            $conn->Open($connection_string);
            $this->link = $conn;
            return true;
        } catch (Exception $e) {
            echo 'Caught exception: ',  $e->getMessage(), "<br>\n";
            return false;
        }
    }
    function query($query){
        try {
            $this->result = $this->link->Execute($query);
            $this->rows_count = $this->result->Fields->Count();
            return $this->result;
        } catch (Exception $e){
            echo 'Caught exception: ',  $e->getMessage(), "<br>\n";
            echo "<h3>$query</h3>";
            die();
        }
    }
}

The OLE DB method felt much more cumbersome, but in the end it had nice exception handling and worked fine (once I got the connection string right).

Conclusion

Your options are native mssql support if you can manage it, classic ODBC and or modern OLE DB connections. Surely one of these methods will allow you to connect and work with your data.

There is one final method for connecting to MSSQL databases that I am aware of, and it is FreeTDS. This is really a project geared to getting MSSQL connectivity supported in Linux-based Apache systems and is known to be difficult to work with. If you must use a Microsoft SQL Server database, you will have a easier time with things if you work with a Windows-based Apache and PHP configuration with one of the above methods.

First-off, give the Background section of the article Creating SalesLogix Table ID Values by Ryan Farley. This will expand a bit how the ID-string is composed. Don’t bother to read into the functions and methods of creating IDs. Ryan is writing from the perspective of a Saleslogix Developer and has access to nifty functions inside the system that automatically generate IDs (as most systems do). But, being that you’re writing this in PHP, presumably for some portal or integration, you’re not inside Saleslogix and thus do not have access to those nifty functions (unless you’re opting to work with the Saleslogix OLE DB Provider on a WinPHP System … more on that later). We’ll have to create our own function go generate these IDs.

First-off, recall that the first character of the ID will be module-specific (or entity-specific, or table-specific), i.e. all Account records start with “A” and all Contact records start with “C” and all “Other” records start with “Q.” Reference sitekeys.KEYDESC for more of these. If you’re note sure what your leading-letter ought to be, just look at the IDs of some existing records of your particular module type.

Next the site code. Again we look at our surroundings. Site codes designate the database used to create the record. Keep in mind that Saleslogix systems will have several databases, one for each client and one on the server. For the purposes of integrations and portals, find the site code for the server itself and use this. Use the siteoptions table for reference.

Now the automatically-incrementing, base-36 encoded part. We’ll use the standard PHP function base_convert heavily here to decode the last-used ID and re-encode it after incrementing.

The last piece of the puzzle is the keytype. Key types aren’t part of the ID string itself, but are a way of referencing the auto-increment log in the sitekeys table. Given a keytype and sitecode we will be able to determine the desired key.

With all that said, I’ve come up with three methods to aide the creation of Saleslogix GUIDs. I offer these as an example and in the spirit of Open Source (also in the spirit of Open Source, please refer to article 11 of the GPLv2 for notes on how I feel about supporting this code).

    public function create_guid($single_char,$site_code,$keytype){
        $current_string_base36 = $this->retrieve_last_key($site_code,$keytype);
        $current_string_base10 = base_convert($current_string_base36,36,10);
        $next_string_base10 = $current_string_base10 + 1;
        $next_string_base36 = base_convert($next_string_base10,10,36);
        $next_string_base36 = strtoupper($next_string_base36);

        $this->put_new_key_into_sitekeys($site_code,$keytype,$next_string_base36);

        $newId = $single_char.$site_code.$next_string_base36;

        return $newId;
    }

    private function put_new_key_into_sitekeys($sitecode,$keytype,$newvalue){
        global $db;
        $query = "update sysdba.sitekeys set keyvalue = '$newvalue'
        where sitecode = '$sitecode' and keytype = '$keytype';";
        $db->query($query);
        return true;
    }

    private function retrieve_last_key($sitecode,$keytype){
        global $db;
        $query = "select keyvalue from sysdba.sitekeys
        where sitecode = '$sitecode' and keytype = '$keytype'";
        $result = $db->query($query);
        while($row = $db->results_by_array($result)){
            return $row[0]['keyvalue'];
        }

        return false;
    }

Now, to put that to use, we could have these methods built into a Notes class (or even better, a Basic class that the Notes and other classes can extend).

require_once('modules/basic.php');
class note extends basic{
    var $tablename = 'ticketactivity';
    var $id;
    function save($note,$ticketid){
        $this->id = $this->create_guid('Q','6UJ9','25');
        ...
    }
}

In the above examples, I also have a global $db object that is a database-helper I created to connect to the database directly and run and process queries to it. You can create one too, or call queries directly with mssql_query. My helper object is really just an abstracted front-end to mssql_connect, mssql_query and mssql_fetch_assoc.