First and foremost, in your default (action) view script simply output the form as usual:

<div class="formContainer">
  <?php echo $this->form ?>
</div>

Then, in your derived Zend_Form class set your custom view script that takes care of rendering the form the way you need it:

/**
 * Custom Zend_Form view script example.
 * @author matthias.kerstner
 */
class Custom_Form extends Zend_Form {

    public function init() {
        $this->setDecorators(array(array(
                'viewScript',
                array(
                    'viewScript' => '_customForm.phtml',
                    array('formId' => 'CustomForm', 'formClass' => 'customForm')
            ))));

Finally, the custom Zend_Form view script looks like the following. Note that it uses additional parameters that you can specify in Custom_Form.

<?php
$params = $this->element->getDecorator('ViewScript')->getOptions();
$formId = $params[0]['formId'];
$formClass = (isset($params[0]['formClass'])) ? $params[0]['formClass'] : '';
?>

<form id="<?php echo $formId ?>"
      class="<?php echo $formClass ?>"
      method="<?php echo $this->element->getMethod() ?>"
      action="<?php echo $this->element->getAction() ?>"
      enctype="<?php echo $this->element->getEnctype() ?>">

    <?php
    echo $this->element->my_element_1;
    echo $this->element->my_element_2;

    echo $this->element->submit;
    ?>

</form>

Don’t forget to call parent::init(); in any of your derived classes. Using custom view scripts gives you the full power to design your form view, but remember that in contrast to using built-in decorators you need to echo your elements manually in your view script.

This is crucial for instance if your controller is required to return JSON or XML as part of a service request.

// in your controller
// 1. disable layout rendering
$this->_helper->layout->disableLayout();
$this->_helper->viewRenderer->setNoRender();

// 2. customize Content-Type
$this->getResponse()->setHeader('Content-Type', 'application/json; charset=utf-8');

// 3. echo' content as usual, e.g. JSON
echo json_encode(array('foo' => 'bar'));

Copyright 2012. Magnifying the Universe by Number Sleuth.

/**
 * An abstraction class for Zend_Mail.
 * @author matthias.kerstner
 */
class Custom_Plugin_Mailer {

    /**
     * Assembles $mail but does not send it.
     * @param array $to
     * @param string $subject
     * @param string $body
     * @param array? $from
     * @param bool? $html
     * @param bool? $appendSignature
     * @param bool? $archive
     * @param string? $encoding
     * @param Zend_Locale? $locale
     * @return bool|Zend_Mail
     */
    public static function assemble($to, $subject, $body, $from = null, $html = false, $appendSignature = true, $archive = true, $encoding = 'UTF-8', $locale = null) {
        return self::send($to, $subject, $body, $from, $html, $appendSignature, $archive, $encoding, false, $locale);
    }

    /**
     * Sends mail.
     * @param array $to [0=email, 1=name]
     * @param string $subject
     * @param string $body
     * @param array? $from [0=email, 1=name]
     * @param bool? $html
     * @param bool? $appendSignature
     * @param bool? $archive
     * @param string? $encoding
     * @param bool? $sendDirectly
     * @param Zend_Locale? $locale
     * @param array? $toBCC [0=email, 1=name]
     * @return bool|Zend_Mail true on success, false on error, Zend_Mail
     *         if $sendDirectly is false
     */
    public static function send($to, $subject, $body, $from = null, $html = false, $appendSignature = true, $archive = true, $encoding = 'UTF-8', $sendDirectly = true, $locale = null, $toBCC = null) {
        $config = Zend_Registry::get('Zend_Config');
        $translate = Zend_Registry::get('Zend_Translate');
        $_locale = $locale instanceof Zend_Locale ? $locale : Zend_Registry::get('Zend_Locale');
        $mail = new Zend_Mail($encoding);

        if (APPLICATION_ENV !== 'production') { // DEBUG MODE
            $mail->setFrom($config->email->noreply->email, $config->email->noreply->sender);
            $mail->addTo($config->email->debug->email, $config->email->debug->sender);
        } else { // PRODUCTION MODE
            if ($from === null) {
                $mail->setFrom($config->email->noreply->email, $config->email->noreply->sender);
            } else {
                if (is_array($from) && count($from) == 2) {
                    $mail->setFrom($from[0], $from[1]);
                } else {
                    throw new Exception('Failed to send email');
                }
            }

            if (is_array($to) && count($to) == 2) {
                $mail->addTo($to[0], $to[1]);
            } else {
                throw new Exception('Failed to send email');
            }
        }

        $mail->setSubject($subject);

        if ($appendSignature) {
            $br = $html ? "<br>" : "\n";
            $body .= $br . $br
                    . $translate->_('DEFAULT.MAIL.SIGNATURE', $_locale);
        }

        if ($html) {
            $mail->setBodyHtml($body);
        } else {
            $mail->setBodyText($body);
        }

        if ($archive) {
            $mail->addBcc($config->email->archive->email, $config->email->archive->sender);
        }

        // BCC
        if (is_array($toBCC) && count($toBCC) == 2) {
            $mailBCC = new Zend_Mail($encoding);
            $mailBCC->setFrom($config->email->noreply->email, $config->email->noreply->sender);
            $mailBCC->addTo($toBCC[0], $toBCC[1]);
            $mailBCC->setSubject("BCC: " . $subject);
            if ($html) {
                $mailBCC->setBodyHtml("BCC:<br />" . $body);
            } else {
                $mailBCC->setBodyText("BCC:\n" . $body);
            }
            $mailBCC->send();
        }

        if (!$sendDirectly) {
            return $mail;
        }

        try {
            if (!$mail->send()) {
                throw new Exception('Failed to send mail to "'
                        . $to[0] . '" with subject "' . $subject . '"');
            }
        } catch (Exception $e) {
            return false;
        }

        return true;
    }

}

Recently, I had to migrate a certain amout of these mailboxes to Microsoft Outlook. Unfortunately, Outlook is not capable of importing plaintext emails by drag-and-drop or via its import/migration assistent. As opposed to Outlook, Windows Live Mail is able to handle the import of emails by just dropping them in the respective folder. But, this only works if the e-mail files have an .eml ending (which is rather poor design, but ok…).

So, in order to import them in Windows Live Mail you need to add the .eml extension to all emails. Fortunately, with the onboard tool offered by most *nix systems you can easily achieve this:

find . -type f -exec mv '{}' '{}'.jpg \;

As always, find recursively iterates over all files and folders and using the -f flag matches all files, and applies the mv command on them, thus adding .eml to them.

Now that we have e-mails that also Windows’s apps are able to handle we can just drag-and-drop them in Windows Live Mail. That’s it!

First of all, you need to enable mod_env for your Apache setup. Secondly, if you are running PHP not as Apache module but rather using FastCGI you need to follow the steps provided here.

Once enabled, you can easily set your enviroment variables in your httpd.conf or .htaccess file directly:

SetEnv APPLICATION_ENV development

In order to get previously set environment variables from within PHP simply use the following function:

getenv()

1. Install qTranslate (http://www.qianqin.de/qtranslate/)
2. edit the plugin settings to enable/disable your supported languages
3. edit your WP layout template (e.g. sidebar.php) and add to qTranslate widget:

   echo qtrans_generateLanguageSelectCode('both');
   

Currently, the qTranslate widget supports to following styles:

• image
• dropdown
• text
• both

For more information on the parameters of qtrans_generateLanguageSelectCode have a look at plugins/qtranslate/qtranslate_widget.php.

If you are looking for a plugin to support multilingual text have a look at the gText widget which works like a charm in combination with qTranslate.

class Form_FileUpload extends Zend_Form {

    public function init() {

        $this->setAttrib('enctype', 'multipart/form-data');

        $element = new Zend_Form_Element_File('image');
        $element->setLabel('Some picture');
        $element->addValidator('Count', false, 1);
        $element->addValidator('Size', false, 204800);
        $element->addValidator('Extension', false, 'jpg,png,gif');
        $element->setRequired(true);

        $this->addElement($element);

        $this->addElement('text', 'someText', array(
            'filters' => array('StringTrim'),
            'label' => _('Some Text'),
            'decorators' => array(
                'viewHelper', array(
                    'Label', array('class' => 'label')
                ),
                'Errors'
            ),
            'validators' => array(
                array('StringLength', true, array(5, 255))),
            'id' => 'SomeText'
        ));
}

Now that we have a form let’s add the logic in the corresponding controller. We only need one action (imageAction) to process POST requests and GET requests:

public function imageAction() {

  $form = new Form_FileUpload();

  if ($this->getRequest()->isPost()) {
    $post = $this->getRequest()->getPost();

    if ($form->isValid($post)) {
     $upload = new Zend_File_Transfer_Adapter_Http();
     $upload->setDestination(realpath(APPLICATION_PATH . '\..\data\upload'));

     try { //be sure to call receive() before getValues()
       $upload->receive();
     } catch (Zend_File_Transfer_Exception $e) {
       $e->getMessage();
     }

     $formData = $form->getValues(); //be sure to call this after receive()

     $filename = $upload->getFileName('image'); //optional info about uploaded file
     $filesize = $upload->getFileSize('image');
     $filemimeType = $upload->getMimeType('image');

     $dstFilePath = '/images/'.$filename;

     $filterFileRename = new Zend_Filter_File_Rename(array('target' => $dstFilePath, 'overwrite' => true));
     $filterFileRename->filter($filename); //move uploade file to destination
   }
 }

 $this->view->form = $form;
}

That’s all there is to it. receive() processes the uploaded file, i.e. checks if everything went well. In order to move uploaded files to certain destination folders you can use Zend_Filter_File_Rename. Unlike the name suggests it does not only rename files but also is capable of moving files.

Make sure to call receive() before getValues() as Zend_Form otherwise messes up the file upload.

Fortunately, there exists a quick fix for this problem. Simply replace corresponding code with the following in the function mytheme_comment in functions.php:

<span class="comment-meta commentmetadata"><a href="<?php echo htmlspecialchars( get_comment_link( $comment->comment_ID ) ) ?>"><?php echo mysql2date('Y/m/d/ H:i', $comment->comment_date);?></a><?php edit_comment_link(__('[Edit]','zbench'),' ','') ?></span>

Pay special attention to

<?php echo mysql2date('Y/m/d/ H:i', $comment->comment_date);?>

which replaces

<?php printf(__('%1$s at %2$s', 'zbench'), get_comment_date(),  get_comment_time()); ?>

1. du
2. sort

du -h /var/www/ --max-depth=1 | sort -h

Whereas du gives you the storage space occupied by certain files and folders, sort actually sorts the resulting list.

Using the additional parameter max-depth you can specify the folder depth which du will use to echo files and folders on the shell during its recursive parsing process.

Basically, what we want to achieve is to be automatically notified when a user changes a marker’s position. Clearly, this can be done by registering a listener on the marker which will fire an event once the marker has been dropped on the destination coordinates. After all, we want to be given these coordinates in order to carry out further actions.

But first of all we need to create a new map instance and bind it to a DOM container element, as explained in the official reference documentation:

var latLng = new google.maps.LatLng(lat,lng);

var options = {
  zoom: 13,
  center: latLng,
  scrollwheel: false,
  disableDoubleClickZoom: true,
  mapTypeId: google.maps.MapTypeId.ROADMAP,
  locale: LANG
}

var map = new google.maps.Map(document.getElementById(canvasDomId), options);

Once we have the map instance we are able to add markers, as shown in the following code snippet:

var marker = new google.maps.Marker({
  position: latLng,
  map: map,
  title: title,
  draggable: true
});

In order for the marker to be draggable across the map we need to set the attribute draggable to true.

Finally, in order to be notified of changes of the marker’s position we need to add an event listener to the marker:

google.maps.event.addListener(marker, 'drag', function(event) {
  console.debug('new position is '+event.latLng.lat()+' / '+event.latLng.lng());
});

google.maps.event.addListener(marker, 'dragend', function(event) {
  console.debug('final position is '+event.latLng.lat()+' / '+event.latLng.lng());
});

Whereas the event drag is fired whenever the user drags the marker and slides it across the map, the dragend is triggered only when the marker is dropped.

Thus, instead of posting through your regular FB user account you want to directly post to a fanpage as the page’s admin (owner), without the hazzle of being forced to login for each post.

Fortunately, there are only a few simple steps required to achieve this functionality which will be explained in the following.

Request App access token

First and foremost, the app through which you will be posting to the fanpage (as its admin) needs to request certain permissions, which can be done using the following link:

https://www.facebook.com/dialog/oauth?client_id=YOUR_APP_ID&client_secret=YOUR_APP_SECRET&redirect_uri=YOUR_REDIRECT_URL&scope=read_stream,publish_stream,offline_access,manage_pages

In order to be able to use this link you need to determine YOUR_APP_ID and YOUR_APP_SECRET via http://developers.facebook.com. Furthermore, in order to be able to post to the fanpage programmatically you need the offline_access permission. Additionally, to impersonate the fanpage’s admin manage_pages and publish_stream permissions are required.

Please note that FB is planning to deprecate the offline_permission in favor of a functionality to extend the lifespan of existing access_tokens. Read more here: https://developers.facebook.com/roadmap/offline-access-removal/

Based on the URL provided above you will be redirected to FB’s login page in case you are not already logged in as the account associated for YOUR_APP_ID. Once logged in, you will be redirected to YOUR_REDIRECT_URL where you’ll find the access token as a GET parameter.

Alternatively, if you do not operate your own test environment for checking the response of this call (i.e. YOUR_REDIRECT_URL) you can simply use the following call, as stated in the client-side authentication flow in the official documentation.

https://www.facebook.com/dialog/oauth?client_id=YOUR_APP_ID&redirect_uri=https://www.facebook.com/connect/login_success.html&response_type=token&scope=read_stream,publish_stream,offline_access,manage_pages

This step needs to be done only once, unless you decide to change your permissions at a later point which will require you to re-authorize using the same link.

Be sure to check out Authentication section in the Facebook Developer notes.

In case you get the “An error occurred. Please try again later.” message make sure that YOUR_REDIRECT_URL matches the one of your FB app.

Request (Fan)Page access token

Once you have acquired the permissions to post through your app the next step is to request the access token for the fanpage, based on the app’s authentication previously requested. Using this token you will be able to post on the fanpage through your app without the need to go through the client-side authentication process every time.

$pageInfo = $facebook->api("/$pageId?fields=access_token");

$pageInfo now holds an array, including the field access_token. Based on this access token we are ready to finally post to the fanpage as one of its admin (impersonation).

Alternatively, in case this call does not return the access token you can issue a direct call to the OpenGraph API, as mentioned in server-side authentication flow:

https://graph.facebook.com/oauth/access_token?client_id=YOUR_APP_ID&redirect_uri=YOUR_REDIRECT_URI&client_secret=YOUR_APP_SECRET&code=CODE_GENERATED_BY_FACEBOOK

The code parameter represents the access token returned in the app-authentication step, which in our case does not expire due to the offline_access permission.

Post to Fanpage as Admin

try {
  $args = array(
    'access_token' => $page_info['access_token'],
    'message' => 'TEST'
  );
  $post_id = $facebook->api("/$pageId/feed", "post", $args);
} catch (FacebookApiException $e) {
  die($e->getMessage());
}

The final PHP code

Although the first step (request app access token) can also be done programmatically, normally you will do this manually as this is only required once. Acquiring the fanpage access token can be easily done on each request.

Please contact FB’s Graph API for all methods. The following code snippets shows how to post a message to the fanpage. For instance, use LINK instead of FEED to post links.

$appid = 'XXX';
$appsecret = 'XXX';
$pageId = 'XXX';

$facebook = new Facebook(array(
  'appId' => $appid,
  'secret' => $appsecret,
  'cookie' => false,
));

$user = $facebook->getUser();

if ($user) {
  try {
    $page_info = $facebook->api("/$pageId?fields=access_token");
    if (!empty($page_info['access_token'])) {
      $args = array(
        'access_token' => $page_info['access_token'],
        'message' => 'TEST'
      );

      $postId = $facebook->api("/$pageId/feed", "post", $args);
    }
  } catch (FacebookApiException $e) {
    error_log($e);
    $user = null;
 }
}

That’s all there is to it!