Classes Naming Convention

It depends on what you are naming, it varies if you are naming a component or module or a plugin. If the class is a part of Component, the general syntax is Com<YourComponentName><M/V/C><FileName>.

For Example: Let us consider, we have a component named CoolBanner. If we want to define a Banner Controller the class name should be ComCoolbannerControllerBanner. And if we want to define a model class, the class name should look like ComCoolbannerModelBanner.

But there are other things to consider when naming your class. But to understand better, we can say the naming of the class depends on the folder structure of your component and filename that will contain your class. You will generally store all your controllers in controllers folder of your component, all models in models folder, filters in Filters folder and like wise views in your views folder. (Views classname are exception to above syntax)

Lets us review how this folder structure and class naming map to each other. As per above example, we should store

ComCoolbannerControllerBanner in /component/com_coolbanner/controllers/banner.php
ComCoolbannerModelBanner in /component/com_coolbanner/models/banner.php
ComCoolbannerModelBanners in /component/com_coolbanner/models/banners.php
ComCoolbannerFilterBannerid in /components/com_coolbanner/filters/bannerid.php

Also if you have some extra level deep folders like /components/comcoolbanner/databases/ we should write the classname that reflects this level too. So for example, let us assume we have 3 folders in /components/comcoolbanner/databases/ folder namely tables , behaviors and rowsets and also have categories.php, hits.php and categories.php in these folders in order. The class name should reflect these folder structure.

ComCoolbannerDatabaseTableCategories should go in /components/com_coolbanner/databases/tables/categories.php
ComCoolbannerDatabaseBehaviorHits Should go in /components/com_coolbanner/databases/behaviors/hits.php
ComCoolbannerDatabaseRowsetCategories Should go in /components/com_coolbanner/databases/rowsets/hits.php

Views are exception to this naming convention. A View’s filename uses the document type that is being used to render the view. The class ComCoolBannerViewBannersHtml will render HTML document type for the banners view and should be stored in the file /components/comcoolbanner/views/banners/html.php. You can even add your own document type format at will. For example if you want a view to be rendered as json, you can create a view class ComCoolbannerViewBannersJson and store it in /components/comcoolbanner/views/banners/json.php

Likewise you can name your classname depending on the folder structure.

You can even follow the above naming convention to name your modules and plugins as well. The only deviation from above syntax is the prefix used to start class name. Modules start with Mod, Plugins start with Plg and Components Start Com. See below

ModCoolbannerDefault will be stored in /modules/mod_coolbanner/default.php
ModCoolbannerView will be stored in /modules/mod_coolbanner/view.php
PlgSystemCoolbanner will be stored in /plugins/system/coolbanner.php
PlgSystemCoolbannerDefault will be stored in /plugins/system/coolbanner/default.php

And likewise.

We will continue the next part of this series in my next post. We will discuss about table and field naming convention in nooku. I hope this was useful for people starting with nooku. Best of luck.

I will try to write my findings, tutorials and tweaks on Nooku in coming days. These are basically my writeup and is not affilated with Nooku or Joomla itself and If there are any errata, the blame is on me . You can even send me suggestion on topics for Blog and I will try to explain explain within my knowledge.

If you are running Linux or FreeBSD Operating System on your local computer and have access to server shell, use ‘scp’ command to copy files and directories to the server.

To copy files

# scp your_filename login@yourserver.com:path

To copy entire folder/directories

# scp -r your_directoryname login@yourserver.com:path

If you are using windows OS, you can use pscp available from Putty Download Page here

Cheers!

Joomla Logo

Out of the box, Joomla! does a great job of managing the content needed to make your Web site sing. But for many people, the true power of Joomla! lies in the application framework that makes it possible for developers all around the world to create powerful add-ons that are called Extensions. An Extension is used to add capabilities to Joomla! that do not exist in the base core code. Here are just some examples of the hundreds of available Extensions:

* Dynamic form builders
* Business or organisational directories
* Document management
* Image and multimedia galleries
* E-commerce and shopping cart engines
* Forums and chat software
* Calendars
* E-mail newsletters
* Data collection and reporting tools
* Banner advertising systems
* Paid subscription services
* and many, many, more

You can find more examples over at our ever growing Joomla! Extensions Directory. Prepare to be amazed at the amount of exciting work produced by our active developer community!

A useful guide to the Extension site can be found at:

http://extensions.joomla.org/content/view/15/63/

Types of Extensions

There are five types of extensions:

* Components
* Modules
* Templates
* Plugins
* Languages

You can read more about the specifics of these using the links in the Article Index – a Table of Contents (yet another useful feature of Joomla!) – at the top right or by clicking on the Next link below.

Component

A Component is the largest and most complex of the Extension types. Components are like mini-applications that render the main body of the page. An analogy that might make the relationship easier to understand would be that Joomla! is a book and all the Components are chapters in the book. The core Article Component (com_content), for example, is the mini-application that handles all core Article rendering just as the core registration Component (com_user) is the mini-application that handles User registration.

Many of Joomla!’s core features are provided by the use of default Components such as:

* Contacts
* Front Page
* News Feeds
* Banners
* Mass Mail
* Polls

A Component will manage data, set displays, provide functions, and in general can perform any operation that does not fall under the general functions of the core code.

Components work hand in hand with Modules and Plugins to provide a rich variety of content display and functionality aside from the standard Article and content display. They make it possible to completely transform Joomla! and greatly expand its capabilities.

Module

A more lightweight and flexible Extension used for page rendering is a Module. Modules are used for small bits of the page that are generally less complex and able to be seen across different Components. To continue in our book analogy, a Module can be looked at as a footnote or header block, or perhaps an image/caption block that can be rendered on a particular page. Obviously you can have a footnote on any page but not all pages will have them. Footnotes also might appear regardless of which chapter you are reading. Simlarly Modules can be rendered regardless of which Component you have loaded.

Modules are like little mini-applets that can be placed anywhere on your site. They work in conjunction with Components in some cases and in others are complete stand alone snippets of code used to display some data from the database such as Articles (Newsflash) Modules are usually used to output data but they can also be interactive form items to input data for example the Login Module or Polls.

Modules can be assigned to Module positions which are defined in your Template and in the back-end using the Module Manager and editing the Module Position settings. For example, “left” and “right” are common for a 3 column layout.
Displaying Modules

Each Module is assigned to a Module position on your site. If you wish it to display in two different locations you must copy the Module and assign the copy to display at the new location. You can also set which Menu Items (and thus pages) a Module will display on, you can select all Menu Items or you can pick and choose by holding down the control key and selecting multiple locations one by one in the Modules [Edit] screen

Note: Your Main Menu is a Module! When you create a new Menu in the Menu Manager you are actually copying the Main Menu Module (mod_mainmenu) code and giving it the name of your new Menu. When you copy a Module you do not copy all of its parameters, you simply allow Joomla! to use the same code with two separate settings.
Newsflash Example

Newsflash is a Module which will display Articles from your site in an assignable Module position. It can be used and configured to display one Category, all Categories, or to randomly choose Articles to highlight to Users. It will display as much of an Article as you set, and will show a Read more… link to take the User to the full Article.

The Newsflash Component is particularly useful for things like Site News or to show the latest Article added to your Web site.

Plugin

One of the more advanced Extensions for Joomla! is the Plugin. In previous versions of Joomla! Plugins were known as Mambots. Aside from changing their name their functionality has been expanded. A Plugin is a section of code that runs when a pre-defined event happens within Joomla!. Editors are Plugins, for example, that execute when the Joomla! event onGetEditorArea occurs. Using a Plugin allows a developer to change the way their code behaves depending upon which Plugins are installed to react to an event.

Language

New to Joomla! 1.5 and perhaps the most basic and critical Extension is a Language. Joomla! is released with multiple Installation Languages but the base Site and Administrator are packaged in just the one Language en-GB – being English with GB spelling for example. To include all the translations currently available would bloat the core package and make it unmanageable for uploading purposes. The Language files enable all the User interfaces both Front-end and Back-end to be presented in the local preferred language. Note these packs do not have any impact on the actual content such as Articles.

More information on languages is available from the

http://community.joomla.org/translations.html

One of the main issues we commonly run into is a non-working .htaccess file.  Apache doesn’t come with .htaccess support automatically turned on.  You’ll have to turn it on in order for .htaccess files to have an effect.  Here’s what you do:

There are two ways,

1. Edit your httpd.conf manually using a text editor like vim, nano, vi, joe whatever you like.
2. Edit your httpd.conf through Webmin

Since the Webmin version is more graphical, we’ll show you how to do it through Webmin.  If you’re using a text editor, just skip to the portion with the AllowOveride command.

1. Login to your Webmin
2. Servers>Apache Webserver
3. Go to the “Global Configuration” tab
4. Click on “Edit Config Files”
5. Search for AllowOverride and .htaccess and remove the # sign in front or type “AllowOverride All”. or Search for AllowOverride None and replace with AllowOverride All
   This should fix it permanently and allow your .htaccess files to override pretty much and directive needed.

In this short tutorial, I will tell about creating elements and using it differently on different places. Elements are special files that generally adds value to parameters. For this tutorial, I will create a color element that  can be used in different components, modules, plugins where color selection is done through a color picker. I will use moorainbow as web color picker.
Also note, I am creating this element for my adsensebingo module. Hence this code has been tested and used.

Creating Color Element File

Element file are generally single php file that has element class that extends JElement base class. The class overrides fetchElement method of JElement Base class to provide color picker.
Let us create a folder that will hold all files necessary for color element.  Let us call this folder “element”. Download the latest moorainbow library and place it in a subfolder directly below the elements folder. Now create a color.php file . This file is the element file and has a class JElementColor that extends JElement base class.
Now override fetchElement method of JElement base class. The important part of element is the fetchElement method. This method actually returns data that can be used by parameters.

A little explanation about fetchElement is necessary. method fetchElement requires 4 arguments namely
$name – is the unique name of the parameter, from the name argument.
$value – is the current value of the parameter.
$node – is a JSimpleXMLElement object representing the <param> element.
$control_name – is the parameter type from the type argument (eg. ‘category’ or ‘color’).

The fetchElement method for Color element is as below

function fetchElement($name, $value, &$node, $control_name)
{
        ob_start();
        $img=JUri::root()."modules/mod_adsensebingo/elements/moorainbow/images/rainbow.png";
        $imgx=JUri::root()."modules/mod_adsensebingo/elements/moorainbow/images/";
        static $embedded;
                if(!$embedded)
        {
            $css2=JUri::root()."modules/mod_adsensebingo/elements/moorainbow/css/mooRainbow.css";
            $jspath=JUri::root()."modules/mod_adsensebingo/elements/moorainbow/js/mooRainbow.js";
             ?>
<link
    href="<?php echo $css2;?>" type="text/css" rel="stylesheet" />
<script src="<?php echo $jspath;?>"></script>

            <?php
            $embedded=true;

        ?>
<script>

            window.addEvent('domready',function(){
//Get sibling function from http://www.sanjeevshrestha.com.np
                Element.extend({
                    getSiblings: function() {
                        return this.getParent().getChildren().remove(this);
                    }
                });
            $('.rainbowbtn').each(function(item){

         item.color=new MooRainbow(item.id, {
                    startColor: [58, 142, 246],
                    wheel: true,
                    id:item.id+'x',
                    onChange: function(color) {

                    item.getSiblings()[0].value = color.hex;
                    },
                    onComplete: function(color) {

                    item.getSiblings()[0].value = color.hex;
                    },

                    imgPath: '<?php echo $imgx;?>'

                });

                });
            });
            </script>
            <?php
        }
            ?>
            <label>
<input
    name="<?php echo $control_name;?////>[<?php echo $name;?>]" type="text"
    class="inputbox" id="<?php echo  $control_name.$name ?>"
    value="<?php echo $value;?>" size="10" />
<img
    src="<?php echo $img;? />" id="img<?php echo $name; ?>" alt="[r]"
    class="rainbowbtn" width="16" height="16" /></label>
        <?php

        $content=ob_get_contents();

        ob_end_clean();
        return $content;

    }

That is it.

Using it in Module Parameters.

Now let us use this in module parameter. Parameters are generally written in
element block. For these params block to render our color element we need to specify path to our elements folder in this params element node as below

<params addpath="[path]/elements"> </param>
--- list of <param> elements ---
</params>

In our case this is written as

<params addpath="/modules/mod_adsensebingo/elements"> </param>
<param name="foreground" type="color" default="#CC0000" label="Foreground Color" description="Select foreground color for your google ad" > </param>
-- other <param> elements
</params>

Now this block is aware of new elment type and knows where to find the element rendering code. The parameter section of module setting page now correctly shows a color picker.
You can create any kind of elments, from a simple integer list to a complex color element or elements that shows records from your component. The usage is limitless.

That is all for color element. More to come on element tutorials till then happy reading.

sudo apt-get install openjdk-6-jre sun-java6-jdk
sudo update-java-alternatives -s java-6-sun

Note: update with the latest java version
This should work with other flavor of linux too. Try with appropriate package manager.

Now try installing the android sdk again. It should work. Happy androiding..

The strtotime function not only converts the string to timestamp value but can also calculate future and past dates. Lets us see some examples

echo date("d-m-y", strtotime("- 7 days"));

This will print the date 7 days ago from current date. simple, isn’t it? yes we can pass offset values into strtotime. The offset values can be any integer followed by days, weeks, months and years. There are other predefined values like now, today, tomorrow, yesterday, first saturday, last saturday, this saturday, next saturday  and so on.

some more examples to make the concept more clear:

echo date("d-m-y", strtotime("- 7 days"));
echo date("d-m-y", strtotime("+1 weeks"));
echo date("d-m-y", strtotime("- 1 months"));
echo date("d-m-y", strtotime("+ 2 years"));
echo date("d-m-y", strtotime("now"));
echo date("d-m-y", strtotime("yesterday"));
echo date("d-m-y", strtotime("last sunday"));
echo date("d-m-y", strtotime("this monday"));
echo date("d-m-y", strtotime("+2 weeks saturday"));

and in a case where you want to find 10 days from today you can simply use
echo date(“d-m-Y”, strtotime(“+10 days”));

And yes this is that simple. Don’t do it the hard way

I have written a post about how to use jQuery with Joomla earlier. This tutorial is just a slight modification of the codes from the earlier post.
To use mootools 1.2.x with Joomla 1.5.x, follow the following steps.

1. Download the mootools core from the mootools core builder site
2. Also Download the additional plugins you will use with your installation from more builder. I recommend downloading both compressed and uncompressed files from the mootools builder. We may need uncompressed files in debuggin mode.
3. Copy these files in a folder that can be accessed by Joomla. I recommend media->system->js folder of joomla installation. The choice is yours!

I copied four files mootools-1.2.3-core.js, mootools-1.2.3-core-compressed.js, mootools-1.2.3.1-more.js and mootools-1.2.3.1-more-compressed.js to media->system->js folder. Now locate and open a file named behavior.php which is inside libraries->joomla->html->html folder. Now find a method named mootools($debug=null) and modify it as below.

function mootools($debug = null)
{
static $loaded;
$mainframe=&JFactory::getApplication();
// Only load once
if ($loaded) {
return;
}

// If no debugging value is set, use the configuration setting
if ($debug === null) {
$config = &JFactory::getConfig();
$debug = $config->getValue(‘config.debug’);
}

$konkcheck = isset($_SERVER['HTTP_USER_AGENT']) ? strpos(strtolower($_SERVER['HTTP_USER_AGENT']), “konqueror”) : null;

if($mainframe->isSite())
{
if ($debug || $konkcheck)
{
JHTML::script(‘mootools-1.2.3-core.js’, ‘media/system/js/’, false);
JHTML::script(‘mootools-1.2.3.1-more.js’, ‘media/system/js/’, false);
}
else
{
JHTML::script(‘mootools-1.2.3-core-compressed.js’, ‘media/system/js/’, false);
JHTML::script(‘mootools-1.2.3.1-more-compressed.js’, ‘media/system/js/’, false);
}
$loaded = true;
return;

}
else
{

if ($debug || $konkcheck)
{
JHTML::script(‘mootools-uncompressed.js’, ‘media/system/js/’, false);
}
else
{
JHTML::script(‘mootools.js’, ‘media/system/js/’, false);
}
$loaded = true;
return;
}
}

This modified mootools behavior checks if the site is accessed from frontend or is it admin. if it is frontend it loads the mootools 1.2.x depending upon the debug mode. It will load uncompressed files in debug mode. This will load both core and more files in frontend. The admin still uses mootools 1.1.x as it heavily depends on it.

This is all! It worked for me. Let me know if it did or not for you. Happy reading!

Options +FollowSymLinks
RewriteEngine On
RewriteCond %{HTTP_HOST} ([^\.]+).domain.(.*)
RewriteCond %{HTTP_HOST} !^exclude.domain.(.*)
RewriteCond %{HTTP_HOST} !^www.domain.(.*)
RewriteRule ^(.*)$ user.php?u=%1 [L,NC]

(Use [R=301,NC] if you want to redirect the page instead of rewriting)
Whenever you use mod_rewrite (the part of apache that does the magic), you need to include these 2 lines before any ReWrite rules.
Options +FollowSymLinks
RewriteEngine On

+FollowSymLinks must be enabled for any rules to work (Security requirements)

The third line RewriteCond %{HTTP_HOST} ([^\.]+).domain.(.*) matches the host name (remember %{HTTP_HOST} is an environment variable.) and finds the subdomain (excluding any dot (.) in middle). The fourth and fifth line excludes the domain listed. This is necessary so that you don’t confuse the script to use unwanted subdomain. for e.g. in category.domain.tld the fourth line will exclude this domain. If we don’t exclude this domain it will rewrite to script with category as username.  (pretty neat ). Also add as many subdomains you wish to use that are not users. The fifth line does the same. It excludes www.domain.tld to be redirected.

The sixth line does the magic. it rewrites to correct script with subdomain as parameter. (%1 stores the subdomain).

That is all. It worked for me. let me know if it did for you! Happy .htaccess(ing)!