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

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

There will also be some integration to popular social sites right on the My Spot page, like twitter and flickr – community based sites with an API that doesn’t require you to visit their site in order to view content.

Last night, I worked with the twitter.com API and with the RSS reader that I’ve hacked up in PHP, and turned out the twitter stream for the-spot.net’s twitter friends. That will go on the front page of the My Spot page so that everyone on tsn can know what all the other tsn members are twittering about.

The next thing I’m going to be doing with that is working on a way to allow the users to update their twitter status directly from tsn. That’s going to take a bit more work than displaying the feed, but it will be a good challenge.

On the previous version of the site, there was a flickr flash app that showed the new photos from the tsn flickr group. That will be coming back as well.

I’m also going to try to make the User Control Panel more accessible and integrate the Buddy List into the My Spot page so you can see when your favorite posters are online (since the information box at the bottom displays the last X minutes, and not “Currently” online).

I’m still trying to gather new ideas from everyone about what they’d like to see on the page…and I hope to make it modular like that previous My Spot page was so they can just be plugged in to the template based on information in the new database determining whether or not they wish to see that.

if you have any ideas – leave comments, or message me directly.

Blogged with Flock

Tags: the-spot.net, tsn7, my spot, flickr, twitter, api, programming, hacking, rss, php, tsn, community, integration, mashup

Technorati Tags: api, buddy list, community, database backend, flash, flickr, front page, members, PHP, phpbb, RSS, rss reader, style, template, the-spot.net, tsn.7, twitter

Originally, I set up the server to be a web server with php and sql capabilities. Then I realized I needed to FTP files to the web server, so I installed FileZilla Server. Once that was done, I started working on the webpage for tsnlocal.net. I got it up, and then wanted to play around with some other type of server, and decided on a Jabber server for instant messaging. I installed Wildfire.

Wildfire is extremely easy to setup and install – so once I finished that, I looked for a Jabber client. My first choice was a VoIP client called Jabbin, but I couldn’t get it to connect to the server – probably because I don’t have a VoIP Protocol on the server to support it. So I went with what we use at work, Exodus. It’s a fairly functional Jabber client – with chat rooms, IM rosters, subscriptions, and file transfer…and a bunch of other stuff, including plugins.

Once the Jabber service was set up, and I figured out how to connect to it, I realized that telling people to use my dyndns domain name was not going to work. So I had to figure out how to get my Godaddy.com domain name to link directly to my IP address. But, come to find out, I have to have a Top Level Domain for an IP address, or my dyndns must be a nameserver registered with the NS Registry, in order to use it as a nameserver. I spent 2 days setting up BIND on Windows XP (because there was very little help on the internet for how to do it). Then I jacked around with the Total DNS control settings on godaddy, and got the webserver to work like it should – almost.

So now you can join the jabber server with yourname@jabber.tsnlocal.net. Now that I had that working, I noticed that there were email settings like pop.tsnlocal.net and smtp.tsnlocal.net that could be set up, so I decided to look into running my own email server. I got in #bloodshotgamer on irc.gamesurge.net and asked some of the tecky people I talk to in there what they’d recommend. Duck-Lap recommended qmail for linux, but mentined MailEnable for Windows. I was hoping for an IMAP service so I could run the webpage side of it, but that was not included with this. I might upgrade the service to something new later on, but for now, this was easy to install, and has easy administration, which is what I’m looking for since most of these other services aren’t critical to the function of the server. BIND was about the only thing that was hell to configure…everything else was easily figured out once I had the info and a general grasp of what it does and how it does it.

So now, [[Oracle]] does these things:
- Web Server (Apache, PHP, MySQL)
- FTP Server
- DNS Server
- Email Server
- Jabber Server
- TeamSpeak Voicechat Server
- Hamachi server
- Google Desktop distributed indexing server for the hamachi shares (the essence of tsnlocal)
- and a keep-alive for the dyndns service linking my IP to the dynamic domain

That’s a lot for a little box…but I’m not done yet – I need to put ssh on it so I can telnet into it. I’m sure there are other things that I will find to do with it as time goes on too.

Technorati Tags: bind, chat rooms, DNS, dns control, domain name, dyndns, Email, email server, email settings, exodus, FileZilla, FTP, godaddy, hamachi, instant messaging, internet, Jabber, jabber client, jabber server, Jabbin, nameserver, PHP, pop, server, setup, smtp, sql, sql capabilities, VoIP, Web, web server, webpage, webserver, Wildfire, Windows, [[Oracle]]

Originally, as you might recall from previous posts, [[Oracle]] is an IRC bot that we use for auto responding and chanserv purposes. Our bots are still the same in function so far, but they each have their own computer.

[[Oracle]] is now the webserver for tsnlocal.net, and runs the tsn.lcl project. It’s hosting a hamachi client, and serveral tsnlocal network connections. It’s also using Google Desktop those network shares, so that I can make them web-searchable, and the files downloadable for those connected to the tsnlocal network. I’m still working on the technology to provide the search page to the outside world (though the files will only be accessible to those who are connected and authenticated to the hamachi network.

To do this, I have installed WAMP (Apache, MySQL, and PHP for Windows) and put it on an XP Professional box. There is a main webpage up right now that shows the online status of [[Oracle]] and [[Oracle]].1 (a secondary server, of which there is also an [[Oracle]].2 which will be used later). The webpage also shows the online status of those involved with the tsnlocal project. The design of the webpage is still under construction though, at the moment.

[[Oracle]] is also hosting some other services for tsn…things that aren’t directly tied to the website, per se…like a TeamSpeak server, Blockland game server, and some other stuff that I haven’t gotten to set up yet.

It’s also been brought to my attention that there is a security exploit in Apache for windows, and [[Oracle]] will be the test-bed for solving that exploit. I have a solution in mind that would work, but might be a bit difficult to set up – though it would solve the problem until a patch is fixed. I’ll post more on that when I get some time to test it.

Technorati Tags: Apache, apache mysql, client, computer oracle, design, game server, google, hamachi, IRC, irc bot, MySQL, network connections, network shares, oracle hosting, PHP, search page, Servers, TeamSpeak, teamspeak server, technology, the-spot.net, tsnLocal.net, WAMP, webserver, website, Windows

I’m also going to be working on two versions of the former “My Spot” page…one that is universal, and one that is user-oriented/customized. The customized one (My Spot) will be written in AJAX, the universal one (The Spot) will be in php.

The new My Spot page will also be the basis for the My Blot page, that will be the essence of the-blot.net – insomuch as the settings will be saved per user on the My Spot page, and will be accessible by user_id…whereas the My Blot page will be accessible by username: the-blot.net/KD or /~day_dreamer~ or /Agent%20Smith.

There will be further posts concerning what the details of all the pages will contain…but greater emphasis will be placed on the photoalbum, journals, profiles, and buddy lists with the coming pages.

Technorati Tags: ajax, Blot, lan party, photoalbum, PHP, profiles, Spot, the-spot.net, theme, tsnX, update

So far, on tsnX.3 I’ve installed phpBB 2.0.20, Category Hierarchy 2.1.4c, and Profile Control Panel 200-1, and Registration IP 1.0.0. At least, those are the ones that I had to write my own code to get the mods to work.

So after you install phpbb 2.0.20, then you install CH 2.1.4c. Once you’ve done that, install Profile CP, and in the root/profilecp/profilecp_register.php you’ll need to make these modifications:

First, we
Find:

		if ( !$row = $db->sql_fetchrow($result) )
		{
			message_die(GENERAL_ERROR, 'Could not obtain next user_id information', '', __LINE__, __FILE__, $sql);
		}
		$userrow['user_id'] = $row['total'] + 1;

Add After:

//-- mod : categories hierarchy ------------------------------------------------
//-- add
			// update last user
			$config->set('stat_last_user', $user_id);
			$config->set('stat_last_username', stripslashes($username));
			$sql = 'SELECT COUNT(user_id) AS total_users
						FROM ' . USERS_TABLE . '
						WHERE user_id <> ' . ANONYMOUS;
			$result = $db->sql_query($sql, false, __LINE__, __FILE__);
			$row = $db->sql_fetchrow($result);
			$config->set('stat_total_users', intval($row['total_users']) + 1);
//-- fin mod : categories hierarchy --------------------------------------------

Find:

		$sql = "INSERT INTO " . USER_GROUP_TABLE . " (user_id, group_id, user_pending)
				VALUES ($user_id, $group_id, 0)";
		if( !($result = $db->sql_query($sql, END_TRANSACTION)) )
		{
			message_die(GENERAL_ERROR, 'Could not insert data into user_group table', '', __LINE__, __FILE__, $sql);
		}

Add After:

//-- mod : categories hierarchy ------------------------------------------------
//-- add
			// cache groups list and set the user_id on the single group_id
			$view_user = new user();
			$view_user->read($user_id);
			$view_user->get_groups_list(true);
//-- fin mod : categories hierarchy --------------------------------------------

Find: