Washingtons Green Grocer is the brainchild of John (Zeke) Zechiel and his wife Lisa. After identifying the need for better produce and deliverables versus store bought goods, John and Lisa planted the seeds for Washingtons Green Grocer in 1994. Every week, Washingtons Green Grocer provides customers with tentative lists of fruits and vegetables that will be available, and each customer can pick and choose what they would like delivered (yep, home delivery!) for that week through their online account.

Providing unmatched service and 100% dedication to custom satisfaction, Washingtons Green Grocer has been wildly popular and has exploded in the DC metro area. They currently serve all of Washington DC and the surrounding suburban areas in Maryland and Virginia from Severna Park to Arlington and all points in between north and south.

How does it work?

Every week, Washingtons Green Grocer selects 12 to 14 different fruits and vegetables and delivers them to your doorstep. On Friday’s, they email customers a tentative list for the next weeks delivery. If there is anything on the list you don’t want, you can log into your account and customize your box. For example, you can choose to receive only 7 items instead of the full box, or substitute items for other items. Each customer can choose exactly what they want and get it without fail every single week. You can also set custom schedules for delivery, such as every other week, or once a month, or schedule around vacation time. It’s all up to the customer!

Application

Such business growth commands the necessity of a powerful web application to tie all the logic together and keep things running smoothly. After getting tired of the shortcomings of their previous system, Zeke contacted us and we started talking about a full redesign of the front end and a re-architecting of the back end. After planning and mind-mapping the application to the last detail, Inclind began work on the project early in the summer of this year.

Their initial website was built on a rigid and inflexible Coldfusion system. The first order of business was getting all the existing data out and into the new system and giving it structure to make it easy to work with. As with all our sites, we begin with a base install of Drupal 6 to build from. Drupal is the best CMF (content management framework) available right now. Other packages that are simply CMS (content management systems- Plone, Wordpress, Joomla) are not as adaptable and flexible as Drupal.

To handle the business end of things, Ubercart takes care of the day to day transactions for customers. There are over 5,000 active customers in the system. To make it as easy as possible to get started, we ask for your basic information up front and allow you to pick your items for delivery. After your account is created, a staff member at Washington’s Green Grocer selects the most appropriate truck route for you and you will begin receiving deliverables on the next scheduled day.

At this point, a customer can login at any time and adjust their delivery schedule, items for delivery, or halt deliveries. Customers can also browse recipes on the site and submit their own. Washington’s Green Grocer promotes healthy eating habits and you will find plenty of recipes on their website for that.

Backend

Along with the new visuals and customer functionality, we needed to build and provide lots of cool administrative stuff into the backend for easy management of customers, data, and content.

We also needed to be able to actively map delivery truck routes through Google Maps on demand and be able to filter them in a variety of ways. This helps Washingtons Green Grocer visually assess their delivery routes, their customers, and orders. We also also extended on that to provide filtering tools to narrow it down further to specific routes, specific clients, specific orders or orders with specific kinds of products.

Washingtons Green Grocer staff also have a variety of reporting tools at their disposal for viewing customer trends, requests, future forecasting, and production reports.

Check out Washingtons Green Grocer today!

Leif has a background in photography, web design, SEO, project/client management, and social media with a likeable personality to boot. He’s very active with social media (and we don’t mind that!) such as Facebook and Twitter. He’s also active in the community with his photography.

Welcome Leif!

It’s 2010. It’s time to stop using Internet Explorer 6.

Internet Explorer 6 was released like a virus on August 27, 2001 with Windows XP. That makes the browser almost 9 years old. Most of you don’t keep cars for that long. You trust your car to protect you from danger, that it has efficient gas usage and quality parts. As soon as it gets old, or you have service issues, you go get a new car. Yet, some of you don’t seem to be bothered that when you sit down to do your banking or purchase things online, you use a browser that has little to no security, easily delivers malware/virii/spyware, and does not adhere to the internet standards created by some of the top minds of internet architecture at W3C. That’s like going 80 miles an hour in a car made of glass, bald tires, and powered by a leaky nuclear core. Eventually you are going to get hurt.

With so many super sexy options out there for browsers, you owe it to yourself to upgrade. And why not? Browsers are free. You’re lucky. I remember paying for Netscape Navigator 4 just to escape Internet Explorer in the 90s. That’s how much I loathed it- and that’s how popular Netscape used to be. For the stubborn who refuse to upgrade, you are about to be left behind. Companies like Google are discontinuing support for Internet Explorer 6. Google knows whats up.

It’s time for you to take action. Please upgrade your browser today. Choose a flavor and enjoy better, and safer, internet browsing today. All of these browsers offer bookmark importing, so you can take your favorites from IE with you.

Google Chrome
Mozilla Firefox
Opera
Apple Safari

If you need assistance upgrading, we’re here to help.

What is an LLC?

A limited liability company or a company with limited liability (abbreviated L.L.C. or LLC or W.L.L) in the law of the vast majority of United States jurisdictions is a legal form of business company that provides limited liability to its owners. Often incorrectly called a “limited liability corporation” (instead of company), it is a hybrid business entity having certain characteristics of both a corporation and a partnership or sole proprietorship (depending on how many owners there are). An LLC, although a business entity, is a type of unincorporated association and is not a corporation. The primary characteristic an LLC shares with a corporation is limited liability, and the primary characteristic it shares with a partnership is the availability of pass-through income taxation. It is often more flexible than a corporation and it is well-suited for companies with a single owner.

Delaware LLC is built on our custom Drupal CMS package. It was designed from the ground up by Creative Director Kevin Howett, and put together in a collaborative effort between newcomer Matt Oseland, Kevin Howett and Bryan Cordrey. Efforts were focused on a pleasing, business-minded design, effective search engine optimization, and funneling/encouraging customers to begin the process of forming an LLC in Delaware.

As Rick’s customers go to him and Harvard Business Services for their LLC/incorporation expertise, Rick came to Inclind for our expertise in clean, effective websites and powerful web application development under Drupal and our deep knowledge of content management systems such as Drupal. We also got to flex our system integration skills with Drupal, PHP and Coldfusion.

About Delaware LLC & Harvard Business Services

With more than 25 years of experience, over 20,000 clients worldwide, and offices in both the United States and Europe, Harvard Business Services, Inc. is the premier provider of registered agent and business formation solutions.

Rick Bell formed Harvard Business Services, Inc. in March, 1981. Competitors then were big and well established. But Rick conducted business with a philosophy that allowed Harvard not just to survive but to thrive, emerging over time to become an acknowledged leader in the business formation industry.

His philosophy focused on a highly personalized style of customer service, understanding that beyond the mechanics of forming a business there were dreams and aspirations. A customer’s individual questions and concerns were important and special, and that’s how they were treated.

Rick also decided that a customer’s business formation costs should be fixed, predictable, affordable, and customers should get a lot of value for their money.

After almost 30 years and tens of thousands of business formations later, that same approach is still the signature of our culture and way of doing business: speed, efficiency, expertise and affordability, all delivered with the Harvard legacy of personal service.

Headquartered in Lewes, DE, Harvard Business Services, Inc. today is the leading provider of business formation services. Along with the Harvard Business Services brand of fast, personalized service, customers soon discover a number of other traits that set Harvard Business Services, Inc. far apart from the rest.
———————————————–

If you have any questions regarding content management systems, Drupal, Coldfusion or systems integration, we are here to help. Give us a call at 302-856-2802, send us a tweet @inclindinc, or stop by our office. We have been the leading web development firm in the area for over 10 years running and have fourty years of combined web experience under one roof.

“At least 34 companies, including Adobe, Symantec, Yahoo and Dow Chemical, were attacked, according to industry sources.”

Whether or not it was a government sponsored attack is irrelevant here (let the FBI/NSA/CIA figure it out, our tax dollars pay for that sort of thing). The common thread in all the attacks is that Internet Explorer was exploited and used to gain access to the infrastructures of these companies.

Do you still use Internet Explorer? The version doesn’t matter, even 8 still sucks. Ask yourself why. If Symantec, Google, Adobe and Yahoo couldn’t protect themselves from an Internet Explorer exploit, what makes you think you can? Google even has the cajones to come out and publicly lambast China and denounce Microsoft XP/IE6 and urge users to move away from Internet Explorer (props to Google).

Switch today. There are plenty of better and more secure browsing options out there. Our personal favorite in the office is Google Chrome. It is lightweight, extremely fast, secure, and works great with web apps like Gmail and Google Wave. It has the fastest javascript engine and pages load lightening quick. Apple’s Safari is also secure, but not as fast as Google Chrome. Opera is also plenty fast and secure as well. There is also Mozilla Firefox, which isn’t as fast, and becomes more insecure the more plugins you add into to it, due to how plugins run with all permissions. Personally I think Firefox is bloated and slow, but it was the first real alternative to Internet Explorer after Netscape left the scene some years ago.

Lastly, if you are still using Windows 98, 2000, XP, its time to move on. Don’t leave your front door open and then complain when your home is robbed. Windows 7 is great, OSX is great, and if you are feeling adventurous, try out Ubuntu.

Fortunately, there is a program out there that will help you keep track of your passwords in a secure way. KeePass is a free program for Windows, Linux, iPhone, and OSX and other portable devices. KeePass allows you to store login information for reference. For example, if you have an Amazon account and you go to log into the website, you can open KeePass and grab your password to paste into the login form at Amazon.

KeePass keeps your data in an encrypted database that must be opened with a master password. Think of it like the key to your front door. This is the only password you need to remember, because it will prevent you from getting to your data if you cannot remember it (just like losing your key to the house will have you locked out).

The best way I have found to use KeePass is to install the software on the machines you frequently use, and store your KeePass database on a USB stick for safekeeping. That way, you can access your passwords anywhere you are, so long as KeePass software is installed.

If you do a lot of commerce online, it would be a good idea to look into this solution for yourself. Better safe than sorry!

Lets take a look at how you bring in files as part of that node as well. From the previous example, before calling node_save($node), I call another function to process files. Name it however you wish. My module is called homes_sync, so my hooks and functions begin with that as per Drupal standards.

1
2
3

homes_sync_get_files($node, $nid, $sessid);
// save the node object
node_save($node);

homes_sync_get_files() is passed the $node object and will return it after adding (or removing) data. To have a reliable file sync, we need to only update files if they are newer, and remove them if they no longer exist.

In this specific example, the project I am working on has two CCK file fields. One is for a floorplan (a PDF) and the other is an image field. In a node, there is only 1 floorplan, but can be up to 2 dozen images. If you had a more generic node that just has a CCK filefield of ‘client_files’ for example, your code would be slightly different.

Before we add any files to the node, the first thing we should do is compare the list of files from the remote site to the local site. We start that off by getting $files via xmlrpc, and loading the node object if $node->nid is present. If any are found on the local site, and not the remote site, we can safely remove them from the node object. The two arrays are iterated over and remove files if necessary.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

function homes_sync_get_files($node, $nid, $sessid) {
 
	$files = xmlrpc(REMOTE_SERVICES_URL, 'file.getHomeFiles', $sessid, $nid);
 
	// first, compare list of files from parent server with local files
	// if our local files has something the parent server doesnt have
	// it was probably deleted. so we need to unset it from the node object
	// when it gets passed back through node_save, cck should delete it proper
 
	if ($node->nid) {
 
		$current_files = node_load($node->nid);
 
		if ($current_files && !$files) {
			// we have files locally, but none on the parent server. 	
			// remove all
			unset($node->field_floorplan);
			unset($node->field_image);
			watchdog('homes_sync', 'Remote copy of @node no longer has files. Removing all local files for @node.', array('@node' => $node->title), WATCHDOG_NOTICE);
		} elseif ($current_files && $files) {
 
			// build comparison arrays
 
			foreach ($files as $remote_file) {
				$remote_files[] = $remote_file['filename'];	
			}
 
			foreach ($current_files->field_floorplan as $local_floorplan_file) {
				$local_files[] = $local_floorplan_file['filename'];
			}
 
			foreach ($current_files->field_image as $local_image_file) {
				$local_files[] = $local_image_file['filename'];
			}
 
			// now lets see whats missing
 
			if (is_array($local_files) && is_array($remote_files)) {
 
				foreach ($local_files as $local_file) {
					if (!in_array($local_file, $remote_files)) {
						// parent site does not have this file in the node anymore
						$files_to_delete[] = $local_file;
					}
				}
 
				if (!empty($files_to_delete) && is_array($files_to_delete)) {
					foreach ($files_to_delete as $key => $file_to_delete) {
						// CCK field arrays exist in node objects even if they have no data
						// we can assume if the first record is NULL, there is no data
 
						if ($node->field_floorplan[0] != NULL) {
							foreach ($node->field_floorplan as $file_key => $floorplan) {
								if ($file_to_delete == $floorplan['filename']) {
									watchdog('homes_sync', '@file file does not exist on parent server anymore for @node. Removing.', array('@file' => $floorplan['filename'], '@node' => $node->title), WATCHDOG_NOTICE);
									unset($node->field_floorplan[$file_key]);
								}
							}
						}
 
						if ($node->field_image[0] != NULL) {
							foreach ($node->field_image as $image_key => $image) {
								if ($file_to_delete == $image['filename']) {
									watchdog('homes_sync', '@image image does not exist on parent server anymore for @node. Removing.', array('@image' => $image['filename'], '@node' => $node->title), WATCHDOG_NOTICE);
									unset($node->field_image[$image_key]);
								}
							}
						}
						unset($floorplan);
						unset($image);
					}
				}
 
			}
		}
 
		unset($remote_files);
		unset($local_files);
	}

Now that we are through with our deletion process, we can begin processing the remote files. For each file id ($fid) we call xmlrpc and get all the data and the file itself and bring it down to our local site. Based on the file extension, we begin building a query so we can look to see if this file exists locally, and what its last timestamp was. We do this so we know if a file should be replaced or not. For example, if you have MyHome.PDF on your local site, and a new version is uploaded on the remote site, simply comparing file names is not good enough. With a filename and a timestamp comparison, you are certain that it should be processed.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

	if ($files) {
 
		foreach ($files as $fid => $remote_file) {
			$file = xmlrpc(REMOTE_SERVICES_URL, 'file.get', $sessid, $fid);
 
			if ($file) {
				// set filepath to save to
				// decode our content file
 
				$file['filepath'] = file_directory_path().'/'.$file['filename'];
				$file_data = base64_decode($file['file']);
 
				// set content type db table, and field to search on.
				// Load up the CCK field
 
				$filetype = explode('.', $file['filename']);
 
				if ($filetype[1] == 'pdf') {
					$content_table = 'content_type_homes';
					$fid_field = 'field_floorplan_fid';
				} else {
					$content_table = 'content_field_image';
					$fid_field = 'field_image_fid';
				}
 
				$file_details = array();
 
				// check if it's the same file coming over
				// only applies if the node exists in the first place. otherwise its a new import on a new home
				// if there is a file match we dont want to do anything but skip the creation
				// i think if you dont keep the node->file field prefilled, and returns those fields empty, it causes the file deletion on the server
 
				if ($node->nid) {
 
					$result = db_query("SELECT f.filename, f.fid, f.filepath, f.timestamp FROM {files} f
											INNER JOIN {%s} ctype ON f.fid = ctype.%s
										WHERE f.filename = '%s'", $content_table, $fid_field, $file['filename']);
 
 
 
					$file_details = db_fetch_array($result);
 
				}
 
 
 
				if ($file_details && $file_details['timestamp'] < $file['timestamp']) {
 
					// if file exists and has not changed remotely, skip it
 
					watchdog('homes_sync', '@file already exists for @home. Skipping.', array('@file' => $file_details['filename'], '@home' => $node->title), WATCHDOG_NOTICE);
 
				} else { 
 
					// save file
					// REPLACE because we can be certain we will not have duplicate files
					// so we will only ever receive unique ones here
 
					file_save_data($file_data, $file['filepath'], FILE_EXISTS_REPLACE);
 
					//write record in files table
					drupal_write_record('files', $file);
 
					$result = db_query("SELECT fid,filepath FROM {files} WHERE filename = '%s'", $file['filename']);
					$file_details = db_fetch_object($result);
 
					$file_data = field_file_load($file_details->fid);
 
					watchdog('homes_sync', 'Uploaded @file into @home.', array('@file' => $full_file['filename'], '@home' => $node->title), WATCHDOG_NOTICE);
 
					if ($file_data) {
 
						if ($filetype[1] == 'pdf') {
							$node->field_floorplan[] = $file_data;
						} else {
							$node->field_image[] = $file_data;
						}
 
					}
 
				}
 
 
			}
		}
	}
 
	return $node;
}

After the file is saved to the file system and database, field_file_load() is called to load the file data. With a populated array now, we can add that to our node object by simply putting $node->field_floorplan[] = $file_data or $node->field_image[] = $file_data to append the existing array with data. The $node object is returned, and node_save($node) is immediately called, and our node data and file data are saved. Just like that, we have a simple content distribution system from one parent site to potentially many remote sites.

This is just a simple example, your mileage may vary. We are utilizing this technology to hook companies together under different Drupal installations on different servers. Using Services you could also distribute Views configurations, users, and system settings.

Up to that point, we had done every project in Coldfusion hosted on Windows (and eventually Linux). There is a price tag that came with that though, whether it be hosting, Coldfusion licensing/upgrading, or development costs. As people were let go due to the economy, we also realized that it is difficult to support proprietary code for a proprietary solution someone else wrote. Why? Because that person is the only person in the world who knows why they made the application/code that way. When something goes wrong, you spend hours trying to find the issue, and even more time coming up with a tested reliable solution.

Proprietary solutions are sold as the best thing since sliced bread, but what customers don’t know is that they are getting locked in to that company. You can’t easily cut ties with a firm and take your site someplace else. Proprietary applications are the brainchild of whoever developed it. Therefore, when you need support, you won’t get it. That developer is long gone, but you are stuck with their code. These firms put you in a box and want to keep you there- that is the whole point of proprietary systems. Why do you think you can’t install OSX on a PC? Why do you think video games are built only for Windows, and not Linux or Mac? It’s all about client retention.

With that, we decided to start fresh and drop our proprietary Coldfusion CMS and Ecommerce platforms. Everyday we were tied up in fixing Inclind Commerce, or trying to meet the needs of each client for Inclind CMS. Pete and I went as fast as we could, but we pretty much knew there was no way to compete with the rest of the world. We turned to open source solutions to provide us a solid base to build off of, instead of starting each project from scratch (which all essentially had the same core functionality as it were). Developing Coldfusion in Fusebox framework is/was an absolute nightmare and probably still is. It is a disjointed unauthentic implementation of MVC style framework despite what they say, and requires you to hold its hand every step of the development process.

We knew Wordpress would not be a solution at all. At best, it is a blogging platform and nothing more. You may read lots of articles that say how awesome Wordpress is and is a CMS, but it is not a CMS. You’ll also see that those articles are written by designers too, not developers. It’s a pain in the ass to develop for, it has patches every other week, plugins are prone to XSS attacks or theme hacking, and cannot sustain the level of development we perform. It is not a prime-time application for websites.

We also tried Joomla. Knowing it was based around Mambo, my expectations were low for it based on the experience I had working with Mambo. Even 5 years later, it had an ugly backend, scattered developer community, and little support. The developer area is full of confusing rules, practices and jargon. Take this for example, from the Joomla extensions page:

• Component – Mini-application to render the main page body.
• Module – Renders small html blocks on any page.
• Plugin – Changes code behavior dynamically.
• Language – Provides language translation.
• Ext. Specific Addon – Specific addon that requires another ext. to operate.
• Tool – External application that helps with creating or managing Joomla! site.

What the hell is the difference? All 6 bullet points say the same thing, yet they are 6 different kinds of extensions for Joomla. We couldn’t see ourselves training clients around the confusing backend or having lowered development time with their overly complicated extension system and scary licensing rules.

We came to Drupal. I had heard about this one on and off in various circles, generally more good than bad. After a week of successful proof of concepts for different kinds of websites, we decided Drupal was the best solution for us in terms of what we needed to accomplish.

Out of the box, Drupal provides:

• Database abstraction
• Auto-discovery of custom modules
• Managed workflow
• Robust Development API
• Experienced and organized developer community
• Intuitive administrative backend
• Easy integration of custom modules through the hook system

There is a solution for just about any scenario in the Drupal world. They have a very good approval process for modules. For example, if a module has security loopholes or bad coding practices, it will not be accepted until those are corrected (I don’t see this happening in other projects). If someone is trying to submit a module that already exists in some form, they are encouraged to merge efforts so the community isn’t littered with duplicate modules with the same functionality. It is differences like these that make Drupal the most widely used, highly regarded, best open source CMS bar none.

Our choice was the right one, proving vital in our relevance to custom web development and is a reason why we are still here and still the top choice for web design / web development / website building on the peninsula. We are able to deploy websites with a consistent codebase and backend in rapid succession. Clients are pleased with the added functionality and easier administrative UI. We’re at the point now where we can take Drupal and make it do anything we need it to do, big or small. We’ve been able to provide scalable solutions from the collaboration of many people providing a solid product. Instead of a couple of people making an in-house solution, we’re working with hundreds on a more polished result. We changed our entire development process so we could have a streamlined workflow and tighter communication between ourselves and the client with great results.

We have some pretty cool projects in the pipeline for 2010 utilizing Drupal and hope to have some things to show off in the next few months. iPhones, region-free real estate integration, content distribution, big boy stuff. Lookout.

We’re kick starting this year with some website launches and the hiring of web developer Matthew Oseland. Matthew came to us eager to collaborate on the cool stuff we work on and has a strong background in web development.

There are a handful of ways to do this. One way would be to create an external database connection, talk to it, and update the data in our database through raw PHP. But that’s not really good, not to mention slow, and also very un Drupal.

Another way would be to utilize Domain Access, and publish content to affiliated sites. That works in some cases, but what if these sites are independent from each other with different companies managing them? You would then have the nightmare of dealing with prefixed tables, back-end training issues, and the occasional node overlap from misconfiguring Domain Access.

A third way would be to utilize FeedAPI (or its successor, Feeds), to read from an RSS feed. Then you could parse and import that content at regular intervals. Sounds great, but if you plan on importing custom node types that have extensive CCK fields, files and images, prepare to sit down and code plugins and parsers galore to support CCK as data sources to target.

The third way is the one I thought I could get working. It seems so simple in theory that you can create an RSS/XML/JSON data structure with Views, and then tell Feeds to take that feed and parse it. True, it works if you are using a basic content type like Story or Page, but all bets are off once CCK comes into play- and who doesn’t use CCK these days? Hats off to Alex Barth / Development Seed though on Feeds, its a great start and sure to grow into a monster data consuming module. I do want to use for future projects, just not for this function.

One way that most people are not aware of is to take advantage of Drupal’s XML-RPC functions through the Services module. In short, the Services module provides:

A standardized solution of integrating external applications with Drupal. Service callbacks may be used with multiple interfaces like XMLRPC, JSON, REST, SOAP, AMF, etc. This allows a Drupal site to provide web services via multiple interfaces while using the same callback code.

So, then we got the idea to have the ‘master’ Drupal site act as a SOAP server with the Services module, and provide our own custom services in order to get the job done. This runs once an hour, requires no user interaction, fails silently, and only requires two modules. Effectively, it also allows us to not have to use:

• Domain Access
• FeedAPI/Feeds
• Multi-site Setup

The benefit of this is every site can run independently from one another and be customized various ways, while still receiving key content from the parent website. Thus is the beauty of XMLRPC/SOAP.

The next part was to create my own custom method so I can request a list of node ID’s from the parent server. There is no method of getting all node ID’s out of the box, but you can easily create them. Here is what I came up with:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

<?php
 
// CODE ON PARENT SERVER
 
function homes_service_service() {
	return array(
		array(
			'#method' => 'node.getAllHomes',
			'#callback' => 'homes_service_node_get_all_homes',
			'#return' => 'array',
			'#help' => 'Return a list of node id\'s that are of the Home content type.',
		),
	);
}
 
function homes_service_node_get_all_homes() {
	$result = db_query('SELECT nid FROM {node} WHERE type = "%s"', 'homes');
 
	while ($home = db_fetch_array($result)) {
		if ($home['nid']) {
			$homes[] = $home['nid'];
		}	
	}
 
	return $homes;
}
 
// CODE ON REMOTE SERVERS
 
function homes_sync_get_node_list() {
 
	// user authentication code here
	// connect as 'services' user with 'services' role
	// that way, drupal permissions are respected
 
	// user.login method used
	// we get a successful login if the return is an array and the array values match our login information
        // this needs a little more work so the parent server knows exactly who is requesting information       
 
	$user = 'user';
	$password = 'password';
 
	$authenticate = xmlrpc('http://upgrade.beracahhomes.com/services/xmlrpc', 'user.login', $user, $password);
 
	if (is_array($authenticate) && $authenticate['user']['name'] === $user && $authenticate['user']['status'] == 1) {
 
		$node_ids = xmlrpc('http://www.parentsite.com/services/xmlrpc', 'node.getAllHomes');
 
		if (xmlrpc_error()) {
			$error = xmlrpc_error();
			watchdog('homes_sync', 'Error getting node list from parent server. Error: @error.', array('@error' => $error), WATCHDOG_CRITICAL);
		} else {
			foreach ($node_ids as $nid) {
				$nodes[] = $nid;
			}
			variable_set('parent_home_nodes', $nodes);
			watchdog('homes_sync', 'Successfully retrieved node list from parent server.', array(), WATCHDOG_NOTICE);
		}
	}
 
	homes_sync_perform_update();
}
 
function homes_sync_perform_update() {
 
	$node_ids = variable_get('parent_home_nodes', 0);
 
	foreach ($node_ids as $nid) {
		$data = xmlrpc('http://www.parentsite.com/services/xmlrpc', 'node.get', $nid);
 
		$result = db_fetch_array(db_query('SELECT n.nid, n.title, n.type FROM {node} n WHERE n.title = "%s" AND n.type = "%s"', $data['title'], 'homes'));
 
		if (xmlrpc_error()) {
			$error = xmlrpc_error();
			watchdog('homes_sync', 'Could not perform XMLRPC request. Error: @error.', array('@error' => $error), WATCHDOG_CRITICAL);
		} else {
			if (is_array($data)) {
				$node = "";
 
				if ($result && $result['nid']) {
					$node->nid = $result['nid'];
				}
 
				$node->type = $data['type'];
				$node->uid = 1;
				$node->status = $data['status'];
				$node->created = $data['created'];
				$node->changed = $data['changed'];
				$node->comment = $data['comment'];
				$node->promote = $data['promote'];
				$node->moderate = $data['moderate'];
				$node->sticky = $data['sticky'];
				$node->tnid = $data['tnid'];
				$node->translate = $data['translate'];
				$node->title = $data['title'];
				$node->body = $data['body'];
				$node->teaser = $data['teaser'];
				$node->format = $data['format'];
				$node->name = $data['name'];
				$node->data = $data['data'];
				$node->path = $data['path'];
				$node->field_type[0]['value'] = $data['field_type'][0]['value'];
				$node->field_number_of_bathrooms[0]['value'] = $data['field_number_of_bathrooms'][0]['value'];
				$node->field_number_of_bedrooms[0]['value'] = $data['field_number_of_bedrooms'][0]['value'];
				$node->field_number_of_floors[0]['value'] = $data['field_number_of_floors'][0]['value'];
				$node->field_square_footage[0]['value'] = $data['field_square_footage'][0]['value'];
 
				node_save($node);
 
				unset($node);
			}
		}	
	}
}
 
function homes_sync_cron() {
	homes_sync_get_node_list();	
}
?>

For some reason, I can’t have two instances of wp-syntax in a single post, so bear with me. The above code is part of two seperate modules, one on the parent server, and one on the remote server (as notated with the PHP comment).

The module code (after CODE ON PARENT SERVER) resides on the parent server. This uses hook_service to talk to Services, and says expose node.getAllHomes as a request. That request method then calls the homes_service_node_get_all_homes function, which does a SQL query returns an array of node id’s that I am looking for.

I could easily return all nodes as their full node objects, but for performance reasons, I’d rather get a short list and save them on the receiving end. That way, I can create/update a handful at a time instead of all at once, which lightens the load on the database and application server.

On the receiving end, we need some code that creates the request that is sent to the parent server. Using hook_cron, I can send this request on an automated basis. The module code (after CODE ON REMOTE SERVERS) looks for the node list locally, and constructs single requests to retrieve node data one at a time. From there, it constructs a node object and saves it all with node_save. If the node already exists, based on type and title (our node ID’s will not match, but our title certainly will, since child sites cannot create or edit these nodes) it grabs the node ID from the local database and puts that in with the node object. node_save is a great function that can handle creating or updating data with the same structure. So, if the update runs again and passes us the same data, it will recognize it already has it, and update the record instead of create duplicates. Slick.

So what do we have? If we deploy the remote code on multiple remote sites, they can all sync up specific content with the parent website without anyone having to do anything special. So long as the parent site admin provides content, everyone will get it.

This is a quick implementation of course. I am fleshing out the authentication further as well as staggering the amount of data updated every cron run. With the core functionality in place, I can focus on security and speed. The next step is retrieving files and images using the same methods, and I will go over that in another post when I get a chance.

I hope fellow Drupalers found this useful, because I found that documentation on this is touch and go (and probably a reason not many utilize XMLRPC/Services). It’s a very powerful feature.