Last year, I did a series on how to protect yourself and your privacy online, with the biggest issue being sites like Facebook. The instructions helped a lot of people, but were soon out-dated since Facebook released updated security controls and privacy settings to make the process even easier. I still had several people seeking advice for handling cyber stalkers, which is still an ongoing issue with the internet, and one that the courts have decided falls under “Free Speech” (however, a “public figure” of sorts filed this case after he had a falling out with a friend).

However, last year, I also used various pieces of technology to lose nearly 30 lbs over 6 months, without taking any medication. All it takes is an awareness of what you’re doing, what you’re eating, and an understanding of what your body is telling you.

My goal last year was to lose 100 lbs in 12 months, in preparation for my wedding. However, the closer it got to the wedding, the less time I had to keep it up, and I relapsed. This year, I take it from the top again, and document what types of technology I’m using, what things I’m doing, and how you can do it too. Everything I’ll be doing will have to fit into a 40 hr work week, with family events and 7-8 hours of sleep each night – so this will be a completely realistic routine for anyone to follow – if they make it a priority, like watching sitcoms, playing video games, and going out. The realistic target weight-loss is about 5 lbs a month. Too slow and it seems pointless, too fast and it will all come back.

If you’re starting a weight-loss goal this year, then I’ll leave you with the #1 tip for doing it: KEEP MOVING. If you’re moving, you’re burning calories, whether it’s walking, running, climbing steps, whatever…just keep moving.

Be looking for posts this year with tips, ideas, technologies, and my progress updates. I’ll also be interested in hearing any other tips that people want to share.

Technorati Tags: forecast, slim-down tech, update, weight-loss

There are two methods of doing the editing, depending on the Yahoo! Store platform that you have. If you’re on the Legacy version, you must go to the page itself, and click edit. This provides you with a series of fields and input boxes for each type of field. No intelligence in the design of what those fields are for or differentiation in how they interact.

If you’re on the Merchant Solutions platform, then you have the option of going directly to the page still, or you can do it in a flat-file pseudo database-like UI which is nothing more than a search-by-field interface, which presents you with a different-looking (but still the same) interface for editing the page.

Over the next few months, I’m going to embark on a web-based interface for importing the legacy store feed (objinfo.xml, which can’t be customized) and see what can be done with the data as far as modifying it, preparing it, cleaning it, and exporting it back to the store. I’m also going to attempt to code it entirely using Kodingen.com. I’ve done a highly customized version of this concept for the company I currently work for (at the time of this post), but none of the code will be reused from that project, and this project will have different, and limited features (in some areas, and expanded in other areas), but for a different data model. In some areas, this application will be more limited (since it’s working with a standardized data format, rather than a customized “catalog.xml” feed from Merchant Solutions. Once this basic version is solid, I may start working on a customized version, or even offering a customizing service to handle the catalog.xml file.

Some things I’d like to do differently with this basic version is:

• create an install process (a la phpBB)
• extensive automation, and possibly some AI concepts
• learn more about object-oriented design and how it can be extended conceptually
• experiment with some various php and javascript frameworks

There are plenty of other feature sets that I’ve learned and developed in addition to these in the past and plan to use as well. So we’ll see how this goes, and I’ll post some updates here. Depending on what I plan to do with it, I may or may not open-source it. If I do, I’ll host it on Google Code.

Technorati Tags: ajax, catalog.xml, Coding, jasper, JavaScript, kodingen.com, MySQL, objinfo.xml, PHP, Programming, yahoo store platform, yahoo! stores

Until now.

Our current order management software runs as a MS Access front-end to a MSSQL 2005 server backend through and ODBC DSN connection. This connection has been limited to MS Access and MS Excel application/queries, and thus, was the limiting factor to writing this most-complex cleanup process into Jada. The most difficult part in my development was finding an understandable article describing how to make an ODBC call, and then actually get the data back, in the same simple manner that one makes a MySQL query. The real issue has been once the connection is closed, the result cannot be accessed. I had to find that out the hardway, via Microsoft’s convoluted documentation on using ODBC.

Here’s the code I’ve used to make the ODBC connection in PHP (unfortunately my blog’s template can’t handle actual code right now):

Code Breakdown

We’ll start creating a function that makes an ODBC connection, passes it an SQL query, then parses the data into a table/array and return the array.

Function call

function odbcQuery($sql, $attempt="") {

When we call the function, we’ll provide the SQL Query we want executed, and an optional description of what we’re trying to do with the query. In this way, if it errors, an semantic error will be displayed along with the technical one to help locate the code easily.

Database Connection

// Establish an odbc connection with the database
$link = odbc_connect("My_DSN_Name", "", "");

When running odbc_connect() it takes 3 parameters:

• the DSN; Server,Port; or Server/SQLInstance
• username
• password

When connecting using Windows Authentication & a DSN (as this example is about), there are some caveats and things to remember:

1. On the web server, the User running the Web Service process needs to be a User with permission to access the SQL Server.
   1. In my case, the user running the web server is SYSTEM, and so the user trying to access the SQL server is “DOMAIN\COMPUTERNAME$“.
   2. There is no password for a SYSTEM account, and so on the SQL Server needs to have a user created named “DOMAIN\COMPUTERNAME$“.
   3. Due to some security concerns, I’ve decided to give the account read-only access to the database I want to access. You’ll need to consult your own IT Administrator or security advisor for your security concerns.
2. In the odbc_connect() statement, you then only need the name of the DSN (which I assume has already been configured on the Web Server you’re using) , followed by two null-quotes: “”.

This creates an active link via ODBC to the SQL Server…supposedly

Database Connection Checking & Error Handling

if (!$link) {
	die('Could not connect: '.odbc_error().': '.odbc_errormsg());
} else {

Next, we check the link . If it just flat-out doesn’t exist, then we kill the program, throw an error message that will read: “Could not connect: <insert odbc error code>:  <insert odbc error text>”. Otherwise, we move on…

Sending the SQL Query & Checking Response

$data = odbc_exec($link, $sql);
if($data === false) {
	echo "ODBC Query: ".$sql."<br /><br />";
	die("ODBC Query failed:  ".$attempt."<br />Error: ".odbc_error());
} else {

Now that we have a valid link to the database, we’ll send a request for data using the odbc_exec() function. This function sends the connection resource ($link) and the SQL Query we want run ($sql). It will return a “ODBC result identifier” or false.

Since a result identifier could, I assume, be the number 0 (zero) I want to ensure that $data is actually false and not just zero. That’s where the triple === comes in. When doing conditional statements, using == will convert the data being compared into a true/false value, where zero or nothing = false and anything else = true. When you use === you test for an actual boolean value, meaning anything including zero = true and false = false.

If the query failed, and resulted in a false result, we’ll display an error message: “ODBC Query: <insert actual SQL Query> // ODBC Query failed: <insert query description> // Error: <insert ODBC error code>”. Otherwise, we’ll move on…

Parsing the Query Results – Column Headers

// Initialization
$row = $fields = $records = $result = array(); 	

// Get the result's column names
$count = odbc_num_fields($data);
for($x=1;$x<=$count;$x++) {
	$fields[] = odbc_field_name($data, $x);
}

We start off by initializing all the variables we’re going to use in the next bit of code, to make sure they’re empty.

Then we’ll run odbc_num_fields() over the $data to get the number of columns we need to iterate through. For columns, the counting starts at 1, so the for-loop starts at 1.

Iterate through each column name and add it to an array, called $fields:

Array (
	[0] => field_name_1
	[1] => field_name_2
	[2] => field_name_3
)

Parsing the Query Results – Records

// Get the result's data: array[record#][column#] = value
$count = odbc_num_rows($data);
for($x=0;$x<$count;$x++) {
	odbc_fetch_into($data, $row, $x);
	array_push($records,$row);
}

Then we run odbc_num_rows() over the $data to get the number of rows we need to iterate through. For rows, the counting starts at 0, so the for-loop starts at 0.

Iterate through each record row and insert it to a temporary array $row using odbc_fetch_into(). Then take $row and put it into an array of records, $records giving you something like this:

Array (
	[0] => Array (
		[0] => record_1_column_1
		[1] => record_1_column_2
		[2] => record_1_column_3
	)
	[1] => Array (
		[0] => record_2_column_1
 		[1] => record_2_column_2
 		[2] => record_2_column_3
  	)
	[2] => Array (
 		[0] => record_3_column_1
 		[1] => record_3_column_2
 		[2] => record_3_column_3
  	)
 )

Making the data useable

Now that we’ve got two tables/arrays of data – the field/column names, and each record’s array of data – it’s time to make it usable in a format that we can consistently expect to be returned. There are two ways to do this. We can create an array listind every record as an array with column_name keys and values

// Return data in the format: array[record_id][column_name] = value
foreach($records as $rid => $record) {
	foreach($fields as $key => $name) {
		$result[$rid][$name] = $record[$key];
	}
}

or we can list every column as an array of record id’s as keys and values.

// Return the data in the format: array[column_name][record_id] = value
foreach($fields as $key => $name) {
	foreach($records as $record) {
		$result[$name][] = $record[$key];
	}
}

Personally I find the first option to be more consistent with my results when calling a 2-dimensional result from MySQL queries, so it is the one I have gone with in my example at the start of the post, and in this description.

The foreach() statements describe a compilation of a $result array in this manner:

1. For each item in the $records array, store the record_id as $rid, and the record array as $record.
2. Then for each item in the $fields array, store its cardinality as $key and it’s value/name as $name.
3. Then compile an array, iterating through each of the fields, storing this $record‘s associated cardinality $key‘s value into the $result array’s storage for this record’s id ($rid) under the appropriate field name.

It’s a lot easier to grasp than it sounds. Basically, take array from the Query Results – Records section, and replace the # with the column name in each: [#] => record_y_column_x, but store it as a different array, called $results. The resulting array would look something like this:

Array (
	[0] => Array (
		[column1] => record_1_column_1_data
		[column2] => record_1_column_2_data
		[column3] => record_1_column_3_data
	)
	[1] => Array (
		[column1] => record_2_column_1_data
 		[column2] => record_2_column_2_data
 		[column3] => record_2_column_3_data
  	)
	[2] => Array (
 		[column1] => record_3_column_1_data
 		[column2] => record_3_column_2_data
 		[column3] => record_3_column_3_data
  	)
 )

Close the connection, Return the result

		odbc_close($link);
		return $result;
	}
}

Now that we’ve stored the data we need from the volatile $data variable returned from the SQL Query into $result, we can close the connection to $link using odbc_close(), and then return $result for the program to do with it what it will.

Conclusion

This is just an example code that explains one way of many to extract a variable 1-2 dimension array of data from your SQL Query, using a Windows-Authenticated ODBC DSN connection. There are many other methods to do this, as well as security fixes, data scrubbing, and other modifications that one would probably want to do.

This is the first function I’ve written in any language to access an SQL Server via ODBC. This is also a function that has worked in tests, but that I have not yet put into production. I encourage you to take this bit of explanation and massage it into something that fits your needs in the code that you’re writing, and don’t rely on what I’ve got here as a written-in-stone example of good production-level code. This sample will change many times before I actually implement it.

Happy Hacking!

Technorati Tags: how to connect to sql server in php with odbc, microsoft odbc, microsoft sql server, mssql, odbc, odbc connection, PHP, php odbc connection, sql, sql server odbc connection, windows authenticated odbc, windows authenticated odbc connection, windows odbc connection

Source: dayoldcake.com

Since I started using a WordPress blog back in 2005, I’ve always had the Akismet WordPress plugin installed, and it was the sole provider of my spam protection. It has done an awesome job with an at-this-moment 99.843% accuracy rating, and has blocked 21,215 spam comments of which 6,686 of them were just in the last 6 months.

About a week ago, I found an additional spam blocking plugin that has also been very helpful. This one is called Bad Behavior.

In my observations over the last couple months, it appears that Akismet will block a comment that doesn’t seem to have any correlation to the content of the blog post. This would be why you see posts in your Spam queue that contain no links, no really harmful URLs, and just random text or pointless statements in the body of the comment. I’m sure Akismet is much more complicated than that, though, and I would assume there is a backend database of known spamming IPs/Hosts out there that it may also check against. However, the simplest, and likely initial method of detecting spam is via content.

Not with Bad Behavior. Instead of checking the content of the spam, it looks at the stuff you can’t see – the HTTP Headers, IP, User-Agent String, etc. From their own website…

Bad Behavior analyzes the HTTP headers, IP address, and other metadata regarding the request to determine if it is spammy or malicious. This approach has proved, as one user said, “shockingly effective.” After all, spammers write their bots on the cheap, and have little incentive to code very well. If they could code very well, they probably wouldn’t be spammers.

When Bad Behavior looks at a request, it determines if the request matches a profile of known malicious or spammy activity, and falls outside the bounds of a normal human browsing the web. If so, the request is blocked. But a way out is provided for any human beings with unusual configurations or viruses/Trojans on their computer who may be blocked.

Source: How Bad Behavior Works

Here’s an example of some of the content it has blocked from this very blog…

The image above is using a User-Agent string that includes the Windows version “Windows XP”. Anyone who has done their homework, and makes up a User-Agent string knows that Windows XP is actually Windows NT 5.x where X is the Service Pack number applied. Since Windows XP is not a valid User-Agent String (even though they went to so much trouble to include all the other information in the header), it was blocked.

With this image, the plugin saw that the header was missing the “Accept” statement, telling the server receiving the request what types of files it was willing to accept as a response. Most of the attempts to bot-post that I have seen blocked in the past week or so have been this type of error.

According to the Bad Behavior Benefits and Features page, the plugin runs before any of your PHP-based software (yeah, that’s right, it is available for any PHP-coded site, not just WordPress blogs), so your server never has to respond to a bot just “harvesting data and delivering junk.” Instead the bot is given some 400-style error, and never gets a response from your site.

There are more features and settings that I haven’t had a chance to play around with yet, but if I find it necessary, I’ll create an additional post or add them to this one. I recommend this plugin to go alongside any other spam protection you have in place on your form-driven website or blog.

Technorati Tags: akismet, bad behavior, spam control, spam protection, wordpress plugins

I ran across several Astaro User Forum posts telling people the same things over and over about what to check, and none of it was helping.

I’ll try and give a run through of some error message appearances from the Fallback error log, and what you should do to fix them. If you have more, leave them in the comments below, and I’ll add them.

ads_get_dnshostname: No dNSHostName attribute!

You need to make sure you have a Host Name specified in the FQDN style in the Management > System Settings > Hostname tab

ads_keytab_add_entry: unable to determine machine account’s dns name in AD

• You need to make sure your Astaro box doesn’t show up as a Computer listed in Active Directory anywhere there are computers listed, then you need to make sure there is a DNS Host (A) entry for your hostname, and also you need to reboot your Active Directory and/or DNS server. (For me, they were the same Windows SBS Box, but a reboot fixed this error message.)

»clock skew too great«

• You need to make sure the Time & Date on both the Astaro box and the Active Directory server are no more than 5 minutes apart.

»pre-authentication failed«

Make sure the Username/Password you're using to join the domain are correct. They should look like the image above.

Below is the fix that finally worked for me, but I never saw anything in the User Forums (or anywhere else, for that matter) related to these error codes and the Astaro box (only to Samba and Linux Servers).

libsmb/clientgen.c:cli_receive_smb

rpc_client/cli_pipe.c:rpc_api_pipe

pipe \lsarpc fnum

• This means that the Intrusion Prevention System is preventing the Active Directory server from approving the Active Directory join. You need to create an Exception like this:

Go to Network Security > Intrusion Prevention > Exceptions and create a new Exception that Skips "Intrusion Prevention" and list the Active Directory Server in the Source Network area.

I’m sure there are probably more items in the Fallback error logs that folks have encountered. Surprisingly, I didn’t even come across this PDF document detailing a lot of them during my searches until I was researching the error codes for this post. Check that document out and see if your answer is in there.

The main rebuttals from most of the “suggestions” you’ll find on the User Forums are:

1. You don’t need to create a Pre-Win2000 Computer in Active Directory for this to work.
2. You can’t have an existing computer entry in Active Directory for the hostname you’ve given your Astaro box.
3. You should create a DNS Host (A) entry for the Astaro box, if you run a DNS server outside of the Astaro box
4. The Time & Date on both the Server and Astaro Box need to be within 5 minutes of each other.
5. You don’t have to be able to ping the Astaro box from the server for this to work.
6. You do have to be able to ping the Active Directory server from the Astaro box’s Support > Tools area
7. Domains ending in .local will work.
8. You don’t have to use all CAPS when filling in the hostname  & domain name, but it’s suggested by the Astaro people. It won’t make a difference to DNS – CAPS or lowercase both resolve the same.

As I mentioned above, if you have any other error messages or tips or suggestions, etc., related to getting the Astaro box on the domain, please post them in the comments. Too many people have spent too long trying to get things to work simply because the information wasn’t out there when they were searching.

Technorati Tags: active directory, ads_get_dnshostname, ads_keytab_add_entry, ASG 120, astaro, astaro sg 120, authentication, can't join domain, clientgen.c:cli_receive_smb, cli_pipe.c:rpc_api_pipe, clock skew too great, Fallback logs, Intrusion Prevention, joining domain failed, Kerberos, pipe \lsarpc fnum, RPC, rpc_client, Samba, SSO astaro

Credit: Paul Mutton

I’ve run an online community for nearly a decade now – and many spin-offs and other projects & even job opportunities have been the result of what I’ve learned while working on my websites.

I started everything when I was 18, with the help of a few friends in the college dorms at ETBU back in 2001, and from there things grew exponentially by word of mouth, until at its peak we had most of Nacogdoches High School in Nacogdoches, TX on the website. There were users in  about 7 different countries, all over the United States, and it was the start of the Social Networking concept.

Myspace came along, and then Facebook, and now things have slowed down quite a bit, as everyone has grown up and moved on with their life. The site is still home to a dedicated few that host their Journals there (which we started before the invention of blogging software).

But I find myself less and less interested in keeping up with it – and it’s a little sad after all thoughts I’ve posted on it, the ideas that others have contributed that changed the course of my life, all the long nights writing code, and just many days at work coming up with ideas & features. That huge time investment is also the reason I’m not all that crazy about re-investing so much time into getting it going again.

The site was cutting edge for its time, and we were on the forefront of the popular technologies before they were popular (video casts, podcasts, internet radio, blogging, social networking, etc). It was quite literally The Spot you wanted to be, and we put a lot of effort into making the atmosphere of the community match that branding.

These days I’m interested in learning new things (as many of the old things I’ve built most of my sites around are being phased out). Myspace is all but gone from the minds of many internet socialites, and Facebook is reaching its Myspace pinnacle. In another 2 years, it will have gone by the wayside just as Myspace did. Twitter is also growing much faster than it expected, and as it keeps evolving out of what it originally was by adding new features, the simplicity of its design will live on, but in another application most likely.

As such, I’m considering finally implementing a domain I’ve held on to for a long time – the-blot.net, and the-blot.com – which were originally intended to be a one-stop blogging service where you can post to any of your blogs, and also read from any of your friends blogs all in one place. That idea was solved in part by Google Reader and Ping.fm’s posting abilities.

So instead of making it just about your blogs, I am going to grab the alpha version of the Diaspora project and start up another social networking site to see what kinds of technology are being implemented in the next generation of social clustering sites. I’m going to have to build a new Linux server & redirect my domains, as well as compile their website codes, so all of this could take a while (as I have to salvage several different computer parts for the server). But as I transition to new technologies, I’ll keep track of the changes here, just as I did when I upgraded the-spot.net from the early days of the static html tsnII to the cutting edge dynamic tsnIII back in 2004.

Technorati Tags: diaspora, podcasts, Servers, social networks, the-blot.net, the-spot.net

Unfortunately, LogMeIn figured out they forgot about that page, I guess when people started reading this post and hitting it on their servers. They have removed the text status as well as all the others, and I can’t figure out why they would do such a thing.

I’m also not sure what they’re offering as an alternative either. So if you know, please leave a comment below. Thanks.

Depreciated Process…

A while back, I started a project called tsn.lcl or tsnlocal, but gave up on it when my electricity bill hit $400 in a month.

Today, I decided to fix up the domain name and get it back on the internet – at least to remove it from GoDaddy’s Parking Page – where they’re making money, not me, off of it.

When I got it published I noticed that none of the Hamachi Web Status images worked anymore, and that the link to such an image, redirected to their login page for your Hamachi Management Dashboard. However, upon further investigation, I found that there was not only an Image version of those status instances, but also a text version.

I really wanted to show the online status of all my machines again, so I wrote my own php script to parse that text data, and created some simple images to show on the website based on the returned status.

So here’s the code so you can do the same thing…

The PHP Function

{code type=php}<?php
function hamachiImg($ip) {
$url = “https://my.hamachi.cc/status/text.php?$ip”;
$status = file_get_contents($url);
$status = preg_replace(‘/\d*\.\d*\.\d*.\d* /’, ”, $status);
$image_url = “./images/$status.png”;
return $image_url;
}
?>{/code}
This code creates a $url variable with the address to the text status, based on the $ip that is passed to it. Then it requests the data, removes the ip address and the trailing space, leaving only the status text. On the server, I have a collection of images with the 4 different statuses as their file name, and with that an $image_url is created to be returned.

The 4 possible statuses are:

• – online
• – offline
• – unknown
• – error

The HTML Code and PHP Function Call

Once you have your php function in the page (I stuck mine before the first <html> tag), you can use the php function to insert the image url when you pass it an IP…
{code type=html}<table>
<tr>
<td style=”width: 100%”>[[Neo]]:</td>
<td style=”width: 100%”> <img src=”<?php echo hamachiImg(’5.37.117.104′); ?>”></td>
</tr>
</table>{/code}
Once you’ve done that, assuming you have entered a valid hamachi IP address, the results should look something like the image at right.

Technorati Tags: hamachi, images, status, vpn, Web

What happened to the Dallas Stars Twitter? They removed me from their friend list, and changed everything!

If you’re asking yourself that question…it’s not what you think. Here’s what happened – it was all a mistake…

The Backstory…

Back in the Fall of 2007, @winkydo had an idea to start broadcasting the scores during the Dallas Stars NHL hockey games. So he went to register the account for @DallasStars and from then on, he and I (@neotsn) were all about posting updates, tying in news feeds. Our updates got pretty complicated using a 1400-character if-statement to parse a collection of inputs and derived values from a database of all the NHL players, their numbers and their teams. We’d watch every game, intently focused on a 52″ Plasma HD TV so that we could see which players scored, which assissted, and get all the stats up on the internet before the official NHL Game Stats page was updated – and often before the announcers could say.

Well, that lasted all the way until the end of 2008-09 Season.

We got a message from @cfaulk, asking who was behind the @DallasStars, but because we had hidden who was behind the account, and had a policy never to reply, opinionate, or follow people with that account, we did not respond. Unfortunately, the means that @cfaulk couldn’t find us to contact us.

Why does it matter that @cfaulk couldn’t find us? Because he’s the Sr. VP of Ticket Sales for the @DallasStars, Sr. Acct Executive for the Texas Rangers, and the Acct Executive for the Dallas Burn.

What happened…

Well, while the Dallas Stars organization was trying to get information from Twitter Co. about who was running the site, they created @TheDallasStars to start their feed. All they wanted to do was ask us to remove the word “Official” from our description since there was truely an Official feed out there.

…But they never got a response from the Twitter people.

Meanwhile, I saw the advertisement on Facebook for @TheDallasStars as the “Official” Twitter feed for the Dallas Stars, and made a comment advertising the one we set up. Then I went to look into the DallasStars.com website, and in their Fan Zone menu, and pulled up their Official Facebook Fanpage – it was the same one. So then I went back to figure out who it was that asked the @DallasStars who they were, and found it was @cfaulk and found him on LinkedIn, figured out who he was there, and asked him to confirm it. He responded asking who I was, and I gave him my contact info, explained how we were using the @DallasStars profile, but didn’t hear anything back

Then, today…

When @cfaulk and company logged into their Twitter account, they noticed that all-the-sudden, the account they registered (@TheDallasStars) was now simply @DallasStars. So I got an email from @cfaulk asking to talk to us. I went and looked at the @DallasStars page to find out it had been suspended as @DallasStars_I. So we were concerned too, because we had hoped we could transfer the fanbase to the NHL Organization by simply turning over the account credentials to the Dallas Stars Organization, as well as the infrastructure we had developed…and possibly work out some kind of contract-labor situation where we could keep maintaining it for them.

This evening there was a conference call placed between @winkydo, @cfaulk, @shickdog (Sr. Dir. of Communications) and myself (@neotsn). During our conversation, we discovered that @cfaulk & @shickdog thought we ditched the account; and @winkydo and I thought they had acquired the account. But apparently Twitter did it on their own accord, probably to reduce mitigation, and just hand over the account to the copyright holder.

We were all disappointed by this because we lost the fanbase we had gained over the 1.5 seasons of tweeting. However, that’s part of the fun – and we still have 2400 (of the 2538 followers) emails telling us who is following. So we can re-add everyone as time goes by, a couple each day so we don’t get banned for adding disproportionate amounts of followers.

Essentially all they wanted to get in touch with us for was to ask us to remove the “Official” verbiage from the description on our page. They were happy that we had such enthusiasm and wanted to remain in touch, since they were just getting started in all of this social networking, and we were able to acquire the fans without their media presence.

Here’s The Breakdown…

Now we have new accounts set up, and they all have purposes, and @winkydo and I are going to be working closely with @cfaulk & @shickdog to get all this up and running again. At least, that’s the hope I think everyone had when we ended the conference call.

Here’s the twitter accounts that came out of it, and what they are:

• @DallasStars – The Official Dallas Stars Twitter account (formerly @thedallasstars)
  • Follow this acct to get Official News from the Dallas Stars Organization
  • Updated and maintained by the Dallas Stars NHL Organization’s Communications Department
• @TheDallasStars – The Fan-version Dallas Stars Twitter account (formerly @dallasstars)
  • Follow this acct to get most of the Official News, the Popular Stars Blogs, and Live Scores
  • Yes, we did clear it with @cfaulk that it would be OK with them to re-register @thedallasstars since they had our original page.
  • Updated and maintained by @winkydo and @neotsn, with Live Scores and News feeds just like before. The same Dallas Stars feed/speed you loved for the past 2 seasons, but this time, you know who’s doing it.
• @DallasStarsLive – A new Fan-version of the Dallas Stars Twitter account
  • This is ONLY Live Scores updated during the games by @winkydo and @neotsn.

Please ReTweet this, and tell all your friends about this change – so everyone can hit the ground running next season!

Technorati Tags: cfaulk, dallas stars, dallas stars twitter, dallasstars, neotsn, shickdog, thedallasstars, twitter, winkydo

My webhost says it is creating a lot of “sleeper” processes on the database server, and using up a lot of the processor resources. My account was even suspended until I fixed it.

SO – I am going to be rewriting the whole thing, pretty much from scratch now, and it will only be loosely based on Dan’s version…

Currently, the code will run through the database of posts, and find those that have shortened URLs stored for them, run a twitter search, and return/parse/store/display the resulting tweetbacks. And it does this every 5 minutes.

However, that sucks up a lot of processing power to do that, especially if you have a big blog, popular blog, or both. The Answer: A Rewrite. This one is going to run a single Twitter search for every shortened url in the database, return ALL the results once, and parse them out, store them in the database, and associate them to their respective parent posts.

So, there’s the update for why this hasn’t been released yet.

I’m also working on trying to get the retro-active TweetThis buttons working on old posts – but something isn’t working right – either it’s the original code that isn’t comparing what’s in the database to the conditional statement correctly (if this.url = “”, then make new ones), or something. It’s going to take some more testing on my own test database, since my webhost is getting antsy with all the processes I’m using.

I’ll keep everyone updated as it moves along. Thanks.

Technorati Tags: api, code, database, MySQL, Ping.fm, plugin, Programming, tweetback, tweetbacks, TweetSuite, webhost, WordPress

Sure enough, Dan Zarrella over at danzarrella.com had. He wrote one for Tweetbacks, and then expanded on it with TweetSuite. So I gave them a shot.

I started with Tweetbacks on the FreeformFrog.com Blog and everything seemed to be working fine – until one day when the Tweetbacks stopped. It just stopped finding them – even though I knew they were getting tweeted – because I was using Ping.fm to syndicate my blog posts to the appropriate social networks.

I gave it a couple weeks, and then decided I was going to fix it. I was tired of not having my TweetBacks working – especially during my efforts pushing a Social Networking campaign at job.

So, I added @danzarrella, and asked…

@danzarrella do you have plans to integrate ping.fm posting in TweetSuite? If not, mind if I take a crack at it?
from @neotsn at 4:32 PM Mar 18th from web

A few minutes later, I got a response…

@neotsn go to town
from @danzarrella at 4:34 PM Mar 18th from TweetDeck in reply to neotsn

Excellent…now I had his blessing to hack his codes. And so I have…

The download is coming soon

I have to get my Ping.fm API Key approved before anyone but me can install the plugin.

And now I present to you a general overview of what I wanted to accomplish, and how I did it. (Please note, this is a GENERAL overview with some examples – it’s not meant to be a how-to, so don’t try to just copy/paste the samples – there is much more to do than can be explained here). Let’s get started…

Objectives…

1. Make it post through Ping.fm – I syndicate all my stuff through twitterfeed.com and it pushes everything out through Ping.fm for me. Upon further investigation, I noticed that TweetSuite used its own publishing code to push out the updates – after it created its own shortened urls and attached them. So of course it would never find my updates – it didn’t know what urls to search for, because it didn’t create them.
2. Make it find my tweets that were pushed through Ping.fm – After realizing that it stopped searching for blog titles and started searching for the shortened urls as the unique identifier on the web, I realized that I needed it to create my urls and push them out with my Ping.fm update text. That was the only way to let TweetSuite know that there were tweets out there about my blog, and obtw here’s the link.
3. Clean up some of the things that were a little messy – Once I got poking around in the code, I noticed that it some parts of it were written a little redundantly, and in order for me to maintain understanding of what was going on, I needed to clean it up a little.

Let’s Code…

Well, for starters, to accomplish #1, I had to write a function that would validate the user’s app key with Ping.fm:
{code type=php}
/* [[Neo]] */
//BEGIN Ping.fm functions
function pingfm_verify() {
// request app key verification
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_URL, ‘http://api.ping.fm/v1/user.validate’);
curl_setopt($ch, CURLOPT_POSTFIELDS, Array(
‘api_key’ => get_option(‘tweetsuite_ping_api_key’),
‘user_app_key’ => get_option(‘tweetsuite_ping_app_key’)
));
$output = curl_exec($ch);
// update database with response
if (preg_match(‘/OK/’, $output)) {
echo ‘ <strong>Your key has been verified.</strong> Your can now post to your
<a href=”http://www.ping.fm” target=”_blank”>Ping.fm</a> account.’;
update_option(‘tweetsuite_ping_keyVerified’, 1);
} else {
echo (‘<strong>Your key could not be verified.</strong>.’);
update_option(‘tweetsuite_ping_keyVerified’, 0);
return false;
}
}

// END Ping.fm Functions
{/code}
Just your basic curl function to contact http://api.ping.fm/v1/user.validate and pass the api_key and user_app_key to the api, per the API Documentation on user.validate. Depending on the response, store it to the database, and display the appropriate message.

Next, I had to implement the fields to make that happen. We’ll start with the database…
{code type=php}
/* [[Neo]] */
//ADDED:
add_option(‘tweetsuite_ping_api_key’,’333333333333333333333333333333333′);
add_option(‘tweetsuite_ping_app_key’,”);
add_option(‘tweetsuite_use_ping’,0);
add_option(‘tweetsuite_ping_keyVerified’,0);
//END ADD
{/code}
This sticks those fields into the wordpress database table “wp_options” where all the config values go. My developer’s api key, a blank user application key, a field for the checkbox “Do you want to use Ping.fm?” and one for whether or not the user_app_key successfully verified.

Then I create the user interface for those fields (as well as rearrange the rest of the fields since these have to flow right to make sense…
{code type=php}
/* [[Neo]] */
//ADDED:
update_option(‘tweetsuite_ping_app_key’, $_POST['tweetsuite_ping_app_key']);
//END ADD

//tweetsuite_use_ping
($_POST['tweetsuite_use_ping']) ? update_option(‘tweetsuite_use_ping’, 1) : update_option(‘tweetsuite_use_ping’, 0);
{/code}

That part allows the database to be updated with the data from the fields below…
{code type=html}
<!– /* [[Neo]] */ –>
<!– BEGIN ADD –>
<tr valign=”top”>
<th scope=”row”>Ping.fm :: Use Ping.fm to publish new posts (via your default method)?:</th>
<td><INPUT TYPE=CHECKBOX NAME=”tweetsuite_use_ping” <?php if(get_option(‘tweetsuite_use_ping’)) { echo “checked”; } ?>>
<br /><b>["Send a Tweet when you publish" is required for this to work]</b>
</td>
</tr>
<tr valign=”top”>
<th scope=”row”>Ping.fm :: Your Ping.fm <a href=”http://ping.fm/key/” target=”_blank”>Application Key</a>:</th>
<td><INPUT TYPE=text NAME=”tweetsuite_ping_app_key” value=’<?php echo get_option(‘tweetsuite_ping_app_key’); ?>’ /><br /><?php if(get_option(‘tweetsuite_ping_app_key’)) { echo pingfm_verify(); } ?>
</td>
</tr>
<!– END ADD –>
{/code}
This is below the checkbox for “Send a Tweet when you publish a post?”…if that is checked, then if you check “Use Ping.fm to publish new posts (via your default method)?” and fill out the next field for “Your Ping.fm Application Key” then it will send your post details on Publish through Ping.fm instead of Twitter itself, appending the tinyurl associated with the post to your Ping.fm message. All this is done by editing the function that sends the tweets…
{code type=php}
function tweetsuite_send($msg) {
/* [[Neo]] */
//REMOVED:
//$prefix = urlencode(get_option(‘tweetsuite_prefix’).’ ‘);
//REPLACED:
$prefix = (get_option(tweetsuite_use_ping) and get_option(tweetsuite_ping_keyVerified)) ? get_option(‘tweetsuite_prefix’).’ ‘ : urlencode(get_option(‘tweetsuite_prefix’).’ ‘);
$msg = $prefix.$msg;

/* [[Neo]] */
//ADDED
if(get_option(tweetsuite_use_ping) and get_option(tweetsuite_ping_keyVerified)) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_URL, ‘http://api.ping.fm/v1/user.post’);
curl_setopt($ch, CURLOPT_POSTFIELDS, Array(
‘api_key’ => get_option(‘tweetsuite_ping_api_key’),
‘user_app_key’ => get_option(‘tweetsuite_ping_app_key’),
‘post_method’ => “default”,
‘body’ => $msg)
);
$output = curl_exec($ch);
} else {
//END ADD
$username = get_option(‘tweetsuite_twitter_username’);
$password = get_option(‘tweetsuite_twitter_password’);
if(($username) and ($password)) {
$url = ‘http://twitter.com/statuses/update.xml’;
$curl_handle = curl_init();
curl_setopt($curl_handle, CURLOPT_URL, “$url”);
curl_setopt($curl_handle, CURLOPT_CONNECTTIMEOUT, 2);
curl_setopt($curl_handle, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl_handle, CURLOPT_POST, 1);
curl_setopt($curl_handle, CURLOPT_POSTFIELDS, “status=$msg”);
curl_setopt($curl_handle, CURLOPT_USERPWD, “$username:$password”);
$buffer = curl_exec($curl_handle);
curl_close($curl_handle);
}
/* [[Neo]] */
//ADDED
}
//END ADD
}
{/code}
This starts off by swapping out the original urlencode() function for a conditional statement deciding if this is a ping.fm post or a twitter post. If it’s a ping.fm post, then we don’t want to urlencode() the prefix, because it sticks + signs where there should be spaces in the prefix to the title. However, if we don’t want to use ping.fm, then don’t mess with the original code.

Following that, it splits which method we used to post, based on the same criteria – make sure the checkbox is true for “tweetsuite_use_ping” and that the user’s app key is verified in “tweetsuite_ping_keyVerified”. If that’s the case, then post it through ping.fm – if any of that is not met, then go ahead and try to post it through twitter. If there is no username and password supplied on the options page, then we just won’t post anything.

Now…about the whole $msg – that part got skipped in the logic of everything. This was the tricky part, for me. Originally, I stumbled across an API Documentation page for the ping.fm method “url.shorten” and that was the very thing I needed – something to grab a ping.fm url, without passing it through ping.fm yet. However, I found out, after much frustration, that this method was mysteriously “depreciated” (which should be read as “edited off the page, and 404′d when you try to use it). But, I found another solution in the knowledgebase at Ping.fm…
{code type=php}
function ts_send_tweet($postID) {
global $wpdb;
if(!is_int($postID))
$postID = $postID->ID;

$table_name = $wpdb->prefix . “shorturls”;
$line = $wpdb->get_row(“select * from $table_name where postID=$postID”);
if($line->postID==$postID) {
/* [[Neo]] */
// ADDED: “*”.
$shorturl = “*”.$line->tinyurl;
$post = get_post($postID);
if(get_option(‘tweetsuite_send_posts’))
tweetsuite_send(trim($post->post_title).’ ‘.$shorturl);
}
}
{/code}
The article said you can prepend a * to the front of a url and it would not shorten it (in addition to the fact that they said they wouldn’t re-shorten any URLs 24 characters or smaller). So, I went with the * solution, because we’re already providing short URLs, but don’t want to risk the functionality in future updates to allow for custom url shortening services.

And that accomplishes both #1 and #2. We have the TweetSuite posting its updates through the Ping.fm API, and pushing a shortened url out with the post. TweetSuite then becomes aware of this url at publish, and stores it in its database. Then the cron job that runs every 5 minutes searches on any version of the URL that was stored and pulls back all the entries from the search.twitter.com Atom feed – parses them, and updates the database with them.

The rest of the stuff I did in the plugin was merely cleaning up…for example, reading the shortened urls from the Atom feed. The original code was:
{code type=php}
if(stristr($tweet, ‘http://bit.ly’)) {
if(strstr($tweet, $bitly)) {
$add = true;
} else {
$add = false;
}
}
{/code}
Because the urls are using alphanumeric sequences to track what link is what – and the url’s are case-sensitive, it was returning links that were not related to the post. For example, I got someone’s tweet about Rush Limbaugh because the bit.ly url (“http://bit.ly/fyhz”)was the same letters, but in a different case then my original “http://bit.ly/FyhZ”. So I changed the order of the search, did it for all the services currently supported, and cleaned up the code a little:
{code type=php}…
if(strstr($tweet, ‘http://bit.ly’)) { $add = (stristr($tweet, $bitly)) ? true : false; } else {
…
{/code}
The function strstr() is not case-sensitive, and that’s ok for a search on the domain name – we want anything that looks close to “bit.ly” to return positive. However, once it does, it’s imperitive that we use the case-sensitive stristr() function to return a positive result only if the full url matches what we have in the database case-for-case.

Wrapping up…

I made a couple more additions to the code beyond that, some of them required for functionality, some of them for cosmetics. I’ve submitted my plugin version to Ping.fm to approve it, and take my Developer’s Key out of “Pending” status. Once that’s done, I’ll send it off to Dan Zarrella to take a look and see how he wants to move forward. Then I’ll be able to post the plugin for download (definitely here, but also on the WordPress Plugin directory.

Continuing on…

I have read through the comments on Dan’s blog from the people, and have taken note of the things that they are asking for. After reading the code, he had already been working on some of the features. There are 5 main ones that people are asking for, and I’ve already done one of them in this release:

1. TweetThis link opens in a new window.
2. AutoUpgrade via WordPress Plugin Directory
3. Allow customized URL Shortening Services
4. TweetThis links for pre-installation posts
5. TweetThis links on the home page.

I’ll be looking more into the other options and see what I can do.

One More Thing…

This post was syndicated through the TweetSuite + Ping.fm plugin .

Technorati Tags: beta, dan zarrella, database, internet, MySQL, PHP, Ping.fm, site, syndication, tweetbacks, TweetSuite, twitter, WordPress