In this post, I’m going to walk through a small project I took on at work to move a department off of Excel to Drupal.  This particular case was a little different then other workflow process automation project I take on as the department came to me looking for an easier way to track information.

Original State:

The Lab Point of Care (POC) department was tracking training session on an excel spreadsheet.  POC is a distributed department with 4 different offices.  2 of the offices shared a spreadsheet and the other two and an identically formatted spreadsheet with information with their location.   The spreadsheet was formatted with each person having it’s own row, and each training session that the person took in a separate column.  All of the spreadsheets are stored on a network share.

Issues with original state:

• The same person could take the same class at multiple locations.  They were only required to take the class at one location.  Since the spreadsheets are not synced, one office would have to open another office’s spreadsheet to verify that the person has taken the class.
• One of the spreadsheets had over 15 thousand rows.  It was slow to load off of the network share.  Due to the size of the spreadsheet, the users would copy the spreadsheet locally and be working off of old data.
• Several users would attempt to update the spreadsheet at the same time.  This would cause file corruption issues and loss of data.

Requirements:

• Easy to search by employee ID or name.
• Ability to quickly add new training session.
  • One session for a day.
  • Multiple sessions for single day.
• Person Data:
  • Employee ID (Unique)
  • Name
  • Location (multiple)
  • Position
• Training Session Data:
  • Training Session Type
  • Certification Length
  • Date
• Reports for training session by multiple criteria.
• Ability to export reports to excel/pdf.
• Upload the current spreadsheets to pre-populate the data.

Plan of Attack:

My main goal was to keep the application was simple as possible.  Most of the application focuses around the Training Sessions screen.  This is the screen where they look up, add/edit training sessions.  Being that this project had very limited time associated to it, I needed to use as many prebuild Drupal modules as possible.  The core of the application is focused around CCK and views.  I used CCK to create the widgets for the forms.  Ajax, Editable and quicktabs were used to help improve UI.  Custom forms (using Form API) combined the views and content type forms on a single page.  The Acquia Marrina Theme from Top Notch Themes (http://www.topnotchthemes.com)

Content Types:

• Person:  Each person has a person node.
• training session:  Each training session is attached to a person.

Main Modules

• Ajax:  Used for UI imporovments.  Gives the ability to add AJAX (http://drupal.org/project/ajax) to any form very easily.
• CCK
  • Content Taxonomy
  • Mulitselect (http://drupal.org/project/multiselect):  Improved UI for Content Taxonomy when using multiple terms.
• Form block (http://drupal.org/project/formblock):  Easily expose a node form to a block.  This was used in combination with Quick Tabs
• Quick Tabs (http://drupal.org/project/quicktabs):  Allow for improvements to the UI.
• Views
• Custom Code

Primary Pages

• Training Tracking Page (Home Page):  Upon first loading the web app, you are giving a page with simple search box (see screen shot).  The user has the option to either type in a few letters of the name or the Employee ID.  The search box is an auto-complete drop down built as a custom form.     Once a person is selected the user presses “search” and it brings up the details for the employee (see screenshot).  At the top of the page the user has the option to either search for another employee or edit the current one.  Under that there is some basic information about the employee.  These fields are pulled from related taxonomy terms.  Quicktabs were used to allow all of the screen to be on the same page.  The first tab is the current sessions and the second tab gives the user the ability to quickly add a new session.  The Ajax module was used to save the info to the database without refreshing the entire page.  This give the user the ability to add training sessions quicker.

• Add/Edit Person Screen:  This is just the add/edit form for person content type.  CCK was used to give the necessary appearance.
• Reports: Views were made with a good amount exposed filters, giving the user the ability to find any necessary information.
• List Management:  The location, position, training session type and certification length are all vocabularies.  The site administrators manage the lists via the core taxonomy forms.

Importing the Old Data

This was the most challenging part of the project.  It required the most custom coding.  The spreadsheets had to be formatted in a way where they could be easily turned in to a csv file.  Once the spreadsheet was in the correct format, the parsecsv-for-php (http://code.google.com/p/parsecsv-for-php/) library was used.  This allows me to easily parse the csv file and place the csv fields in the correct content types.  A little error and duplicate checking and I had myself a nice template to use for future data imports.

Conclusion

The web application has been live for about a month and I’ve already heard how much it has improved their workflow.  The amount of effort that was needed to evaluate the workflow process and create the application was well worth the benefit.  This was the first Drupal application for this company and we are already working on a few others.

Code Dreamers

A few months ago I launch the official front end to my freelancer Drupal development.  After much consideration, I named it Code Dreamers (http://code-dreamers.com).  Since I’m not a full time developer, I’ve done my best to limit my scope of what services I offer.  With a child on the way, I didn’t want to get myself anymore over extended then I already am.  I’ve deiced to specialize in offering custom Drupal functionality.  I’m not looking to create the entire site, just add or enhance a current site/project.  My clients are other developers and designers (mostly designers).

This is a very excited endeavor for me.  Hopefully the start of a new life in development.

Taxonomy Menu

This module has consumed most of my free time.  I totally rewrote the module to use Drupal’s menu system correctly.  I’ve learned a ton about Drupal, php and open source development.  I am very proud of this module.  I have spent countless hours in the issues queue answer questions and developing new functionality.  A few other developers had submitted patches to enhance it’s functionality.  It’s great to get more involvement.  One of the featuers I’m most proudof is the API (http://drupal.org/node/380652).  Now developers can customized the menu to their hearts content.

I’m working on the next version of Taxonomy Menu already.  Some great ideas are coming form the community.  It will be easier to use with more customization.  I’m very excited about this.  Unfortunately, it’s slow coming.  I hope to have a first alpha version by the end of the month.

Blog To It

I had several conversation with the developer of Blog To It (http://blog.to.it), Tim Millwood (http://www.millwoodonline.co.uk/) over Twitter and we ended up teaming up to work on the site together.  He launched Blog To It shortly after I began working on Blogs of Indy.  I’ve decided to stop development on Blogs of Indy and focus on Blog to It instead.  Tim and I have had tossed around ideas and I’m ready to get started.

Drupal

I have began to implement new Drupal sites at my place of employment.  They have been a M$ shop for a long time and the idea of open source is very scary.  Their attitude changed very quickly when I was able to create a server and deploy a custom fully functionality website within 20 hours.  Now I’m adding more Drupal sites.   I’m hoping to make my full time job developing Drupal.

My trust in these sites has now gone by the wayside.  From braingir’s blog:

Problems first surfaced last year, when the San Francisco Chronicle’s Michael Bauer wrote that a few chefs had encountered diners threatening them with bad reviews if meals and drinks weren’t comped.

Continued on to this paragraph where all of my faith was lost:

Now, Michael Atkinson, founder of the social networking site FOH-BOH, reports even worse shenanigans on the part of Yelp! The East Bay Express published an article last week on Yelp’s newest sales pitch to chefs and how it was gaining traction. Sales reps from the company are now calling restaurants with bad reviews posted and offering — for a mere $299 a month — to remove those bad reviews! As part of their service now, the folks at Yelp make money by cleaning up negative comments! Wow. Just Wow. What little shred of usability just went out the window. Talk about a no-negative review policy. How about we make some money on those?!

This cuts deeply into the trust of the “Average Joe.”  The reviews now mean nothing.  If Yelp does this then who is to say that the other sites don’t already do this or are going to follow suit.  Our only hope is to educate the masses to not use sites like this and refer the reviews to the professionals (or educated armatures).

Before you start throwing the freedom of speech argument at me, realize that I agree that everyone should have voice, but when that voice promotes corruption then the voice should be silenced.

EDIT:  I wanted defend Angie’s List. This is a review service that I have found to be extremely honest will continue to recommend them to everyone.

Ingredients:

• Chipped Beef
• Boneless/Skinless Chicken Breast
• Thinly sliced bacon
• 3/4 cup grated Swiss cheese
• 1 pint sour cream
• 1 can mushroom soup
• 1/6 tsp poultry seasoning

Instructions:

• Grease bottom of oblong backing dish adn line with chipped beef
• Cut chicken breasts in half.
• Wrap chicken in bacon.
• Place chicken on top of the chipped beef.
• Mix sour cream, mushroom soup and poultry seasoning together; pour over chicken.
• Base at 275 for 3 hours.
• Last 20 minutes, cover with Swiss cheese.
• Makes a gravy that can be served in a separate dish for those who like more (like me).
• Server with rice or over toast.

FeedAPI Taxonomy Compare Updates. This module is a key piece to the functionality.  I spent several hours fixing bugs and adding functionality.  Being able to match on synonym will help me keep my menus clean.

Blogs of Indy Custom Module

I added a few tabs to the profile page.  One tab is a list of all the blogs for that user.  It is basically a copy of the FeedAPI admin page just filter for the user.  I filtered it based upon the user argument in the URL. Here is the code for the hook_menu.

$items['user/%user/feeds'] = array(
‘type’ => MENU_LOCAL_TASK,
‘title’ => ‘Blogs’, //Going to be a variable on the main setting page
‘page callback’ => ‘blogsofindy_feedapi_admin_overview’,
‘access callback’ => TRUE,  //security is built into the function since this displays on the user profile page
‘page arguments’ => array(1), //pass the account
‘file’ => ‘blogsofindy.feed.user.page.inc’
);
$items['user/%user/feeds/overview'] = array(
‘type’ => MENU_DEFAULT_LOCAL_TASK,
‘title’ => ‘Overview’,
‘weight’ => -10,
);

Here is the page callback code.

function blogsofindy_feedapi_admin_overview($account = NULL) {
$header = array(
t(‘Title’),
t(‘Last refresh’),
t(‘New items added per update’),
t(‘Update rate’),
t(‘Number of items’),
t(‘Processing time’),
t(‘Commands’),
);
$rows = array();
//check to see if account variable was passed.
//if so then only bring back the nid where the nid is the author
if (!isset($account)) {
$result = pager_query(“SELECT nid from {feedapi} ORDER BY checked DESC”, 50, 0, “SELECT count(*) FROM {feedapi}”);
}
else {
$sql = sprintf(“SELECT feedapi.nid AS nid FROM {feedapi} INNER JOIN {node} ON {feedapi}.nid = {node}.nid WHERE ({node}.uid = %d) ORDER BY {feedapi}.checked DESC”, $account->uid);
$sql_count = sprintf(“SELECT count(*) FROM {feedapi} INNER JOIN {node} ON {feedapi}.nid = {node}.nid WHERE ({node}.uid = %d)”, $account->uid);
$result = pager_query($sql, 50, 0, $sql_count);
}
while ($nid = db_fetch_array($result)) {
$nid = $nid['nid'];
$node = node_load($nid);
if (is_object($node)) {
$commands = array(l(t(‘Delete’), ‘node/’. $node->nid .’/delete’, array(‘query’ => ‘destination=’ . $_REQUEST[q])),
l(t(‘Remove items’), ‘node/’. $node->nid .’/purge’, array(‘query’ => ‘destination=’ . $_REQUEST[q])),
l(t(‘Refresh’), ‘node/’. $node->nid .’/refresh’, array(‘query’ => ‘destination=’ . $_REQUEST[q])),
l(t(‘Edit’), ‘node/’. $node->nid .’/edit’, array(‘query’ => ‘destination=’ . $_REQUEST[q])),
);
// Fetch statistics for this feed
foreach (array(‘download_num’, ‘new’,  ‘process_time’, ‘update_times’) as $type) {
$node->feed->statistics[$type] = _feedapi_get_stat($node->nid, $type, TRUE);
}
if (count($node->feed->statistics['download_num']) != 0 && count($node->feed->statistics['new']) != 0 && count($node->feed->statistics['process_time']) != 0) {
$update_rate = _feedapi_update_rate($node->feed->statistics['update_times']);
$rows[] = array(
l($node->title, “node/$node->nid”),
$node->feed->checked == 0 ? t(‘Never’) : t(‘%time ago’, array(‘%time’ => format_interval(time() – $node->feed->checked))),
round(array_sum($node->feed->statistics['new']) / count($node->feed->statistics['new']), 2),
is_numeric($update_rate) ? format_interval($update_rate) : $update_rate,
round((array_sum($node->feed->statistics['download_num']) / count($node->feed->statistics['download_num'])), 2),
round((array_sum($node->feed->statistics['process_time']) / count($node->feed->statistics['process_time'])), 2) .’ ‘. t(‘ms’),
theme(‘item_list’, $commands),
);
}
else {
$rows[] = array(
l($node->title, “node/$node->nid”),
$node->feed->checked == 0 ? t(‘Never’) : t(‘%time ago’, array(‘%time’ => format_interval(time() – $node->feed->checked))),
”, ”, t(‘No enough data for statistics’), ”,
theme(‘item_list’, $commands),
);
}
}
}
$output = format_plural(round(FEEDAPI_CRON_STAT_LIFETIME / (24*3600)), “Average over the last day.”,
“Averages over the last @count days.”
);
$output .= theme(‘table’, $header, $rows);
$output .= theme(‘pager’, 0, 50);
return $output;
}

Pretty simple really.  It’s a copy of the admin display from FeedAPI.  What I changed is in Italics. Right after I did this, FeedAPI introduced a view based approach to the page.  I have yet to change my code to use a view, though probably a good idea.

Blog Tag Management

As some of you remember, I mentioned that there needs to be an easy way for the blog owners to manage the incoming terms that need to be associated to the categories.  I choose to do this by adding a tab to the profile page.

$items['user/%user/feeds/terms'] = array(
‘type’ => MENU_LOCAL_TASK,
‘title’ => ‘Terms’,
‘page callback’ => drupal_get_form,
‘access callback’ => TRUE,
‘page arguments’ => array(‘blogsofindy_terms_form’, 1),
‘file’ => ‘blogsofindy.feed.user.page.inc’
);
$items['admin/settings/blogsofindy'] = array(
‘type’ => MENU_NORMAL_ITEM,
‘title’ => ‘Blogs of Indy’,
‘description’ => ‘Change the settings for Blogs of Indy Custom Module’,
‘page callback’  => ‘drupal_get_form’,
‘page arguments’ => array(‘blogsofindy_admin_settings’),
‘access callback’ => TRUE,
‘file’ => ‘blogsofindy_admin.pages.inc’,
);

I have complete the first version of the code for displaying the form but I am not ready to share the validation or submit code.  I had to come up with how I wanted to manage the terms.  This is when I added the synonym functionality to FeedAPI Taxonomy Compare.  The idea is that incoming feed’s tag will match the synonym and attach itself to the category term.  So this form will give the users a list of the tags that their blogs are associated to so they can either “link” them to a category by making them a synonym or add the tag as a category.  Either way, the posts nodes will be related to a category term and unrelated from a tag term.  I’m struggling with giving the user so much power to add categories (and in turn menu items) so easily.  Though it would give them a sense of ownership which is what I am looking for.

Either way, here is the code for the form.

function blogsofindy_terms_form($form_state, $account) {
//build SQL statment for tag options
$sql = sprintf(“SELECT DISTINCT td.tid AS tid, td.name AS term_name
FROM {node} n
inner join {term_node} tn on n.vid = tn.vid
inner join {term_data} td on tn.tid = td.tid
WHERE n.uid =  %d AND n.type =  ‘%s’ AND td.vid = %d
ORDER BY td.name”, $account->uid, ‘feed_item’, variable_get(‘blogsofindy_tags’, array(’0′)));

$result = db_query(db_rewrite_sql($sql));
$tags = array();

$categories = array();
$tree = taxonomy_get_tree(variable_get(‘blogsofindy_category’, array(’0′)));
foreach ($tree as $key => $term) {
$categories[$term->tid] = _blogsofindy_terms_format($term->name, $term->depth);
}
if (!empty($result)) {
while ($data = db_fetch_object($result)) {
$tags[$data->tid] = t($data->term_name);
}

$form['tags'] = array(
‘#type’ => ‘select’,
‘#title’ => t(‘List of Tags’),
‘#options’ => $tags,
);

$form['categories'] = array(
‘#type’ => ‘select’,
‘#title’ => t(‘Category’),
‘#options’ => $categories,
);

$form['merge'] = array(
‘#type’ => ‘select’,
‘#title’ => ‘Action’,
‘#options’  => array(
’1′ => t(‘Move posts and all future posts to new Term’),
’2′ => t(‘Move Term from Tags to selected Category’)
),
‘#default_valule’ => ’1′,
‘#description’ => t(‘Moving the Term from Tags to the selected Cateogry will change the parent and vocabulary for the selected Term’),
);

$form['submit'] = array(
‘#type’ => ‘submit’,
‘#value’ => t(‘Move’),
);
}
return $form;
}

Using a helper function to display the categories in a hierarchy display

/**
* helper function to great the options for the cateogires in a tree format.
* @param string $term
* @param int $depth
* @return string
*/
function _blogsofindy_terms_format($term, $depth) {
$output = $term;
if ($depth > 0) {
for ($i=1; $i <= $depth; $i++) {
$output = ‘-’ . $output;
}
}

return $output;
}

I also added a admin settings page to select which vocabularies to use in the “Tags” and “Category” drop downs on the form.

function blogsofindy_admin_settings() {
//get list of vocabularies
foreach (taxonomy_get_vocabularies() as $voc) {
$options[$voc->vid] = $voc->name;
}

$form['blogsofindy_tags'] = array(
‘#type’ => ‘select’,
‘#title’ => t(‘Tags Vocabulary’),
‘#options’ => $options,
‘#default_value’ => variable_get(‘blogsofindy_tags’, array(’0′)),
);

$form['blogsofindy_category'] = array(
‘#type’ => ‘select’,
‘#title’ => t(‘Category Vocabulary’),
‘#options’ => $options,
‘#default_value’ => variable_get(‘blogsofindy_category’, array(’0′)),
);

return system_settings_form($form);
}

Left to do before initial release

After I finish the code for managing the terms I have to put in place my ideas from my post More Features for the Blogger.  I also like Blog.to.it‘s idea of integrating twitter.  This would give more attention to the arthur.  Then comes the decision about where to display what.  I want to be sure to reconize the blogger but don’t want to make the page to busy.  Then comes theming which I haven’t even begun to learn yet.   There you go, more to come

I also added the ability to match on Synonyms.  So if the tag matched a synonym of a category, then the node is attached to the category term.  This is useful because now you can have more control over what categories you have.  You no longer have to find a place for each term you want to match on.  There is a new setting in admin/settings/feedapi_taxonomy_compare to turn on this functionality.

Download the latest version and let me know.

One of my most difficult decisions is selecting which restaurant I want to go to.  Since it also falls on my Birthday week, I get to enjoy a fine dinner on my Birthday for a great price.  While I was reading one of my favorite blogs, Feed Me Drink Me (If you want to know anything about food in Indianapolis, this is the place to start), I came across 2 posts about this years event. (Devour Downtown Starts Today and Open Thread: Devour-Downtown Fatique)  It really made me think more about my decision.  I guess I always assumed the deals were good.  Apparently some of them may not be.  I will be paying attention to the second thread mentioned for suggestions.  I want to make this year great.

I really really want to go to Elements.  They don’t have a predefined menu though.  Which is what I love about them.  The menu changes based upon what they have to cook with.  The problem is that I have family members with food allergies and have to be careful.

Where would you good?

This is a simple recipe that is very filling and lot in carbs.  And yes, they taste much better then the look.

Ingredients:

• 1 lb Hamburger
• 1 lb sausage (Jimmy Dean Roll)
• 1 T. oregano
• 1/2 T. garlic salt
• 8 oz shredded cheddar
• English Muffins (or any bread)

1. Brown hamburger, sausage.  Add spices when almost complete.  Drain.
2. Mix in cheese until melted
3. Lie out English Muffins on cooking sheets.
4. Place meat mixture over English Muffins.
5. Cook for 15min at 375 degrees.

Notes:  Only cook what you are going to eat at this sitting.  It is easy to make a large batch of the meat (even double) and place in the freezer.  Within 20 minutes you have a fresh tasting meal.  I suggest pairing this with vegetables.  Otherwise it can get rather heavy.

Happy Cooking!

My needs

• Syntax color coding
• Tab Formatting help
• Auto Complete
• Ability to add folders as includes for auto complete.
• Debugging
• CVS/SVN integration

Here are the IDE’s that I tested.

• Zend Studio
• NuSphere PhpED
• Komodo
• Code Lobster
• NetBeans

Zend Studio

Zend Studio is a very well polished product.  It has every tool you would every want in an IDE.  That is it’s greatest strength and weakness.  The entire interface seemed a little sluggish compared to the other IDE’s.  The interfaced had a more professional look then the others.  It was very easy to start using.  The controls were very intuitive.  You can get started doing basic PHP sites easily and know that there is plenty to learn.    So what’s the downside?  The price.  At $399 for 1 year of upgrades and $717 for 3 years it is rather steep.  It’s a great IDE though.  I enjoyed my 30 days using Zend, and it’s made by the same people who made PHP.  It’s a great choice.

NuSphere PhpED

After all of the hype from the PHP Editors website, I had to give the trial a go.  Like Zend this is a full featured IDE.  It has every tool you would every need.  I didn’t spend much time with this IDE.  When I tested it I didn’t have any projects, I was just researching.  It worked well but didn’t leave any sort of lasting impression on me.  I read that it has excellent debuger and good database integration.  It also is a little expense at $250.

Active Stat’s Komodo

This was a great product.  I fell in love with this IDE from the first line of code I wrote.  Not only does it contain all of the features that Zend has, it is FAST.  I didn’t feel like the application was doing anything in the background like Zend.  The code intelligence was fast and it added include folders with ease.  The debugger worked as well as the other IDE’s (they all use the XDebug PHP plugin).  The only down side is that the interface didn’t look like a $300 application.  The developers have definitely spent their time on speed and functionality instead of the presentation.  This was my favorite of the paid IDE’s.

Code Lobster

Code Lobster is a new comer to the IDE arena.  The product was good and the price was right, FREE!!  It has code intelligence and debugging just like the big boys.   It was quick and had a nice interface.  I was as comfortable doing the actual coding.  The tab logic and auto “)” and “}” didn’t act like I wanted.  I had to go back a few times to edit the “help” it provided.  One of the coolest features about Code Lobster is the Drupal plug in.  It had full integration to the Drupal API.  It even knew how to format the array correctly.  If you put “$form['form_name] = array” then the auto complete takes control asking you which element you want to use.  You just select them from the drop down and it formats it according to the Drupal standards (even puts the “#”).  There is also a Smarty Plug in that I’m sure is just as cool.  The plug-ins are not free though.  But if you are going to use Code Lobster, the $99 plug-in is worth it.  That being said, I couldn’t pull myself past the coding “help.”

NetBeans

NetBeans is free IDE based totally in Java.  Alright, don’t run for the hills quite yet.  This IDE has came a long way during it’s life.  The newest version is fast and fully featured.  The interface and usability is right up there with Zend and Komodo.  While it wasn’t love at first site, like Komodo, it has turned into a loving relationship.  After a little tweaking of the settings, it did everything I wanted how I wanted.  It fit my coding habits perfectly.  One of the cool features is the debugger.  It has the standard XDebug functionality but it also has a firefox plugin to debug the front end.  Guess what, It has a Drupal plug-in also.  The plug in is not as feature rich as the Code Lobster one but it Free.  Oh, and did I mention that everything is FREE!

Conclusion

If Komod was free then I would have used that.  Being that it wasn’t I went to NetBeans.  I have no regrats.  NetBeans as been very good to me.  My effeicncy is way up.  No longer to I forget the “;” or have any syntax errors.  I am now a happy devloper.   I know there are several others that are good that I haven’t tried.  This is in no way a complete list.  Just my experience.

http://drupal.org/project/feedapi_taxonomy_compare

• Control over how the content will be displayed:  Using Drupal’s input formats, I can specify what HTML tags are allowed.  So if they do not want their pictures to appear then they won’t.
• Display Teaser Only:  This will only display a teaser of the post on Blogs of Indy.  This option is only available if they are using a plain text input format.
• More Blocks.
  • “Most posts from this Author”
  • “About this Author”
  • “Post from this category”

Hopefully most of the blog owners will allow the full post to be displayed if I have a strong presence showing who the content is from.

I’ve also changed my philosophy on how the categories and tags will be managed.  Instead of having the categories managed by an administrator, the users will be able to categorize the content if they do not agree.  The will not be able to remove a post from a category, but rather add it to a category.

Blogs of Indy is going to be focused around dipalying the most relevant information for the reader.  I have ideas of adding a “Other posts you would like” sort of block in the future.

New Module:

FeedAPI Taxonomy Compare. You can get a detailed info from the readme file and the project page (when it comes up) but here is the basic idea.

This module is meant to work with FeedAPI, FeedAPI Node and Feed Element Mapper to give more control over what happens with incoming taxonomy terms.

Example Use.
Vocabulary of ‘Categories’ feeds the a piece of the primary links using taxonomy_menu.  When a feed-item comes in the options->tags element is mapped to the ‘Tags’ vocabularies using Feed Element Mapper.  If the term is found then I remove it from the association from the ‘Tags’ vocabulary and add the association to the ‘Categories’ vocabulary.  Now the new items are automatically in the correct place for views.

The feed owner (or other person) would then come match the new tags to an existing category.  If they wish to add a new category then they fill out a request form and the site administrator can create the term and move the nodes accordingly.

Suggested Workflow
1. Feed is refreshed
2. New node is created using the taxonomy setting from Feed Element Mapper.  If using FeedAPI Node Inherit, this is applied here also.
3. All mapped and inherited terms are run through this module.
4. Matched terms are added to more defined categories.
5. Unmachted terms are placed in a general vocabulary where the feed administrator can add them to specific categories later.

Other accomplishment

• Messaging and Notifications now send out emails.
• Fixed cron timeout.  Issue was incompatibility with the Notifications plugin for FeedAPI.
• Put together Incoming feed workflow.

Still To Do

• Rewrite Subscription Block module.
• Customize Notification UI
• Create an UI for feed owners to administer the term-node relationship and move terms between vocabularies.  This will be a modification of Taxonomy Manager.
• Notification Workflow.

Check it out!

http://www.tweetdeck.com/beta/

I did my best to get a picture of people enjoying the food, but each batch of waffles that came out of the iron were gone within minutes.

I must say these were the best waffles that I had ever had.  So light and fluffy that you could eat 10 of them.  Of course it helps that I only have a small waffle maker that makes the little 4×4 inch waffles.  It did take me about an hour to prep these.  I ended up missing some of the present opening.  So here are some tips to help you avoid that.

• PREP, PREP, PREP!
• Have all of the dry ingredients premixed.
• Create the egg yoke mixture (egg yokes and sugar).
• Pre-Beat the egg whites.  I’m not sure how early you can do this one.  A side note that it took atleast 8 minutes of beating with a handheld electric mixture to get the correct consistency and we don’t think we beat them enough.
• Don’t over spray your iron.  Depending on your iron, there is such a thing as to much cooking spray.  I found reapplying every 3rd attempt kept my iron good and clean while not transferring to much of the oil to the waffles and hindering the backing process.
• Server quickly.  They get cold fast.

Following the prep steps will go a long way on  cooking day.  Especially if you are cooking for 12!

Merry Christmas and Happy Cooking!!

Ingredients

• 2 Sticks of butter (mmmmmm…  butttterrrrr)
• 2 cups brown sugar
• 1/2 cup Karo (light)
• 1/2 tsp vanilla
• 1/2 tsp baking soda
• 2 pkgs corn puffs (8 oz each)

Add butter, brown sugar and Karo in pot and boil for 5 minutes.  Stir in Vanilla and baking soda.  Pour over corn puffs and stir until well coated.  Add nuts if you wish.  Bake at 250 degrees for an hour, stirring every 15 minutes.

notification_block.zip

What it does:  Add a block with a drop down.  The drop down contains the name of the Feed and all taxonomy terms for that node.  If the node type is the feed item (Post) then it pulls the parent feed and puts it in the list.

I’m using this basic setup as an interface for the users to add subscriptions.   Please comment on the idea.

Now I basically have to rewrite the entire thing and pull the feedapi and notification options and type from the modules functions before I can release this. I’ll probably end up adding in some jscript effects to make it pop.

I had dream last night (yes, I dream in Drupal) about how to create more meaningful categories for people to subscribe to.  The idea of synonyms came to mind.  So instead of (or maybe along with) assigning the categories to the feeds, the tags from the blogs will be attached to a category.  The problem is that this will require intervention from the user, either myself or the blog owner, and are they going to want to spend the time?  I’m doing my best to make this “not another site I have to do to”.  Thoughts?

Still To DO:

• Rewrite Subscription Block module
• Decide on Control level for users
• Continue working on theme
• Customize Notification UI
• How to catorigize posts meaninfully

Example site:

http://newfind.net/DrupalTheme/

Here are a few screencasts from the created.

http://psd2cssonline.com/node/183

http://psd2cssonline.com/node/186

http://psd2cssonline.com/node/193

It creates the regions based upon the of the layer.  So if you want to add a search region, you just create a layer called mysearch_drupal.  You set the size and location of the layer to the size you want for the region and this site will create the .info, .tpl and .css files for the psd.  This is a great way to start the your theme.  It’s not perfect, it seems to use fixed width and height but that can be changed via css.

I haven’t tried this out yet but I will be soon.