We’ve done a bit of research on Magento already, and found that while it is very powerful and flexible, there is very little documentation and some people have found that the layers of programming and thousands of files are tricky to customize, and this makes it take up to 5 times longer to customize. In addition, I have read that the cart runs slowly, requires at least a semi-dedicated server, and can be costly to host as the number of products increases.

Magento allows for multiple stores to use one cart, an obvious savings to our clients. It also allows for multiple product images so that customers can get a really good look at what they are purchasing. It also allows coupons and different pricing for customer groups. Google checkout, PayPal, and PayPal Pro are all integrated, and there is a one-page checkout process.

As far as SEO goes, this cart has the ability to add unique titles and descriptions and keyword rich URLs on pages, just like Squirrelcart. It also has a nice CMS which allows your customers to add informational pages which can be used for SEO as well.

You can download the cart for free from http://www.magentocommerce.com, and there is also a fully supported enterprise edition of the cart for just under $9,000 for larger businesses that want to integrate their carts and inventory systems. The cart is coded with the latest PHP 5 object oriented standards and uses the Zend framework.

Check back to our blog in early January after we complete our first Magento ecommerce website, when we will review our coding experiences using the software.

When most people visit websites, they assume the animated material is Flash.  That’s not always the case.  Due to the growing popularity of JavaScript frameworks, there are now a variety of exciting options for incorporating animations and animated material into your website that don’t involve Flash, which can’t be read by search engines.

You want your website to be creative and interactive, but you also want to show up in the SERPS.  You don’t have to sacrifice any optimization with jQuery.  It serves as an excellent tool for front-end developers to present information to the end user in more interesting ways.  The fact that jQuery website animation uses JavaScript to manipulate DOM objects, (represented with HTML and styled with CSS) makes it easy to stay SEO friendly because you can reveal and hide content from the user with effects, but still keep the same page markup for search crawlers.

If you’re interested in jQuery animation for your website, check out these 6 cool website animation techniques:

1.   jQuery Cycle: http://malsup.com/jquery/cycle/

A great way to display your images!

This useful plugin can be used to create slideshows of images without the need for Flash.  You can use this to display a gallery of images and choose the manner you’d like the images to transition.  Effects include Shuffle, Zoom, Fade, Turn Down, Curtain, and Scroll.

Boomtown uses this jQuery animation here: www.boomtownig.com

2.   jQuery Accordion: http://jqueryui.com/demos/accordion/

Manage your content.

The jQuery Accordion can help you display lots and lots of content in a condensed form that’s still visible to search engines, but doesn’t overload users’ senses. 

RCD Technology uses the accordion plugin to successfully manage their content:  http://www.rcdtechnology.com

3.  Form Validation: http://jquery.malsup.com/form/

Doing client-side form validation is made much easier with the jQuery forms plugin.

Widely regarded as one of the best jQuery plugins, Form Validation involves doing things like checking that all required fields were filled out and, if so, were they filled out to a required specification (e.g. correctly formatted phone numbers or dates), enabling you to get the information you need.

4.   Superfish: http://users.tpg.com.au/j_birch/plugins/superfish/#examples

Create a cross-browser multi-level horizontal or vertical navigation.

The jQuery Superfish plugin is great for managing drop down and multi-level navigation.  With the Superfish navigation plugin, you’ll be able to showcase and direct visitors to the many webpages your site has to offer.

It’s used for the navigation in the orange top menu of the Boomtown site and blog:  www.boomtownig.com

5.   Subtle Animation Effects: http://www.rcdtechnology.com/rfid-applications/partners-customers/

Create subtle animation effects for page items and images. (You can view these by mousing over the partner logos).

The creation of these effects for page items adds different movement to images.

6.   Or you can use any of the widgets in the jQuery UI to enhance user experience:
http://jqueryui.com/demos/

We hope these 6 tools will inspire you to explore all that jQuery has to offer—there are numerous other plugins and website animation techniques as well.  Learn more about jQuery and what it can do for your website!

#!/bin/bash
for domain in `cat domains.txt`
do
   echo $domain
   `whois $domain >> whois-results.txt`
done

You could take this a step further and do some regular expression matching to only get the lines of interest, but this needed to be quick and dirty.

Outline of Components

1. Adding a unique id to the body tag of each page in the zend framework project
2. A modal dialog using jQuery UI that displays the exit survey
3. An AJAX call to our Zend Framework controller that logs the survey results
4. A script that runs from the crontab to email the survey results on a daily basis

Directory Structure of Zend Framework Project

Here’s what the directory structure of my Zend Framework project looks like. Htdocs is the web root and all of the application files are in the FTP root, safely prevented from being accessed via the web in a folder called app_jsc.

You’ll notice that the Zend Framework library is mysteriously missing. I keep this at the same directory level as app_jsc and htdocs because I might want to run multiple apps on this hosting account.

Add a Unique id to Each Page’s Body Tag

I like to add an id to the body tag of each of the pages in my Zend Framework projects. For example:

This comes in handy if you need to target css or javascript to certain pages only. In the app_jsc/views/layouts/main.phtml, put this code:

I have a controller plugin called ViewSetup that I use to execute certain code during the dispatch cycle. Setting up and registering controller plugins can vary depending on which version of Zend Framework you’re using, so I won’t cover how to specifically do that in this post, but you should be familiar with how this works. In the dispatchLoopStartup() of my plugin, I put this code that assigns a value to bodyId and passes it to the view:

public function dispatchLoopStartup(Zend_Controller_Request_Abstract $request)
{
  // Get the name of the controller and action of this request
  $controllerName = $request->getControllerName();
  $actionName = $request->getActionName();
 
  // Get static instance of ViewRenderer helper
  $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer');
  $viewRenderer->initView();
  $view = $viewRenderer->view;
 
  // Assign value to the bodyId and pass it to the view
  $view->bodyId = $controllerName . '-' . $actionName;
}

So, on the home page of the site, the HTML will look like:

jQuery UI Custom Build

First, we need to head over to jQuery UI and get the components we’ll need to construct the modal dialog. I want to download a custom version of the jQuery UI that contains only the components I really need for the exit survey. The UI demo pages are really good about specifying the dependencies needed for each widget to work. The jQuery Dialog widget needs UI Core, UI Draggable, and UI Resizeable. The last two are only necessary if I want the dialog to be resizeable or draggable (surprise). I might want this, so I’m going to include them in the custom build I specify on the download page. On this page, I specify that I want the Cupertino theme. I check the UI Core, Draggable and Resizeable from the Interactions, the Dialog widget, and all of the effects because I might want to apply one when the dialog appears. They aren’t necessary for this to work though.

When you build your own download package, jQuery is going to give you a zip file containing a css folder, a js folder, and another folder called development-bundle. I only need what’s in the css and js folders. The css folder will contain a folder with your theme name and, inside of that, the themed css file and an images folder. I’m just going to drop the cupertino folder into my public css folder (I call mine “c” for short) in my project. I’ll also drop the files from the js folder into my public js folder in my project. I need to place some code in app_jsc/views/layouts/main.phtml to make sure the css files and js files are included in my project.

Code to place in the head tag to include the css and javascript files:

<!-- First we need jquery -->
<script src="/js/jquery-1.3.2.min.js" type="text/javascript"><!--mce:0--></script>
 
<!-- the custom jquery-ui javascript -->
<script src="/js/jquery-ui-1.7.2.custom.min.js" type="text/javascript"><!--mce:1--></script>
 
<!-- the javascript where I put all of my DOM ready code -->
<script src="/js/init.js" type="text/javascript"><!--mce:2--></script>
 
...
 
<!-- Main site stylesheet -->
 
<!-- custom jquery-ui stylesheet -->

Now, you can get all fancy and use Zend Framework’s headScript, headLink, and headStyle helpers to append everything somewhere up the request dispatch cycle, but this is just a simple website that doesn’t use any logic to append certain styles or javascript. Every page gets everything, so let’s just keep it simple for now.

The HTML for the Modal Dialog

The HTML for the exit survey needs to go on the contact page (app_jsc/views/scripts/contact-us/index.phtml) and stay hidden until we call the dialog() method on it.

<div id="survey" style="display: none;" title="Before you go...">
 
Would you mind telling us why you're leaving this page?
<form id="survey-form" accept-charset="utf-8" method="post">
<input name="reasons" type="radio" value="Don't want to leave email" /> <span class="reason">You want to contact us, but don’t want to leave your email address</span>
<input name="reasons" type="radio" value="CAPTCHA trouble" /> <span class="reason">You want to contact us, but had trouble with captcha verification</span>
<input name="reasons" type="radio" value="Got her by accident" /> <span class="reason">You got to this page by accident</span>
<input name="reasons" type="radio" value="No interest in contacting" /> <span class="reason">You have no interest in contacting us</span>
  </form></div>

The Javascript

I like to put all of my DOM ready and onload code in a file called init.js and then include that on every page. I can hook page-specific javascript code on the unique body id that I’ve already set up. Here’s my init.js file:

$(document).ready(function(){
 
  // Check the radio button associated with the label
  $('span.reason').click(function(e){
    $(this).prev('input:first').attr('checked',true);
  });
 
  // Bind function to the click events of the navigation links
  $('#contact-us-index #topnav a, #contact-us-index #navigation a').click(function(e) {
    // Prevent the browser from loading the page the user tried to visit
    e.preventDefault();
 
    // Save the URL of where the user wanted to go
    destination = $(this).attr('href');
 
    // Show the exit survey
    showExitSurvey();
  });
 
});
 
function showExitSurvey()
{
  $('#survey').dialog({
    width: 500,
    bgiframe: true,
    modal: true,
    close: function() { $('#survey').dialog('destroy'); },  // Destroy the dialog.  Allows it to appear again if closed.
    buttons: {"Continue >>" : log_answer }                  // Add a continue button that logs the answer when clicked
  });
}
 
function log_answer() {
  $.ajax({
    type: "POST",
    url: "/contact-us/abandon/format/text",
    data: $("#survey-form").serialize(),
    dataType: "text",
    complete: function() { $(location).attr('href',destination); }
  });
  return;
}

The comments pretty well explain what is going on here, but lets discuss the basic flow. I like for the text associated with a radio button or check box on a form to select the radio button or checkbox when clicked, so that’s what my first bit of code does. When the text in the span tag is clicked, the first previous radio button sibling is checked.

Next, I’m going to assign a function to the click event of the page navigation links. Notice, I’m using my bodyId hook to only bind the click event to navigation links on the contact page. When the user clicks on a link, I want to stop the browser from taking them to the page they wanted, so I call preventDefault() on the click event. I’ll need to know where the user was going in order to redirect them after they fill out the exit survey, so I save the destination for later.

Finally, we call the showExitSurvey() function. This defines our jQuery modal dialog. The close option has a function associated with it that destroys the dialog box. If the user clicks on the X in the top right corner of the dialog to close it and then clicks on a link to leave the contact page again, this allows the dialog to reappear. I’m only defining one button on this dialog because I want to make it as simple as possible. I don’t want to force the user to enter an answer. They should just be able to hit the continue button and get on with what they were doing. The continue button has a callback associated with it, log_answer. Let’s take a look at that function.

The log_answer() function is where we build the AJAX call to our script that processes the survey. I’m simply sending the data as a POST request to our controller. I serialize the data from the form and tell jQuery to expect the AJAX response in plain text. When the AJAX request is complete, I forward the user on to where they wanted to go in the first place. I like to use the complete option instead of success. The complete event fires after the success and error events of the request. It’s pretty much the last event to be fired during the AJAX request cycle, so you can be sure that everything is done. In a more complex setup, you could have other things happen during the success and error events before redirecting, but here, I just want it to fail silently and let the user get on with their browsing.

A Word About When a User Closes the Browser Window

It would be nice to administer the survey when the user tries to close their browser window. Unfortunately, there is no good cross-browser way that I know of (commenters, got any ideas?) to implement this. Gmail users have seen something similar to this when they try to close the browser window before finishing a new email. It will say something like, “Are you sure you want to leave this page?” warning us that our changes will be lost. This topic (the onbeforeunload event) has been covered in great detail by many other bloggers. Check out Patrick Hunlock’s great article on the matter, for example. The bottom line is that, while it is possible to display a confirm message to prevent changes from being lost when we close a browser window, it is another matter entirely to collect data from a form and send the results to an asynchronous processing script.

The Controller

I need to tell my controller which actions can respond to AJAX requests. You do this by making use of the AjaxContext action helper. In this example, I’m using plain text as the AJAX response, so I’ll need to define this as a new context. I could easily have used xml or json as the response type. These are built in context types in Zend Framework, but this will give us an opportunity to see how to define a new context type for a controller action in Zend Framework. First, I need to get the AjaxContext helper, add my new context, then associate that context with the abandonAction() in my controller.

class ContactUsController extends Zend_Controller_Action
{
 
  public function init()
  {
    $ajaxContext = $this->_helper->getHelper('AjaxContext');
    $ajaxContext->addContext('text',
      array(
        'suffix' => 'text',
        'header' => array('
          Content-Type',
          'text/plain')
        )
      )
      ->addActionContext('abandon','text')
      ->initContext();
  }
}

What we’re doing here is using the addContext method to define our new ‘text’ context. After we define it, we can tell the controller that the abandon action can respond to XMLHttpRequests with this new context. The client request will be to /contact-us/abandon/format/text. You could just as easily say /contact-us/abandon?format=text.

View Scripts

First, let’s add the view scripts needed for the abandon action. Create two new files:

app_jsc/
  views/
    scripts/
      contact-us/
        abandon.phtml
        abondon.text.phtml

The first file, abandon.phtml, will be rendered if you type http://www.domain-name.com/contact-us/abandon/ into a browser. You don’t really need this file if you don’t care that an error is thrown should someone go to the URL. The second file, abandon.text.phtml, is the context-specific view script that will be rendered only if the controller detects an XMLHttpRequest (in other words, AJAX) to the abandon action. Note, that if you try to put http://www.domain-name.com/contact-us/abandon/format/text into the browser, the controller will still render the abandon.phtml view script because it’s not an AJAX request.

Here’s what’s in my abandon.text.phtml and my abandon.phtml file.

response ?>

The abandonAction()

class ContactUsController extends Zend_Controller_Action
{
  public function abandonAction()
  {
    // Bail if it wasn't a POST request
    if(!$this->_request->isPost())
    {
      $this->view->response = "false";
      return;
    }
 
    // Fetch the post variables into a local array
    $post = $this->_request->getPost();
 
    // If they selected nothing, reason set as no-reason, otherwise
    // it's set as the reason they selected
    $reason = empty($post['reasons'])  ? "No reason given" : $post['reasons'];
 
    // Set up a new logger that writes to a file
    // Log the reason
    $logger = new Zend_Log();
    $writer = new Zend_Log_Writer_Stream(APP_PATH . "/logs/contact-abandon-log.txt");
    $logger->addWriter($writer);
    $logger->log($reason,Zend_Log::INFO);
 
    // Tell the view that we're finished
    $this->view->response = "done";
  }
}

The first thing that happens here is the action just bails out if we don’t have a HTTP POST request. Then we’re going to use Zend_Log to create our log file. Passing a string to Zend_Log_Writer_Stream will always try to open a file in append mode or create the file if it doesn’t exist. So our log will just build and build each time this action is called.

Note that I did not call disableLayout() anywhere. That’s because the AjaxContext helper disables this for us. An AJAX request to this action will only render the code and text in the abandon.text.phtml view script.

So, now we’re logging people’s responses when they leave our fabulous page. Now to set up the script that will email the results daily.

The Emailer Script

I want a script that will check the contents of the log, email me the results, then clear out the log for the next day’s data.

app_jsc/
  cron_scripts/
    email-results-of-log.php

// Add zf library files to include path and require mailer
ini_set(
  'include_path',ini_get('include_path') .
  PATH_SEPARATOR . dirname(__FILE__) . "/the/relative/path/to/your/zf_library_files");
require_once('Zend/Mail.php');
 
// Get the contents of the log file
$filename = "/absolute/path/to/your/application/app_jsc/logs/contact-abandon-log.txt";
$contents = file_get_contents($filename);
 
// Bail out if there is nothing to report
if(empty($contents)) {exit(1);}
 
// Empty the log file
$handle = @fopen($filename,'w');
fclose($handle);
 
// Now send the mail
$body_html = nl2br($contents);
$mail = new Zend_Mail();
$mail->setFrom('info@thedomain.com',"Some Name");
$mail->addTo('person@test.com','Your Name');
$mail->setSubject('Reasons People Abandoned Contact Page - ' . date('Y-m-d'));
$mail->setBodyHtml($body_html);
$mail->send();

Pretty simple really. The only tricky part is making sure you add the Zend Framework library files to your include path. Then you can use Zend_Mail as a standalone component. That’s one of the things I like about Zend Framework. The ability to use parts of it as needed in your standalone scripts.

Schedule the Emailer to Run Automatically With Cron

I want my emailer script to send me the log file results every morning at 8:30am. That means executing this script from cron. Cron is just a task scheduler for unix/linux. If you’re not familiar with it, check it out, but chances are, if you’ve gotten this far in this article, you’re probably aware of it. You’ll need to work with your web host to find out how to edit your crontab. In this hosting environment, I have shell access, which allows me to use lots of powerful command line tools on the server. To edit my crontab, I type:

crontab -e

Now, in goes the following:

30 8 * * * php app_jsc/cron_scripts/email-results-of-abandon-log.php

Save the changes to your crontab. This will execute the command, “php app_jsc/cron_scripts/email-results-of-abandon-log.php,” in my user’s home directory every day at 8:30am. The email you receive every day should look something like this:

2009-11-30T15:30:43-05:00 INFO (6): No reason given
2009-11-30T15:43:04-05:00 INFO (6): Didn't want to leave email address

Obviously, if you’re site’s really busy, the log will grow quite large and maybe you’ll want to come up with a better way of examining the data.

UPDATE: It appears this is broken again when upgrading to WordPress version 2.9.2.  Currently working on a fix.

The Problem

I was developing a custom WordPress theme for a client in a shared hosting environment when I ran into a problem with the WP Post Thumbnail (WPPT) plugin.  When editing a post in the WordPress admin, the loading spinner image next to the Preset1 tab never disappeared.  It just kept spinning and spinning.  To troubleshoot, I enabled the console panel in Firebug to examine the AJAX request/response data.  As is common in the AJAX paradigm, the response is sent back to the requesting page as JSON.  But the Firebug console reported a JSON parse error when trying to evaluate the AJAX response.

WPPT makes use of PHP’s json_encode() and json_decode() functions to encode/decode data.  The JSON extension is bundled with PHP >= 5.2.0 by default, but a lot of shared hosting environments have older versions of PHP where these functions are unavailable.  The WPPT plugin accounts for this and bundles its own versions of the functions to be used should native PHP functions be unavailable.  In wp-content/plugins/wp-post-thumbnail/wppt.php, it checks for the presence of the JSON extension and includes it’s own file if it doesn’t exist:

if ( !function_exists('json_encode') )
	require_once( dirname(__FILE__) . '/includes/json.php' );

Unfortunately, the functions bundled with this plugin do not produce 100% valid JSON and you’ll still get the parse error.  So what to do?

A Real Replacement For json_encode() and json_decode()

For a true json_encode() equivalent, I turned to PHP PEAR.  There is a Services_JSON package available.  You can donwload this package and get the source code or just copy and paste the code here.  Simply replace the code in the wp-content/plugins/wp-post-thumbnail/json.php file with this code.  But you’re not done yet.  Keep reading.

Avoid Conflicts With Other WordPress Plugins

There are other WordPress plugins that use this code for their own json_encode() substitutes.  Twitter Tools is one.  If you have Twitter Tools installed and include this code with the WPPT plugin, your whole WordPress installation will break because you’ll be declaring the classes Services_JSON and Services_JSON_Error in two places which isn’t allowed.  To avoid this, I namespaced the class names in the json.php file by prepending Wppt_ to the class names.

Do a search and find all instances of these lines:

class Services_JSON
class Services_JSON_Error

Replace with these respectively:

class Wppt_Services_JSON
class Wppt_Services_JSON_Error

Final Step

Add the following code at the end of the wp-content/plugins/wp-post-thumbnail/includes/json.php file so that when the WPPT plugin calls json_encode() or json_decode(), these functions will be called:

function json_encode($data) {
	$json = new Wppt_Services_JSON();
	return( $json->encode($data) );
}
 
function json_decode($data) {
	$json = new Wppt_Services_JSON();
	return( $json->decode($data) );
}

That should do it.  The WPPT plugin should work without any errors.  One thing to note is that any subsequent plugins that rely on the PHP’s JSON extension will also use the functions you just defined above.  I’m willing to live with this since the Services_JSON package is vetted by virtue of being part of PEAR.  Should the client’s web host decide to version up PHP, all plugins will start using the native JSON functions and mine will simply fade into obscurity.

After dealing with rounded corner images, CSS hacks, javascript hacks, and extraneous markup hacks for years, I decided it was time to put this thing to rest and come up with a solution that works for every design I’m translating into CSS, no matter where the rounded corners appear (nav bar, floating divs, on images, on background images, etc…)

If you know anything about me you know that I’m a stickler for semantic markup and clean code in general. XHTML and CSS that validate. So you’ll get an idea of my frustration level with this rounded corner issue when you hear that the solution I’ve settled upon doesn’t validate CSS. Yes that’s right. However I’m sleeping just fine and I’m quite happy that this solution is keeping me from spending 20 hours to create a style sheet!

So what is it you ask?

In short, I’m using native CSS rounded corner support for all browsers except IE… and for IE I’m implementing the BEST javascript-based rounded corner solution I’ve found to date: DD_roundies. So in my CSS I use the standard Gecko and Webkit syntax for achieving my rounded corners. I then use conditional comments to include the DD_roundies solution for any version of IE. It’s that simple.

I’ve tried EVERY single rounded corner javascript library out there. I’m not kdding… at least 20 different solutions. None work as well in IE as DD_roundies. In fact, conditional comments aren’t even 100% necessary since DD_roundies won’t invoke on any browser except the IE’s! So in the end I get a style sheet that validates EVERYTHING except the border-radius properties, and a design that can include rounded corners almost anywhere I desire. It’s a sacrifice I’m willing to live with.

Submission URLs

These social bookmarking links are powered by “submission URLs.” This is simply a web address (URL) specific to the social bookmarking web site, to which you can “submit” or “share” your article or web page. Each site has it’s own URL that they’ve setup. Programmers like me just make sure that on every page of the site, the little icon for sharing this page on Facebook (or whatever site I choose) links to Facebook properly using the submission URL. So in short, Jane Doe visits my site, finds an incredibly interesting article and wants to share it with her family who all have Facebook accounts. She clicks on my “Share this on Facebook” icon and she’s redirected to the Facebook site (by the submission URL) and after she logs in, uses Facebook’s interface for posting my article to her profile. Done!

So what’s the problem?

Well there are literally HUNDREDS of social bookmarking sites out there. Everyday more are created while others are gaining in popularity. Well that’s a lot of submission URLs for me to find if I want to make social bookmarking available on my site! Would you believe that it took me and a coworker several HOURS to find a resource that simply compiled a bunch of submission URLs?! And we’re two able-bodied, internet-savvy people. I was shocked at how difficult it was to track down submission URLs for this project. And going directly to each social bookmarking site wasn’t much help! It seems as though this information is buried deeply in help documentation. Why??

The solution

Fortunately we eventually stumbled upon two web sites that were of the most help:

• Kevin van Zonneveld’s “List of social bookmarking sites”
• Jquery’s Bookmark plug-in!

I was able to easily find submission URLs for the 8-10 sites I needed, directly from these sites or by viewing source. Nice!!

Microsoft announced on Tuesday, January 29, 2008, on the adCenter Official Blog that Microsoft adcenter and The Wall Street Journal Digital Network reached an agreement in which Microsoft will become the exclusive provider of contextual and paid search advertisements for The Wall Street Journal Digital Network (WSJDN). Wall Street Journal Digital Network includes many popular websites including WSJ.com, Barrons.com, Marketwatch.com, allthingsd.com and other sites.

Wall Street Journal Digital Network (WSJDN) reaches worldwide viewers of over 20 million users & serves over 330 million page views per month. This agreement marks an exciting increase in reach and significance for adCenter customers bidding on financial services keywords. Contextual advertising will automatically begin on the WSJDN starting in February 2008. Now Microsoft adCenter customer can extend their ads to the WSJDN in February, 2008. Timing for Paid Search advertising on WSJDN is still being determined by Microsoft.

Microsoft also mentions many content tips at there official blog. Here are some of them:

• Increasing your bids to position your ads to appear.
• Monitor your ROI with conversion tracking.
• Write compelling ad copy.
• Contextual ads reach targeted audiences.

Now advertiser can list there business on high traffic editorial pages – ad space that was completely reserved for limited advertisers. You may find more information about this here. ]]> http://www.boomtownig.com/blog/adcenter-content-ads/66/feed/ 0