Joomla! Documentation - User contributions [en]

Unified Content Model

2013-05-20T11:26:48Z

Elin: Created page with "The Joomla! CMS is a Content Management System. The Unified Content Model is a concept that involves the organization of content and content related features in the CMS. Jooml..."

The Joomla! CMS is a Content Management System. The Unified Content Model is a concept that involves the organization of content and content related features in the CMS. Joomla 1.x, 1.5 and 3.0 do not used a unified content model. That is, each kind of content (articles, weblinks, contacts, newsfeeds, and others) is considered completely separate from the others. However, a closer look a the database structures and and code for each type of content reveals that there are many commonalities. The UCM concept seeks to take advantage of this.

==Why UCM==

==Possible Strategies==

==Links==

Unified Content Model Working Group

2013-05-20T05:04:55Z

Elin: /* Roadmap */

The Unified Content Model Working Group is a Production Working Group. UCM is powerful new tool that is proposed for inclusion in the Platform. What use will the CMS make of it, what are the backward compatibility issues involved, what new coding would be needed to use it in the CMS, and what are the implications for third party extensions are all open questions.

==Coordinators & PLT Contact==

Elin Waring
==Announcements==

==External resources==

Background Materials

The original code from eBay

The first extended discussion on the platform mailing list.

Rob Schley talk at Joomla Day New York

Elin Waring slides for PWG lightning talks at Joomla and Beyond 2012

Video of PWG Meeting at JAB 2012

Video of session on UCM at Joomla World Conference

Slides from Elin's session on UCM at JWC

Sam's example of a web services application

Stefan's GSOC application using UCM

==Deliverables==

Long term, a new Joomla application for the management of content.

==Technical Work produced by this group==

==Communications==

==Roadmap==
This effort can be thought of as two coordinated efforts:
* Work on the CMS 3 series to implement UCM for the core and extensions that wish to opt into it.
* Work on a the CMS 4 series that would be built around this model as well as other architectural changes.

Steps
*Initial infrastructure for use of a single core table: 3.1.
*Migration to a the single core content table for all or most core components for 3.2

==Meetings==

[[Category:Documentation Working Group]]
[[Category:Working Groups]]

J3.1:Using Tags in an Extension

2013-05-18T16:55:36Z

Elin: /* Add or modify a delete() method */

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$result = parent::delete($pk);
return $result && $this->tagsHelper->deleteTagData($this, $pk);
}

</source>

This manages the deletion of all related data if a content item is deleted.

== Add tags to the getItem() method of the model ==

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

Note: It is our intent to make the storage field a property so that alternative fields can be used.

== Add a tag field to edit screens ==
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen '''MUST''' be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
* '''AJAX mode.''' Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add '''mode="ajax"''' or '''mode="nested"''' to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

== Prepare the view ==
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

== Set up the display ==

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

=== Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method. ===

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

And modify your batch method by adding
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

That’s it, now create some tags, tag some items and you are set.

[[Category:Development]][[Category:Content Tags]]

Fatal-error-in-registration

2013-05-14T09:48:06Z

Elin:

When registration is done with administrator activation, one may get a

Fatal error: Call to a member function where() on a non-object in ROOT/components/com_users/models/registration.php on line 109

To solve this, change line 108 of ROOT/components/com_users/models/registration.php

from

->from($db->quoteName('#__users')

to

->from($db->quoteName('#__users'))

(There should be an additional ) at the end of the line.)

<noinclude>
[[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

J3.1:Using Tags in an Extension

2013-05-04T00:23:31Z

Elin: /* Batch processing */

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

== Add tags to the getItem() method of the model ==

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

Note: It is our intent to make the storage field a property so that alternative fields can be used.

== Add a tag field to edit screens ==
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
* '''AJAX mode.''' Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add '''mode="ajax"''' or '''mode="nested"''' to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

== Prepare the view ==
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

== Set up the display ==

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

=== Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method. ===

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

And modify your batch method by adding
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

That’s it, now create some tags, tag some items and you are set.

[[Category:Development]][[Category:Tags]]

J3.1:Using Tags in an Extension

2013-05-04T00:22:07Z

Elin: /* Add tags to the getItem() method of the model */

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

== Add tags to the getItem() method of the model ==

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

Note: It is our intent to make the storage field a property so that alternative fields can be used.

== Add a tag field to edit screens ==
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
* '''AJAX mode.''' Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add '''mode="ajax"''' or '''mode="nested"''' to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

== Prepare the view ==
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

== Set up the display ==

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

=== Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method. ===

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

And modify your batch method by adding
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

That’s it, now create some tags, tag some items and you are set.

[[Category:Development]][[Category:Tags]]

J3.1:Using Tags in an Extension

2013-05-04T00:20:43Z

Elin: /* Modify your store() method */

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

== Add tags to the getItem() method of the model ==

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

== Add a tag field to edit screens ==
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
* '''AJAX mode.''' Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add '''mode="ajax"''' or '''mode="nested"''' to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

== Prepare the view ==
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

== Set up the display ==

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

=== Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method. ===

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

And modify your batch method by adding
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

That’s it, now create some tags, tag some items and you are set.

[[Category:Development]][[Category:Tags]]

J3.1:Using Tags in an Extension

2013-05-04T00:20:17Z

Elin: /* Modify your store() method */

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

== Add tags to the getItem() method of the model ==

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

== Add a tag field to edit screens ==
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
* '''AJAX mode.''' Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add '''mode="ajax"''' or '''mode="nested"''' to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

== Prepare the view ==
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

== Set up the display ==

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

=== Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method. ===

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

And modify your batch method by adding
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

That’s it, now create some tags, tag some items and you are set.

[[Category:Development]][[Category:Tags]]

Component Development/Reading list

2013-04-29T03:13:55Z

Elin:

* [[Portal:Platform|Joomla Platform Portal]] {{JVer|platform}}
* [[File Structure and Naming Conventions]] {{JVer/multi|1.5,2.5,3.0}}
* [[Component Program Flow]]. UML sequence diagrams showing the control flow for a component. {{JVer/multi|1.5,2.5,3.0}}
* [[Developing a Model-View-Controller Component]] {{JVer/multi|1.5,2.5,3.0}}
* [[Components:xml installfile]]. An example component XML installation file. {{JVer|1.5}}
* [[Manifest files]] for the installation of extensions {{JVer/multi|1.6,1.7,2.5,3.0}}
* [[Adding sortable columns to a table in a component]]
* [[How to add custom filters to components]] {{JVer/multi|1.7,2.5}}
* [[Supporting SEF URLs in your component]]
* [[Supporting plugins in your component]] {{JVer|1.5}}
* [[Using JPagination in your component]] (Incomplete) {{JVer|1.5}}
* [[Using the JPane classes in a component]] {{JVer|1.5}}
* [[Using the JHtmlTabs class in a component]] {{JVer/multi|1.6,1.7,2.5,3.0}}
* [[Using the editor in a component]]
* [[Adding AJAX to your component]]
* [[Ajax using MooTools]] {{JVer|1.5}}
* [[How to add breadcrumbs]]
* [[Sending email from extensions]]
* [[Using the JToolBar class in the frontend]]
* [[Creating a toolbar for your component]]
* [[Creating a file uploader in your component]]
* [[Adding Javascript moo.fx to your component]]
* [[Creating Mootools accordion or simple slider/toggler]]
* [[Adding view layout configuration parameters]]
* [[Using a custom image in the menu bar title]]
* [[How to implement XML-RPC in a component]]
* [[Using multiple models in an MVC component]]
* [[Adding ACL rules to your component]] {{JVer/multi|1.6,1.7,2.5,3.0}}
* [[JController and its subclass usage overview]] {{JVer/multi|1.6,1.7,2.5}}
* [[Managing Component Updates with Joomla!2.5 - Part 1]] {{JVer/multi|1.6,1.7,2.5}}
* [[Xml-rpc changes in Joomla! 1.6]] {{JVer/multi|1.6,1.7,2.5,3.0}}
* [[Creating PDF views]] {{JVer|2.5}}<noinclude>[[Category:Landing subpages|{{PAGENAME}}]]</noinclude>
* [[Using_Tags_in_an_Extension]]{{JVer|3.1}}

J3.1:Using Tags in an Extension

2013-04-29T03:12:35Z

Elin:

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

== Add tags to the getItem() method of the model ==

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

== Add a tag field to edit screens ==
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
* '''AJAX mode.''' Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add '''mode="ajax"''' or '''mode="nested"''' to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

== Prepare the view ==
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

== Set up the display ==

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

=== Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method. ===

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

_And modify your batch method by adding_
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

_That’s it, now create some tags, tag some items and you are set._

[[Developers]][[Tags]]

J3.1:Using Tags in an Extension

2013-04-29T03:10:42Z

Elin:

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

== Add tags to the getItem() method of the model ==

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

== Add a tag field to edit screens ==
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
* '''AJAX mode.''' Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add '''mode="ajax"''' or '''mode="nested"''' to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

== Prepare the view ==
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

== Set up the display ==

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

=== Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method. ===

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

_And modify your batch method by adding_
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

_That’s it, now create some tags, tag some items and you are set._

[[Development]][[Tags]]

J3.1:Using Tags in an Extension

2013-04-29T03:07:49Z

Elin:

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

== Add tags to the getItem() method of the model ==

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

== Add a tag field to edit screens ==
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
* '''AJAX mode.''' Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add '''mode="ajax"''' or '''mode="nested"''' to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

== Prepare the view ==
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

== Set up the display ==

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

=== Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method. ===

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

_And modify your batch method by adding_
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

_That’s it, now create some tags, tag some items and you are set._

[[Developer]][[Tags]][[3.1]]

J3.1:Using Tags in an Extension

2013-04-29T03:06:23Z

Elin:

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

=== Add tags to the getItem() method of the model ===

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

=== Add a tag field to edit screens ===
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
* '''AJAX mode.''' Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add '''mode="ajax"''' or '''mode="nested"''' to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

=== Prepare the view ===
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

=== Set up the display ===

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

=== Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method. ===

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

_And modify your batch method by adding_
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

_That’s it, now create some tags, tag some items and you are set._

[[Developer]][[Tags]][[3.1]]

J3.1:Using Tags in an Extension

2013-04-29T02:10:40Z

Elin:

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
# #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
# #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note''' : Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note:
To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title
</source>
in both the ini and sys.ini files.

'''Rules''' is currently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

'''Important note''' The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

'''Router''' is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property ===

<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

=== Modify your constructor ===

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

=== Modify your store() method ===
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

=== Add or modify a delete() method ===

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

=== Add tags to the getItem() method of the model ===

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

=== Add a tag field to edit screens ===
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* '''Nested tags mode.''' Hierarchical tag list. Doesn't support on the fly tag creation.
*
=== AJAX mode. ===
Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add **mode="ajax"** or **mode="nested"** to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

### 5. Prepare the view
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

### 6. Set up the display

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

== Batch processing ==
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

###Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method._

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

_And modify your batch method by adding_
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

_That’s it, now create some tags, tag some items and you are set._

[[Developer]][[Tags]][[3.1]]

J3.1:Using Tags in an Extension

2013-04-29T01:50:32Z

Elin: Created page with "Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns. Us..."

Joomla's tagging system is used in all core content extensions and is designed to be be easy to integrate into other extensions that use standard Joomla design patterns.

Using tags in an extension is relatively straightforward but it requires small changes in a number of specific places.

== Create a content type for each view ==
Note: Types can be added using either sql or postflight by creating a JTableContenttype instance and adding a row.

First identify which tables contain data that will be tagged and what the name of the single item view displaying each of these tables. For example:
* #__contact_details is the table displayed in the view contact of component com_contact with table class ContactTableContact.
* #__weblinks is the table displayed in the view weblink of com_weblinks so WeblinksTableWeblink.

<source lang="sql">
CREATE TABLE IF NOT EXISTS `#__content_types` (
`type_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`type_title` varchar(255) NOT NULL DEFAULT '',
`type_alias` varchar(255) NOT NULL DEFAULT '',
`table` varchar(255) NOT NULL DEFAULT '',
`rules` text NOT NULL,
`field_mappings` text NOT NULL,
`router` varchar(255) NOT NULL DEFAULT '',

</source>

For each table/option/view you will need to make an entry in #__content_types. You can do this either using sql or postflight by creating an instance of JTableContenttype. Don't forget a category type if you use the Joomla categories API.

A string giving component.view (that would be in the page request, typically matching the model name) goes in the **type_alias** field.

'''table''' gives the complete table class information for the table class stored as a JSON object in which the first element represents your "special" table and the second an optional common table (otherwise it will default the JTableCorecontent. This includes the name of the database table, the name of the primary key, the prefix, the name, an option array as used in your constructor and getInstance() methods. This enables the tagging system (and other APIs) to access your table easily.

If you are using Joomla categories make sure to create a category type so that they can be tagged. In Joomla 3.1 and 3.1.1 there is an error where the tag field will show even if there is not a type, but this will be corrected in 3.1.2.

'''Important note'''

Please note that the table name for the common table is #__ucm_content. This is INCORRECT in 3.1 and 3.1.1 data but is not currently used. The data will be updated in 3.1.2.

<source lang="php">
{"special":{"dbtable":"#__content","key":"id","type":"Content","prefix":"JTable","config":"array()"},"common":{"dbtable":"#__ucm_content","key":"ucm_id","type":"Corecontent","prefix":"JTable","config":"array()"}}
</source>

The '''type_title''' field would potentially be used for display although this is not implemented currently except in the contentttype field. Usually it should begin with an upper case letter if it is in English. See note about how to make this translatable.

note: To make your type names translatable add
<source lang="php">
COM_TAGS_CONTENT_TYPE_ + the type_title

</source>in both the ini and sys.ini files.

Rules iscurrently not used. It will likely be removed in favor of an asset_id for each type, but currently you can ignore this field which will be managed by JTable.

'''field_mappings''' maps the names of specific fields in your table to a set of standard names. This mapping is stored as a JSON array with the first element mapping to the common fields and the second one mapping the other fields from the table.

==== Important note ====

The JHelperTags and JUcm APIS currently (at 3.1.1) support arrays for this field, but our intention is to change this to support either arrays or objects with a default of objects. This is planned for implementation for 3.1.2.

<source lang="php">
'{"common":[{"core_content_item_id":"id","core_title":"title","core_state":"published","core_alias":"alias","core_created_time":"created_time","core_modified_time":"modified_time","core_body":"description", "core_hits":"hits","core_publish_up":"null","core_publish_down":"null","core_access":"access", "core_params":"params", "core_featured":"null", "core_metadata":"metadata", "core_language":"language", "core_images":"null", "core_urls":"null", "core_version":"version", "core_ordering":"null", "core_metakey":"metakey", "core_metadesc":"metadesc", "core_catid":"parent_id", "core_xreference":"null", "asset_id":"asset_id"}], "special": [{"parent_id":"parent_id","lft":"lft","rgt":"rgt","level":"level","path":"path","extension":"extension","note":"note"}]}'
</source>

is the field mapping for the Article type. Note that article uses the name attribs for the core field called params. If your table does not contain a field, put “null” instead. Leaving it blank may cause SQL issues. The special fields are optional. At a minimum for common fields you need to map: content_item_id, alias and title in order to successfully create urls in the tagged items list. You also will probably want: access, status, and language.

**Router** is an optional name of a static helper router method for this type found in its front end helpers folder.
If you only store data in #__ucm_content you will eventually be able to leave the router field blank although this option is not currently implemented. If you do not have a custom router tags falls back to the rules found in JHelperRoute.

== Modify your component's table class (or classes if you have multiple tables) ==

This has several parts.

=== Add a property
===
<source lang="php">
/**
* Indicator that the tags have been changed
*
* @var JHelperTags
* @since 3.1
*/
protected $tagsHelper = null;
</source>
This property helps to manage change in tags.

#### Modify your constructor

Follow this example to modify your consructor which provides substantial reduction in duplicate code.
<source lang="php">
$this->tagsHelper = new JHelperTags();
$this->tagsHelper->typeAlias = 'com_contact.contact';
</source>

#### Modify your store() method
Management of tagging and associated data is largely handled through the store() method. This provides maximum flexibility for the handling of tags across many extensions.

If you don't have a store() method you will need to add one. The assumption is that tables will inherit from JTable.

The handling involves preStoreProcess(), a call to the parent store() method, and then a postStoreProcess().

<source lang="php">
$this->tagsHelper->preStoreProcess($this);
$result = parent::store($updateNulls);

return $result && $this->tagsHelper->postStoreProcess($this);
</source>

It is important that this be in the correct order since completion of tag processing depends on having primary key data from the parent store() method.

Note that much of this code is designed to prevent storage in in #__ucm_content when items are not tagged. If you want to always store in #__ucm_content you should modify the handling appropriately.

#### Add or modify a delete() method

The basic structure:

<source lang="php">
/**
* Method to delete a row from the database table by primary key value.
*
* @param integer $pk Primary key to delete.
*
* @return boolean True on success.
*
* @since 3.1
* @throws UnexpectedValueException
*/
public function delete($pk = null)
{
$return = parent::delete($pk, $children);
if ($return)
{
$helper = new JHelperTags;
$helper->tagDeleteInstances($pk);
}
return $return; }

</source>

This manages the deletion of all related data if a content item is deleted.

### 3.Add tags to the getItem() method of the model

In the getItem() (or similar) method of your model add
<source lang="php">
// Load item tags
if (!empty($item->id))
{
$item->tags = new JHelperTags;
$item->tags->getTagIds($item->id, 'com_contact.contact');
$item->metadata['tags'] = $item->tags;
}
</source>
changing to your component and alias name, matching what is in the type table.and changing the name of id property to the name of your primary key.

### 4. Add a tag field to edit screens
In any edit layouts where you want to allow tagging, you need to add the field to the xml and the appropriate layouts if necessary.

Update: Note that there is new handling of this in the core. Tags in the edit screen should be part of a metadata <fields></fields> group. The core provides two JLayouts to help you manage standard layouts, one (details) for the metadata and one for the sidebar that includes the tabs.

<source lang="xml">
<field name="tags" type="tag"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field></source>

The field loads all the Javascript libraries required. You don't need to worry about that.

The field supports two modes:
* **Nested tags mode.** Hierarchical tag list. Doesn't support on the fly tag creation.
* **AJAX mode.** Tags are searched while user types (3 min. chars required to launch the AJAX search). Custom tags are added by pressing ENTER or COMMA keys. Tags show the global route/path. Example: <code>grandpa/parent/tag</code>

The field mode can be forced or use the com_tags setting <code>Tag field mode</code> to determine its mode. To set/force the field mode we have to add **mode="ajax"** or **mode="nested"** to the tag field definition.

Example of forced AJAX mode:

<source lang="xml">
<field name="tags" type="tag" mode="ajax"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>
</source>
The field also includes an attribute to allow/deny the user to enter custom values. Currently this only works in AJAX mode. The attribute has to be added to the field definition like **custom="allow"** or **custom="deny"**

Example field definition with custom tags denied:

<source lang="xml">
<field name="tags" type="tag" mode="ajax" custom="denied"
label="JTAG" description="JTAG_DESC"
class="inputbox span12 small" multiple="true"
>
</field>

</source>
if it is not already there. Usually multiple should be true unless you have a specific reason for it not to be.
In the core components in administrator, the field is in the group shown on the right, below the language field.

### 5. Prepare the view
Add an appropriate version of this to your view.html.php file before loading the layout:

<source lang="php">
$item->tags = new JHelperTags;
$item->tags->getItemTags('com_newsfeeds.newsfeed.' , $this->item->id);
</source>

The first parameter should match a type in the types table. The second parameter is the primary key under which this record is stored in your table. This would be used in any display in any view where you want the tags associated with the item to display.

### 6. Set up the display

In any layout where you want to display the tags associated with an item add:
<source lang="php">
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>

</source>
Changing the object and property names as appropriate.

You will most likely want to add the show_tags parameter to the item parameters, the menu item parameters and component configuration as appropriate for your use case.

<source lang="php">
<?php if ($this->params->get('show_tags', 1) && !empty($this->item->tags)) : ?>
<?php $this->item->tagLayout = new JLayoutFile('joomla.content.tags'); ?>
<?php echo $this->item->tagLayout->render($this->item->tags->itemTags); ?>
<?php endif; ?></source>

### 7. Batch processing
If you want to add the ability to do batch tagging to a backend list view do the following.

Add tag to the default_batch layout

<source lang="php">
<div class="control-group">
<div class="controls">
<?php echo JHtml::_('batch.tag');?>
</div>
</div></source>

And add tag to the button class in the modal footer (Not totally necessary at this point, but good for potential future changes e.g. if unTag is added.)

<source lang="php">
<button class="btn" type="button" onclick="document.id('batch-category-id').value='';document.id('batch-access').value='';document.id('batch-language-id').value='';document.id('batch-user-id').value='';document.id('batch-tag-id)').value=''" data-dismiss="modal">
</source>

###Add a batch method to your model if you are not extending JModelAdmin or overriding the batch method._

<source lang="php">
/**
* Batch tag a list of item.
*
* @param integer $value The value of the new tag.
* @param array $pks An array of row IDs.
* @param array $contexts An array of item contexts.
*
* @return void.
*
* @since 3.1
*/
protected function batchTag($value, $pks, $contexts)
{
$tagsHelper = new JHelperTags();
$tagsHelper->tagItems($value, $pks, $contexts);

return true;
}
</source>

_And modify your batch method by adding_
<source lang="php">
if (!empty($commands['tag']))
{
if (!$this->batchTag($commands['tag'], $pks, $contexts))
{
return false;
}

$done = true;
}

</source>

Pay attention to any JSON encoded strings that you need special handling for in batch processing -- remember that you are saving a copy of the core fields and you need save to work as expected.

_That’s it, now create some tags, tag some items and you are set._

[[Developer]][[Tags]][[3.1]]

Article Management/Reading list

2013-04-29T00:54:23Z

Elin:

===Managing Content===
* [[understanding sections, categories and articles]]{{JVer|1.5}}
* [[creating a section and category hierarchy]]{{JVer|1.5}}
* [[adding a new article]]
* [[adding a menu item which points to an Article]]
* [[managing the front page]]
* [[scheduling an Article to be available only between certain dates]]
* [[restricting access to an Article]]
* [[restricting access to "read more"]]
* [[restricting access to a Section]]{{JVer|1.5}}
* [[restricting access to a Category]]{{JVer|1.5}}
* [[removing email, print or PDF icons from all Articles]]
* [[removing author name, creation date or update date from all Articles]]
* [[moving an Article to the archive]]
* [[deleting an Article]]

===Editing an Article===
* [[adding an image to an article]]
* [[inserting a heading into an Article]]
* [[inserting a list into an Article]]
* [[inserting a table into an Article]]
* [[modifying a table in an Article]]
* [[inserting a link to another Article or content page into an Article]]
* [[inserting a link to another website into an Article]]
* [[removing a link from an Article]]
* [[splitting an Article into an introduction with a link to read more]]
* [[removing email, print or PDF icons from an Article]]
* [[removing author name, creation date or update date from an Article]]
* [[previewing an Article]]
* [[splitting a long Article into multiple linked pages]]

[[Category:Content Management]]
[[Category:Article Management]]

Article Management/Reading list

2013-04-29T00:53:47Z

Elin:

===Managing Content===
* [[understanding sections, categories and articles]]{{JVer|1.5}}
* [[creating a section and category hierarchy]]{{JVer|1.5}}
* [[adding a new article]]
* [[adding a menu item which points to an Article]]
* [[managing the front page]]
* [[scheduling an Article to be available only between certain dates]]
* [[restricting access to an Article]]
* [[restricting access to "read more"]]
* [[restricting access to a Section]]{{JVer|1.5}}
* [[restricting access to a Category]]{{JVer|1.5,2.5,3}}
* [[removing email, print or PDF icons from all Articles]]
* [[removing author name, creation date or update date from all Articles]]
* [[moving an Article to the archive]]
* [[deleting an Article]]

===Editing an Article===
* [[adding an image to an article]]
* [[inserting a heading into an Article]]
* [[inserting a list into an Article]]
* [[inserting a table into an Article]]
* [[modifying a table in an Article]]
* [[inserting a link to another Article or content page into an Article]]
* [[inserting a link to another website into an Article]]
* [[removing a link from an Article]]
* [[splitting an Article into an introduction with a link to read more]]
* [[removing email, print or PDF icons from an Article]]
* [[removing author name, creation date or update date from an Article]]
* [[previewing an Article]]
* [[splitting a long Article into multiple linked pages]]

[[Category:Content Management]]
[[Category:Article Management]]

Article Management/Reading list

2013-04-29T00:52:19Z

Elin:

===Managing Content===
* [[understanding sections, categories and articles]]{{JVer|1.5}}
* [[creating a section and category hierarchy]]{{JVer|1.5}}
* [[adding a new article]]
* [[adding a menu item which points to an Article]]
* [[managing the front page]]
* [[scheduling an Article to be available only between certain dates]]
* [[restricting access to an Article]]
* [[restricting access to "read more"]]
* [[restricting access to a Section]]{{JVer|1.6}}
* [[restricting access to a Category]]{{JVer|1.6}}
* [[removing email, print or PDF icons from all Articles]]
* [[removing author name, creation date or update date from all Articles]]
* [[moving an Article to the archive]]
* [[deleting an Article]]

===Editing an Article===
* [[adding an image to an article]]
* [[inserting a heading into an Article]]
* [[inserting a list into an Article]]
* [[inserting a table into an Article]]
* [[modifying a table in an Article]]
* [[inserting a link to another Article or content page into an Article]]
* [[inserting a link to another website into an Article]]
* [[removing a link from an Article]]
* [[splitting an Article into an introduction with a link to read more]]
* [[removing email, print or PDF icons from an Article]]
* [[removing author name, creation date or update date from an Article]]
* [[previewing an Article]]
* [[splitting a long Article into multiple linked pages]]

[[Category:Content Management]]
[[Category:Article Management]]

How to use the filesystem package

2013-04-29T00:42:48Z

Elin:

{{version|1.5,2.5,3}}
=Using the JFILE:: class=

There are 4 classes in the J15 filesystem library.

* JFile:: (file.php)
* JFolder:: (folder.php)
* JPath:: (path.php)
* JArchive:: (archive.php)[/i]

For this first tutorial, I will focus on the JFile:: class.

The base for filehandling is the JFile class, found in libraries/joomla/filesystem/file.php
Below I will discuss the most common options from this library file. At the end of this post, I put it together in a very simple script for file upload.

==Get file extension==
Syntax:
<source lang=php>
$ext = JFile::getExt($filename);
</source>

Pretty clear, just feed the function with a filename and it will return the extension of the file you selected.

==Strip file extension==
Syntax:
<source lang=php>
$name = JFile::stripExt($filename);
</source>
This will return the filename without the extension.

==Clean filename==
Syntax:
<source lang=php>
$safefilename = JFile::makeSafe($filename);
</source>
It cleans out all odd characters from a filename and returns a safe filename.

==Copy a file==
Syntax:
<source lang=php>
JFile::copy($src, $dest);
</source>
It is basically a wrapper for the PHP copy() function, but also checks if the file you want to copy exists and the destination really is available. Great thing is that this function also makes use of the FTP-layer in J15 if necessary.

==Delete a file==
Syntax:
<source lang=php>
JFile::delete($path.$file);
</source>
It tries to delete the file, making sure it is actually existing, but also checks permissions. If permissions are not set up properly, it tries to change them and delete the file. It also uses the FTP-layer when necessary.

==Upload a file==
Syntax:
<source lang=php>
JFile::upload($src, $dest);
</source>
It is basically the wrapper for the PHP move_uploaded_file() function, but also does checks availability and permissions on both source and destination path.

==Example==
So how does that look in a script? I put up a small code snippet of an upload script. Some of the functions are used.
The script is fired from an upload form. That form has a file element, called file_upload (see below).
<source lang=php>
<form name="upload" method="post" enctype="multipart/form-data">
<input type="file" name="file_upload" />
<input type="submit" />
</form>
</source>

Note:
If you didn´t add the part: enctype="multipart/form-data" then you are unable to upload a file!

Upload code looks like this:
<source lang=php>
<?php
***********************
* *
* File upload example *
* *
***********************
//Retrieve file details from uploaded file, sent from upload form
$file = JRequest::getVar('file_upload', null, 'files', 'array');

//Import filesystem libraries. Perhaps not necessary, but does not hurt
jimport('joomla.filesystem.file');

//Clean up filename to get rid of strange characters like spaces etc
$filename = JFile::makeSafe($file['name']);

//Set up the source and destination of the file
$src = $file['tmp_name'];
$dest = JPATH_COMPONENT . DS . "uploads" . DS . $filename;

//First check if the file has the right extension, we need jpg only
if ( strtolower(JFile::getExt($filename) ) == 'jpg') {
if ( JFile::upload($src, $dest) ) {
//Redirect to a page of your choice
} else {
//Redirect and throw an error message
}
} else {
//Redirect and notify user file is not right extension
}
?>
</source>

=Upload - Full Sample=

Little sample where admin choose the file type or all, enter the users to access the form upload.
Folder to upload files in Joomla directory or with absolute path.
Only selected users access the form upload.

mod_simpleupload.xml
<source lang=xml>
<?xml version="1.0" encoding="utf-8"?>
<install type="module" version="1.5.0">
<name>Simple Upload 1.3</name>
<author>Ribamar FS</author>
<creationDate>fevereiro 2010</creationDate>
<copyright>(C) 2005 Open Source Matters. All rights reserved.</copyright>
<license>http://www.gnu.org/copyleft/gpl.html GNU/GPL</license>
<authorEmail>ribafs@gmail.com</authorEmail>
<authorUrl>http://ribafs.org</authorUrl>
<version>1.3</version>
<description>Simple Upload 1.3 - Simple upload with Joomla Framework.</description>
<files>
<filename module="mod_simpleupload">mod_simpleupload.php</filename>
</files>
<params>
<param name="dir" type="text" label="Directory" description="Directory Upload" default="upload"/>
<param name="type" type="list" default="*" label="Select a file type" description="File type">
<option value="*">Any File </option>
<option value="image/png">PNG</option>
<option value="image/gif">GIF</option>
<option value="image/jpeg">JPEG</option>
<option value="application/zip">ZIP</option>
<option value="application/x-gzip">TAR.GZ</option>
<option value="text/html">HTML</option>
<option value="text/plain">TXT</option>
<option value="application/pdf">PDF</option>
<option value="application/msword">DOC</option>
</param>
<param name="user_names" type="text" label="User Names (optional)" description="Names users (optionas)" default=""/>
</params>
</install>
</source>

mod_simpleupload.php
<source lang=php>
<?php
// no direct access
defined('_JEXEC') or die('Restricted access');

//Import filesystem libraries. Perhaps not necessary, but does not hurt
jimport('joomla.filesystem.file');

$max = ini_get('upload_max_filesize');
$module_dir = $params->get( 'dir' );
$file_type = $params->get( 'type' );

$user_names = $params->get( 'user_names' );
$msg = '';

function fileUpload($max, $module_dir, $file_type, $msg){
//Retrieve file details from uploaded file, sent from upload form
$file = JRequest::getVar('file_upload', null, 'files', 'array');
// Retorna: Array ( [name] => mod_simpleupload_1.2.1.zip [type] => application/zip
// [tmp_name] => /tmp/phpo3VG9F [error] => 0 [size] => 4463 )

if(isset($file)){
//Clean up filename to get rid of strange characters like spaces etc
$filename = JFile::makeSafe($file['name']);

if($file['size'] > $max) $msg = JText::_('ONLY_FILES_UNDER').' '.$max;
//Set up the source and destination of the file

$src = $file['tmp_name'];
$dest = $module_dir . DS . $filename;

//First check if the file has the right extension, we need jpg only
if ($file['type'] == $file_type || $file_type == '*') {
if ( JFile::upload($src, $dest) ) {

//Redirect to a page of your choice
$msg = JText::_('FILE_SAVE_AS').' '.$dest;
} else {
//Redirect and throw an error message
$msg = JText::_('ERROR_IN_UPLOAD');
}
} else {
//Redirect and notify user file is not right extension
$msg = JText::_('FILE_TYPE_INVALID');
}

$msg = "<script>alert('". $msg ."');</script>";
}
return $msg;
}

$user =& JFactory::getUser();
$username = $user->get('username');

$acc = 0;
$session =& JFactory::getSession();

if(isset($user_names)) {
$more = strpos($user_names, ',',0);
if($more >0){
$user_names = explode(',',$user_names);
foreach($user_names as $un){
if($un == $username) {
$session->set($acc, 1);
}else{
$session->set($acc, 0);
}
}
}else{
if ($user_names == $username) $session->set($acc, 1);
}
}else{
if(isset($username)) $session->set($acc, 1);
}

if($session->get($acc) == 1){
?>

<form name="imgform" method="post" action="" enctype="multipart/form-data" onSubmit="if(file_upload.value=='') {alert('Choose a file!');return false;}">
<?php echo JText::_('CHOOSE_FILE'); ?> <input type="file" name="file_upload" size="10" />
<input name="submit" type="submit" value="Upload" />
</form>

<?php
print fileUpload($max, $module_dir, $file_type, $msg);
}

// Adapted from http://docs.joomla.org/How_to_use_the_filesystem_package
?>
</source>

=Using the JFolder:: class=
The base for folder handling is the JFolder class, found in libraries/joomla/filesystem/folder.php
Below I will discuss the most common options from this library file. At the end of this post, I put it together in a very simple script as an exmaple

==Copy folder==
Syntax:
<source lang=php>
JFolder::copy($src, $dest, $path, $force);
</source>
This will copy a complete folder and all of it’s contents to another location on the server. It does permission and availability checking on both source and destination. By using $path you can enter a basepath to prefix to the filename and by setting the $force parameter to true, you can force the overwriting of already existing files. If set in the configuration, the FTP-layer will be used.

==Create folder==
Syntax:
<source lang=php>
JFolder::create($path, $mode);
</source>
This is basically a wrapper for the php mkdir() function, but with error permissions and availability checking. This one also uses the FTP-layer when set in the configuration. $mode will set the default permission, once copied and defaults to 0755.

==Move folder==
Syntax:
<source lang=php>
JFolder::move($src, $dest);
</source>
Basically a wrapper for the php rename() function, but with permissions and availability checking. This one also uses the FTP-layer when set in the configuration.

==Check if folder exists==
Syntax:
<source lang=php>
JFolder::exists($path);
</source>
Wrapper for the php is_dir() function. Pretty straightforward, returns true if folder exists.

==Read files from folder==
Syntax:
<source lang=php>
JFolder::files($path, $filter = '.', $recurse, $fullpath , $exclude);
</source>
Function to read files from a folder. When setting $recurse to true, also subfolders will be searched. $fullpath set to true returns the full path in the array. With $exclude, you can offer an array of extensions, not to include in the search for files. It returns an array with all filenames.

==Read folders from filesystem==
Syntax:
<source lang=php>
JFolder::folders($path, $filter = '.', $recurse, $fullpath , $exclude);
</source>
Exactly the same as JFolder::files(), except this does only return an array with foldernames.

==Make a tree like list from a folder structure==
Syntax:
<source lang=php>
JFolder::listFolderTree($path, $filter, $maxLevel = 3, $level = 0, $parent = 0);
</source>
It will read a folder, specified in $path and will return all folders in an array, suitable for tree display. You can specify the number of levels. The folder array looks like this:
<source lang=php>
Array
(
[0] => Array
(
[id] => 1
[parent] => 0
[name] => administrator
[fullname] => g:/joomla_1012/administrator
[relname] => g:/joomla_1012/administrator
)

[1] => Array
(
[id] => 2
[parent] => 1
[name] => backups
[fullname] => g:/joomla_1012/administrator/backups
[relname] => g:/joomla_1012/administrator/backups
)

[2] => Array
(
[id] => 3
[parent] => 1
[name] => components
[fullname] => g:/joomla_1012/administrator/components
[relname] => g:/joomla_1012/administrator/components
)
)
</source>

==Clean a path string==
Syntax:
<source lang=php>
JFolder::makeSafe($path);
</source>
Identically to the JFile::makeSafe() function. It cleans all odd characters out of the string and returns a clean path.

==Example==
Ok, and how does this look in actual code. We are going to read the contents of a folder called images. In it, al large number of files are placed. We want to create a subfolder, called jpg and filter all jpg files out and move them to the jpg subfolder. After that, we will move the complete subfolder to another place on the server.
<source lang=php>
<?php
//First we set up parameters
$searchpath = JPATH_COMPONENT . DS . "images";

//Then we create the subfolder called jpg
if ( !JFolder::create($searchpath . DS . "jpg") ) {
//Throw error message and stop script
}

//Now we read all jpg files and put them in an array.
$jpg_files = JFolder::files($searchpath, '.jpg');

//Now we need some stuff from the JFile:: class to move all files into the new folder
foreach ($jpg_files as $file) {
JFile::move($searchpath. DS . $file, $searchpath . DS. "jpg" . $file);
}

//Lastly, we are moving the complete subdir to the root of the component.
if (JFolder::move($searchpath . DS. "jpg", $JPATH_COMPONENT) ) {
//Redirect with perhaps a happy message
} else {
//Throw an error
}
?>
</source>

This is example script only, but gives a general idea of the possibilities. I did not touch other stuff like JError to keep it clean and simple.
<noinclude>[[Category:Development]]</noinclude>

Multilingual-problems-after-updating-to-2.5.11-or-3.1.1

2013-04-28T15:50:23Z

Elin:

Some (but not all) multilingual sites experience a problem where all content not in the default language is not displayed and the language filter module does not seem to work.

An official fix is not yet announced. However there were two changes that may be causing this issue and users may want to try fixing these. Try each fix in order and test to see if it resolves the problem.

First, if you have contact data you must ensure that every contact has a language (if it says "Undefined" in the contact manager, that tells you no language is assigned) and every contact that has a linked user should either have a version set to language ALL or else have one version set to each content language used on your site. That is if you have 3 languages you must either have 3 separate contacts or you must have one set to all.

Second, open the language filter plugin, make sure the cookie lifetime is set to year and save.

<noinclude>
[[Category:Version 2.5 FAQ]][[Category:Version 2.5.11 FAQ]][[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

Multilingual-problems-after-updating-to-2.5.11-or-3.1.1

2013-04-28T15:46:10Z

Elin:

Some (but not all) multilingual sites experience a problem where all content not in the default language is not displayed and the language filter module does not seem to work.

An official fix is not yet announced. However there were two changes that may be causing this issue and users may want to try fixing these. Try each fix in order and test to see if it resolves the problem.

First, open the language filter plugin, make sure the cookie lifetime is set to year and save.

Second, if you have contact data you must ensure that every contact has a language (if it says "Undefined" in the contact manager, that tells you no language is assigned) and every contact that has a linked user should either have a version with language ALL or else have a version in each content language used on your site.

<noinclude>
[[Category:Version 2.5 FAQ]][[Category:Version 2.5.11 FAQ]][[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

Multilingual-problems-after-updating-to-2.5.11-or-3.1.1

2013-04-28T15:44:41Z

Elin:

Some (but not all) multilingual sites experience a problem where all content not in the default language is not displayed and the language filter module does not seem to work.

An official fix is not yet announced. However there were two changes that may be causing this issue and users may want to try fixing these. Try each fix in order and test to see if it resolves the problem.

First, open the language filter plugin, make sure the cookie lifetime is set to year and save.

Second, if you have contact data you must ensure that every contact has a language (if it says "undefined" in the contact manager, that tells you no language is assigned) and every contact that has a linked user should either have a version with language ALL or else have a version in each content language used on your site.

<noinclude>
[[Category:Version 2.5 FAQ]][[Category:Version 2.5.11 FAQ]][[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

Multilingual-problems-after-updating-to-2.5.11-or-3.1.1

2013-04-28T15:41:23Z

Elin:

Some (but not all) multilingual sites experience a problem where all content not in the default language is not displayed and the language filter module does not seem to work.

An official fix is not yet announced. However there were two changes that may be causing this issue and users may want to try fixing these. Try each fix in order and test to see if it resolves the problem.

First, open the language filter plugin, make sure the cookie lifetime is set to year and save.

Second, if you have contact data you must ensure that every contact has a language (if it says "undefined" in the contact manager, that tells you no language is assigned) and every contact that has a linked user should have a version with language ALL as well as any specific language versions.

<noinclude>
[[Category:Version 2.5 FAQ]][[Category:Version 2.5.11 FAQ]][[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

Ftp-update-not-working

2013-04-28T01:04:03Z

Elin: Created page with "There have been reports that updates with the FTP layer enabled are not working. Currently there is not a fix for this, but it is suggested that rather than use the updater y..."

There have been reports that updates with the FTP layer enabled are not working. Currently there is not a fix for this, but it is suggested that rather than use the updater you install the new Joomla version using the standard extension manager install. If that does not work, you can ftp the update zip filed to your host and unzip the new files, replacing the old ones. You will need to manually run the database changes using the appropriate version scrip found in administrator/components/com_admin/sql.

You will also need to manually delete the Flash uploader files from the media folder.

<noinclude>
[[Category:Version 2.5 FAQ]][[Category:Version 2.5.11 FAQ]][[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

Multilingual-problems-after-updating-to-2.5.11-or-3.1.1

2013-04-28T00:56:27Z

Elin:

Some (but not all) multilingual sites experience a problem where all content not in the default language is not displayed and the language filter module does not seem to work. Although an official fix is not yet announced, this is related to the change to language cookie handling that was introduced. As a first step try opening the language filter plugin and set the cookie lifetime to year and see if that solves the problem. If it does not as a '''temporary''' solution you may want to revert the change to the plugin. To do so take the code from the code below and change the plugin. Delete the lines with + at the beginning and add the lines with - at the beginning in the file plugins/system/languagefilter/languagefilter.php.

@@ -82,7 +84,7 @@
$conf = JFactory::getConfig();
$cookie_domain = $conf->get('config.cookie_domain', '');
$cookie_path = $conf->get('config.cookie_path', '/');
- setcookie(JApplication::getHash('language'), $lang_code, time() + 365 * 86400, $cookie_path, $cookie_domain);
+ setcookie(JApplication::getHash('language'), $lang_code, $this->getLangCookieTime(), $cookie_path, $cookie_domain);
// set the request var
JRequest::setVar('language', $lang_code);
}
@@ -355,7 +357,7 @@
$conf = JFactory::getConfig();
$cookie_domain = $conf->get('config.cookie_domain', '');
$cookie_path = $conf->get('config.cookie_path', '/');
- setcookie(JApplication::getHash('language'), $lang_code, time() + 365 * 86400, $cookie_path, $cookie_domain);
+ setcookie(JApplication::getHash('language'), $lang_code, $this->getLangCookieTime(), $cookie_path, $cookie_domain);
}
}
}

<noinclude>
[[Category:Version 2.5 FAQ]][[Category:Version 2.5.11 FAQ]][[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

Multilingual-problems-after-updating-to-2.5.11-or-3.1.1

2013-04-27T23:00:54Z

Elin: Created page with "Some (but not all) multilingual sites experience a problem where all content not in the default language is not displayed and the language filter module does not seem to work...."

Some (but not all) multilingual sites experience a problem where all content not in the default language is not displayed and the language filter module does not seem to work. Although an official fix is not yet announced, this is related to the change to language cookie handling that was introduced. As a first step try opening the language filter plugin and set the cookie lifetime to year and see if that solves the problem. If it does not as a '''temporary''' solution you may want to revert the change to the plugin. To do so take the code from the code below and change the plugin. Delete the lines with + at the beginning and add the lines with - at the beginning in the file plugins/system/languagefilter/languagefilter.php.

<source: php>

@@ -82,7 +84,7 @@
$conf = JFactory::getConfig();
$cookie_domain = $conf->get('config.cookie_domain', '');
$cookie_path = $conf->get('config.cookie_path', '/');
- setcookie(JApplication::getHash('language'), $lang_code, time() + 365 * 86400, $cookie_path, $cookie_domain);
+ setcookie(JApplication::getHash('language'), $lang_code, $this->getLangCookieTime(), $cookie_path, $cookie_domain);
// set the request var
JRequest::setVar('language', $lang_code);
}
@@ -355,7 +357,7 @@
$conf = JFactory::getConfig();
$cookie_domain = $conf->get('config.cookie_domain', '');
$cookie_path = $conf->get('config.cookie_path', '/');
- setcookie(JApplication::getHash('language'), $lang_code, time() + 365 * 86400, $cookie_path, $cookie_domain);
+ setcookie(JApplication::getHash('language'), $lang_code, $this->getLangCookieTime(), $cookie_path, $cookie_domain);
}
}
}

</source>

<noinclude>
[[Category:Version 2.5 FAQ]][[Category:Version 2.5.11 FAQ]][[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

J3.1:How To Use Content Tags in Joomla!

2013-04-27T19:48:40Z

Elin:

Tags in Joomla! provide a flexible way of organizing content. The same tag can be applied to many different content items across content types (articles, weblinks, newsfeeds, contacts, and catgories). Any item can have as many tags as desired.

Once an item is tagged with a specific tag, browsing to the link for that tag will give a list of all items that have been tagged with that tag.

Tags can be created in two ways.

# You can browse to the Tags manager (link on the Components menu). There you can create detailed tags in a way similar to creating an article. Besides a name, tags can include a description, images, meta data and other items similar to all other Joomla content types. In the Tags Manager you can also choose a parent for a tag to create nested tagging.
# You can create tags on the fly in any content editing screen that has a tags field. Start typing the name of a possible tag. Once you get to three letters you will start to see suggested tags that alread exist. If you are creating a brand new tag finish typing the name and hit enter and the tag will be created for you when you save.

Once you have tags and some tagged items you can display them in the front end in several ways.

# By default Joomla! will display tags embedded in each item that has been tagged. You can turn this display off by changing the parameters. You can control positioning of this display with layout overrides and alternate layouts and you can style it with your css.
# You can create a menu link that displays a list of tags, with links to the tagged items for each tag.
# You can create a menu link that displays a list of tagged items for a given tag and display either as a list or blog style.
# You can use one of the tags modules. Popular tags will display a linked list of the tags that have the most tagged items. Similar Tags will display a list of items that have a similar set of tags to the currently displayed item (note that this module does not display on pages that are not showing content items).

J3.1:How To Use Content Tags in Joomla!

2013-04-27T19:42:52Z

Elin: Created page with "Tags in Joomla! provide a flexible way of organizing content. The same tag can be applied to many different content items across content types (articles, weblinks, newsfeeds, ..."

Tag form field type

2013-04-27T17:59:12Z

Elin:

The '''Tag''' field type provides a point where you can enter tags - this is either AJAX or nested.

* '''type''' (mandatory) must be ''tag''.
* '''name''' (mandatory) is the unique name of the parameter.
* '''mode''' (optional) (translatable) is the description of the field.
* '''label''' (mandatory) (translatable) is the descriptive title of the field.
* '''description''' (optional) (translatable) is the description of the field.
* '''id''' (optional) is the id to add to the field. Note if none is set this will be the name of the field.
* '''class''' (optional) is the class to add to the field.
* '''published''' (optional) determines if non published tags should be allowed.
* '''language''' (optional) is language to filter the existing tags by.
* '''multiple''' (optional) is the ability to add more than 1 tag to the form field.
* '''custom''' (optional) if the ajax mode is chosen setting this to ''deny'' will prevent users from adding in new tags.

Example XML Definition for an AJAX Tag
<source lang="xml"><field name="tags" type="tag" label="JTAG" description="JTAG_DESC" mode="ajax" class="inputbox span12 small" multiple="true" /></source>

Example XML Definition for an Nested Tag
<source lang="xml"><field name="tags" type="tag" label="JTAG" description="JTAG_DESC" mode="nested" class="inputbox span12 small" multiple="true" /></source>

<noinclude>

=== See also ===
[http://magazine.joomla.org/issues/issue-apr-2103/item/1225-joomla-tag-field Joomla! Community Magazine April 2013 Issue]
[[Category:Standard form field types]]
</noinclude>

No-updates-shown-in-current-version

2013-04-27T13:40:02Z

Elin: Created page with "There are some reports that updates that have been released are not shown in the current (older) version. If this occurs, go to the Updates tab of the Extensions Manager. Cl..."

There are some reports that updates that have been released are not shown in the current (older) version. If this occurs, go to the Updates tab of the Extensions Manager. Click the clear cache icon. Then click the check for updates icon.

<noinclude>[[Category:Version 2.5 FAQ]]
[[Category:Version 2.5.11 FAQ]]
</noinclude>

Warnings-upgrading-from-2.5-to-3

2013-04-27T10:59:12Z

Elin:

When updating from the 2.5 series to the 3 series you may see a large number of warnings and notices on the update page. These do not interfere with the update process and may simply be ignored.

<noinclude>
[[Category:Version 2.5 FAQ]][[Category:Version 2.5.11 FAQ]][[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

Warnings-upgrading-from-2.5-to-3

2013-04-27T10:56:15Z

Elin:

When updating from the 2.5 series to the 3 series you may see a large number of warnings and notices on the update page. These do not interfere with the update process and may simply be ignored.

<noinclude>
[[Category:Version 2.5 FAQ][Category:Version 2.5.11 FAQ][Category:Version 3.1.0 FAQ][Category:Version 3.1.1 FAQ]]
</noinclude>

Warnings-upgrading-from-2.5-to-3

2013-04-27T10:52:01Z

Elin: Created page with "When updating from the 2.5 series to the 3 series you may see a large number of warnings and notices on the update page. These do not interfere with the update process and ma..."

When updating from the 2.5 series to the 3 series you may see a large number of warnings and notices on the update page. These do not interfere with the update process and may simply be ignored.

<noinclude>
[[Category:Version 2.5 FAQ][Category:Version 2.5.11 FAQ][Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

Talk:Tags-not-installed-in-3.1.0

2013-04-27T10:49:00Z

Elin: Created page with "Can we change the name to say in-3.1.0-or-3.1.1?"

Can we change the name to say in-3.1.0-or-3.1.1?

Problems-with-added-fields-in-3.1.0

2013-04-27T09:45:22Z

Elin: Created page with "If you have a plugin that adds extra fields to the article editor it may break in 3.1.0. To fix this you must update to 3.1.1. <noinclude>Category:Version 3.0 FAQ [[Categ..."

If you have a plugin that adds extra fields to the article editor it may break in 3.1.0. To fix this you must update to 3.1.1.

<noinclude>[[Category:Version 3.0 FAQ]]
[[Category:Version 3.1.0 FAQ]]
</noinclude>

Empty-$path-issue-in-2.5.10

2013-04-27T08:56:48Z

Elin:

In version 2.5.10 some extensions show an empty $path error. The best solution for this is to update to 2.5.11.

If for some reason you cannot update to 2.5.11 you can apply the following hot fix.

Navigate to libraries/joomla/filesystem/path.php.

At about line 202 change
if (!is_string($path))
to
if (!is_string($path) && !empty($path))

<code>
diff --git a/libraries/joomla/filesystem/path.php b/libraries/joomla/filesystem/path.php
index d4c8bb9..d5116c8 100644
--- a/libraries/joomla/filesystem/path.php
+++ b/libraries/joomla/filesystem/path.php
@@ -199,7 +199,7 @@ class JPath
*/
public static function clean($path, $ds = DIRECTORY_SEPARATOR)
{
- if (!is_string($path))
+ if (!is_string($path) && !empty($path))
{
throw new UnexpectedValueException('JPath::clean: $path is not a string.');
}

</code>

<noinclude>[[Category:Version 2.5 FAQ]]
[[Category:Version 2.5.10 FAQ]]
</noinclude>

Empty-$path-issue-in-2.5.10

2013-04-27T08:54:51Z

Elin: Created page with "In version 2.5.10 some extensions show an empty $path error. The best solution for this is to update to 2.5.11. If for some reason you cannot update to 2.5.11 you can apply t..."

Broken-configuration-screen-in-2.5.10

2013-04-27T08:43:43Z

Elin: Created page with "If you use memcached you may have a broken configuration screen. The best solution to this is to update to 2.5.11. If for some reason you cannot update to 2.5.11 you may appl..."

If you use memcached you may have a broken configuration screen. The best solution to this is to update to 2.5.11.
If for some reason you cannot update to 2.5.11 you may apply the following hotfix.

Find the file libraries/joomla/cache/storage/memcached.php

At line 317 change Memcache to Memcached.

<code>
- $memcached = new Memcache;
+ $memcached = new Memcached;
</code>

<noinclude>[[Category:Version 2.5 FAQ]]
[[Category:Version 2.5.10 FAQ]]
</noinclude>

Cannot-upload-file-in-2.5.10

2013-04-27T08:34:09Z

Elin: Created page with "If you get a message saying you cannot upload in 2.5.10 the best solution is to upgrade to 2.5.11. If it is not possible to upgrade to 2.5.11 you can click the options button..."

If you get a message saying you cannot upload in 2.5.10 the best solution is to upgrade to 2.5.11.

If it is not possible to upgrade to 2.5.11 you can click the options button in the media manager and save, and the error will be gone.

Please note that the Flash uploader has been removed completely for security reasons.

<noinclude>[[Category:Version 2.5 FAQ]]
[[Category:Version 2.5.10 FAQ]]
</noinclude>

Missing-intro-text-and-images-in 2.5.10

2013-04-27T08:24:36Z

Elin: Created page with "Updating to 2.5.10 may lead to the "disappearance" of intro text and images from featured or blog article views. To fix please update to 2.5.11. If for some reason updating..."

Updating to 2.5.10 may lead to the "disappearance" of intro text and images from featured or blog article views.
To fix please update to 2.5.11.

If for some reason updating to 2.5.11 is not possible, change "Show Intro Text" to Show.
This may temporarily cause your full article to display the intro text when you don't want that. In that case you should change the Show Intro Text for each impacted article to Hide. A more complete solution can also be implemented by creating a template override.

<noinclude>[[Category:Version 2.5 FAQ]]
[[Category:Version 2.5.10 FAQ]]
</noinclude>

Database-tab-error-in-2.5.10

2013-04-27T08:21:43Z

Elin:

In 2.5.10 you may see an error in the database tab saying you are not on the latest version. This is most easily fixed by updating to 2.5.11.

If for some reason you cannot update to 2.5.11 you can apply the following hot fix that was added in that update.
To apply open the two referenced files (libraries/cms/schema/changeset.php and libraries/joomla/filesystem/folder.php) and delete all of the lines that start with a minus sign and add all the lines that start with a plus sign. It is strongly preferable that you do the update to 3.1.1 rather than apply the hot fix.

<code>
diff --git a/libraries/cms/schema/changeset.php b/libraries/cms/schema/changeset.php
index 95b1a47..8e0ba28 100644
--- a/libraries/cms/schema/changeset.php
+++ b/libraries/cms/schema/changeset.php
@@ -196,7 +196,8 @@
{
$this->folder = JPATH_ADMINISTRATOR . '/components/com_admin/sql/updates/';
}
- return JFolder::files($this->folder . '/' . $sqlFolder, '\.sql$', 1, true);
+ return JFolder::files($this->folder . '/' . $sqlFolder, '\.sql$', 1, true, array('.svn', 'CVS', '.DS_Store', '__MACOSX'),
+ array('^\..*', '.*~'), true);
}

/**
diff --git a/libraries/joomla/filesystem/folder.php b/libraries/joomla/filesystem/folder.php
index edf39d6..ecabc52 100644
--- a/libraries/joomla/filesystem/folder.php
+++ b/libraries/joomla/filesystem/folder.php
@@ -467,13 +467,14 @@
* @param boolean $full True to return the full path to the file.
* @param array $exclude Array with names of files which should not be shown in the result.
* @param array $excludefilter Array of filter to exclude
+ * @param boolean $naturalSort False for asort, true for natsort
*
* @return array Files in the given folder.
*
* @since 11.1
*/
public static function files($path, $filter = '.', $recurse = false, $full = false, $exclude = array('.svn', 'CVS', '.DS_Store', '__MACOSX'),
- $excludefilter = array('^\..*', '.*~'))
+ $excludefilter = array('^\..*', '.*~'), $naturalSort = false)
{
// Check to make sure the path valid and clean
$path = JPath::clean($path);
@@ -498,8 +499,15 @@
// Get the files
$arr = self::_items($path, $filter, $recurse, $full, $exclude, $excludefilter_string, true);

- // Sort the files
- asort($arr);
+ // Sort the files based on either natural or alpha method
+ if ($naturalSort)
+ {
+ natsort($arr);
+ }
+ else
+ {
+ asort($arr);
+ }
return array_values($arr);
}
</code>

[[Category:Version 2.5.10 FAQ]]

Database-tab-error-in-2.5.10

2013-04-27T08:19:28Z

Elin: Created page with " In 2.5.10 you may see an error in the database tab saying you are not on the latest version. This is most easily fixed by updating to 2.5.11. If for some reason you cann..."

Tags-not-installed-in-3.1.0

2013-04-27T08:03:18Z

Elin: Created page with "If you have a message saying tags have not installed, it means that the full update sql did not run. Updating to 3.1.1 may solve this issue. If it does not or for some reaso..."

If you have a message saying tags have not installed, it means that the full update sql did not run.

Updating to 3.1.1 may solve this issue.

If it does not or for some reason you cannot update to 3.1.1 the following steps will resolve it.

# In your file system go to /administration/components/com_admin/sql and find the file 3.1.0.sql. Open it in a plain text editor.

# Determine your database prefix by looking at the server tab in global configuration or by looking at your database table names in phpmyadmin or whatever system your host provides for managing your database. For example you may see xyz123_assets ... in this case xyz123 is your prefix.

# In the text editor search and replace #_ with your prefix. Note that the replace should only replace the first underscore ... so now you should have for example xyz123_content_types.

# In phpmyadmin go to the SQL tab and paste the full file from the editor (or do similar in another system).

# click Go (or do similar in another system)

At this point tags will be fully installed.

<noinclude>
[[Category:Version 3.1.0 FAQ]][[Category:Version 3.1.1 FAQ]]
</noinclude>

Missing-intro-text-and-images-in 3.1.0

2013-04-27T07:52:14Z

Elin: Created page with "Updating to 3.1.0 may lead to the "disappearance" of intro text and images from featured or blog article views. To fix please update to 3.1.1. If for some reason updating t..."

Updating to 3.1.0 may lead to the "disappearance" of intro text and images from featured or blog article views.
To fix please update to 3.1.1.

If for some reason updating to 3.1.1 is not possible, change "Show Intro Text" to Show.
This may temporarily cause your full article to display the intro text when you don't want that. In that case you should change the Show Intro Text for each impacted article to Hide.

<noinclude>[[Category:Version 3.0 FAQ]]
[[Category:Version 3.1.0 FAQ]]
</noinclude>

GNOME Outreach Program for Women

2013-04-04T22:08:12Z

Elin: Created page with "here it is"

here it is

GSOC 2013 Project Ideas

2013-04-04T05:26:19Z

Elin: /* Project: Add fieldtype 'oclock' in fields */

<div style="float:right; margin-left:1em; width:40%;">__TOC__</div>
<div style="float:left; margin-right:1em;">[[Image:GSOC_2013.png|150px‎]]</div>

==Welcome!==
Welcome to the Joomla! Google Summer of Code (GSoC) 2013 project ideas page. As we move forward with the 2013 version of the Joomla! GSoC, we will use this page to develop possible project ideas. Please note that anyone who is interested can participate in this process. You do not have to be a GSoC student or mentor to suggest possible project ideas. Please keep in mind that projects need to be realistically something that is able to be functionally completed by a student working full time for about eight weeks. Thanks!

Discussion of ideas and other GSoC related items is welcome on our Google Group: https://groups.google.com/forum/?fromgroups#!forum/joomla-gsoc-2013

If you are interested in participating as a student please review the materials on applying that are available at [http://www.google-melange.com/gsoc/document/show/gsoc_program/google/gsoc2013/help_page Google]. We strongly encourage you to ask questions about process and ideas on the mailing list.

If you are interested in serving as a mentor, please fill out the [https://docs.google.com/a/community.joomla.org/spreadsheet/viewform?formkey=dHA2V1lJbThYQXpwMERiRG1FOTZlV3c6MA Mentor Application Form 2013].

==Ideas==

Opportunities exist for students to work with projects from either the Joomla CMS, the Joomla Platform or in some cases a combination of both.

In addition to this ideas list, the Joomla! Community is able to voice their opinion on features they would like to see via the [http://ideas.joomla.org/ Joomla! Idea Pool]. Those wishing to add ideas to this listing are encouraged to review the Idea Pool and base their idea on the input received there. You can also view the past lists for [http://docs.joomla.org/GSOC_2012_Project_Ideas 2012] [http://docs.joomla.org/Summer_of_Code_2010_Project_Ideas 2010] and [http://docs.joomla.org/Summer_of_Code_2009_Project_Ideas 2009], which may be useful for reference. We ask that you keep ideas realistic for the time frame that students will have to complete their projects.

Unless a mentor has proposed a specific project, mentors from the mentor pool will be matched with student projects. However members of the mentor pool are available to answer questions on the Joomla GSoC mailing list.

===Joomla CMS===

* [http://github.com/joomla/joomla-cms Source Code]
* [http://groups.google.com/d/forum/joomla-dev-cms Developer Mailing List]

====Project: Build New Media Manager for CMS 3====

:'''Brief Explanation:''' The current media manager is outdated and limited. Build a new media manager to include a better user interface, more robust functionality, and seamless integration for extensions to use. The improvements could include:
* Storage of media information in the database (including standard file property information, created by user and date, rights and other meta data and tracking of media as assets).
* Allow renaming of files
* Automated creation of thumbnails to dimensions that the webmaster can configure
* Support for a variety of media types that addresses security concerns
* Creation of a number of controllers for media manipulation such as cropping, resizing and filtering and implementation of their use.
* Use of nesting for management and display of media options
* Management of both local and remote media
* Support for creation of collections of media for example for display in a carousel as a separate content type.

:'''Expected Results:''' A new Media Manager component to improve the usability, functionality, and reusability of the extension. Work should be fully documented and include system tests as well as unit tests for all new classes.

: The work will likely include creation of a new media management package in the CMS library as well as reusable controllers for media related tasks.

: The work should align with other work in the content model and the student should expect to interact extensively with the team working on the Joomla 3.2 release.

:'''Knowledge Prerequisite:''' PHP, MySQL, Javascript, Joomla CMS, Joomla Platform, HTML5, Usability

:'''Difficulty:''' Medium

====Project: Convert JavaScript from MooTools to jQuery====

:'''Brief explanation:''' Version 3 of the CMS introduced [http://twitter.github.com/bootstrap Twitter Bootstrap] and [http://jquery.com jQuery] to the core code base. Previous versions of the CMS had been using MooTools as the preferred JavaScript library. Currently, both JavaScript libraries are shipped and used within the CMS, which occasionally causes conflicts with a user's JavaScript functionality. The CMS would like to reduce the dependency on MooTools by converting its core JavaScript behaviors from MooTools to jQuery or providing custom solutions.

:'''Expected Results:''' Dependency on MooTools is reduced within the CMS.

:'''Knowledge Prerequisite:''' Joomla CMS, PHP, JavaScript

:'''Difficulty:''' Medium

====Project: html contenteditable Ajax based front-end editor for articles, categories, tags and other content====

:'''Brief explanation:''' Allow seamless ajax-driven content-editing in the fronted of existing content.

:'''Expected Results:''' Authors with ACL permissions should be able to directly edit all content (content, weblinks, contacts, newsfeeds and categories as well as any new types that are added in the future) from the front-end. Administrators should be able to configure front end editing for appropriate users to have access to the full set of fields available in the back end in the front end (rather than the limited set of fields now available). All this should be done using Ajax. This project should focus on editing data from the core_content table and will involve work with the team implementing the migration to core_content.

:'''Knowledge Prerequisite:''' A good knowledge of Joomla, of jQuery and Ajax techniques would help a lot here.

:'''Difficulty:''' Medium to Hard

====Project: front-end editor for modules and menus====

:'''Brief explanation:''' Allow seamless ajax-driven content-editing in the fronted of existing content and allowing to insert new modules.

:'''Expected Results:''' Authors with ACL permissions should be able to directly edit modules (titles and content/settings, and inserting new modules including menus the front-end. There are a number of possible approaches this could take. For example, they could possibly use the administration interface in the front-end, otherwise with links to the corresponding administration page. This would at least allow to remove the guesswork of which module outputs what result. Using an open-source html-contenteditable javascript editor would help here in the formatting. Another possibility would be to use a services model.

Note: There will be some overlap here with the potential com_services project so project could be incorporated into that project or there could be coordination of the two projects.

:'''Knowledge Prerequisite:''' A good knowledge of Joomla, of jQuery and Ajax techniques would help a lot here.

:'''Difficulty:''' Medium to Hard

====Project: Update and add new editor plugins====

:'''Brief explanation:''' Joomla has a system of editor_xtd plugins that allow users to safely insert correct html for common items such as images, page breaks, and links to articles independent of the editor used. This project will involve updating and adding new plugins and improving usabilty. For example in terms of new plugins might include:
* A plugin that adds modal behaviour (JHTML::_('behavior.modal');). The plugin can be deactivated by a {}tag (like {modal state=0}).
* A plugin that allows safe embedding of external web services such as video or maps.

Updating plugins would include generalizing the article plugin to work across all content types using the core_content table.

Here is an example of how a plan for a modal plugin would look:

*Background: A link with the attribute 'class="modal"' is opened in a kind of lightbox. Thus easily galleries can be generated. Additionally prepare editor(s) (e. g. via editor.css in template folder) to offer the modal class in their link edit display.

*Expected Results: The modal behaviour is always available - if plugin is published and it is not forbidden by a tag. And a link with class 'modal' can easily be generated - via button and/or via editor.
Note that this may not be the ideal way to provide this functionality, it could be that the existing articles plugin is modified to allow a link type of modal for example. Thus this project would involve a careful review of existing plugins.

:'''Expected Results:''' New plugins for a number of useful items, updates to older plugins and improved user interface for the buttons.

:'''Knowledge Prerequisite:''' PHP, HTML, Javascript

:'''Difficulty:''' Easy/Medium

====Project: Add plugin 'mvc override'====

:'''Brief explanation:''' Generate a plugin that enables the developer to overwrite models and controllers.

:'''Expected Results:''' Any model and controller can be overridden.

:'''Knowledge Prerequisite:''' Joomla! CMS, PHP

:'''Difficulty:''' Medium

====Project: Hathor is beautiful====

:'''Brief explanation:''' Make the admin template 'Hathor' more beautiful. Hathor is Isis' little sister. While Isis is breathtaking, Hathor still lacks a little css: She's edgy, and pale, and boring. Yet she always does what she is told. She deserves being tended a little. No additional functionality needed, no html changes, just css beauty.

: Note that for Google Summer of Code here must be substantial coding involved in the project. In the case of Hathor this would likely involve work on making Bootstrap Javascript meet accessibility standards and work on the core administrator layouts.

:'''Expected Results:''' Hathor is beautiful.

:'''Knowledge Prerequisite:''' Javascript, CSS, HTML, PHP

:'''Difficulty:''' Easy

====Project: Accesssible Backend Template====

:'''Brief explanation:''' For most people, the internet has become the norm. Information from around the world is freely available. But not all people are benefitting from it, especially those with disabilities. For those who find it difficult to participate fully in social life, much can be gained from communication technology. But they often face barriers which make it difficult to access information and applications. Take "looking for a job" as an example. The computer gives people with disabilities excellent prospects in overcoming limitations to find employment. Wouldn't it be nice if they had full access to the Joomla backend? New career opportunties would be opened up. If the requirements of accessibility are carefully met, it would make the system easier to understand and easier to use for all users.

: We already, have an accessible backend Joomla template, but it is not very attractive and it is not using all the new technical possibilities.
: For this reason we are looking for someone who will use Bootstrap to build (with our support):

: - an attractive, accessible design with good user guidance (layout & colors, contrast)

: - a meaningful semantic structure based on web standards

: Some preliminary steps have been made to get you started, but this remains a very complex endeavor.

:'''Expected Results:''' Accessible admin template

:'''Knowledge Prerequisite:''' WAI-ARIA, Javascript, CSS, HTML, PHP

:'''Difficulty:''' Medium-Hard

: Posible mentors: Angie Radtke

====Project: Refactor document model containers====

:'''Brief explanation:''' When I say document model containers, what I'm really talking about is all those arrays in the document model that store things like metas, scripts, css, etc. Those can be rendered collectively in the template using the jdoc head tag. The project would refactor the document model to allow more robust methods of working with document containers. One solution would be to use PHP ArrayObjects instead of simple arrays.

:'''Expected Results:''' A robust solution should allow methods for appending and prepending items, method chaining, and the ability to create custom containers from within extensions and templates.

:'''Knowledge Prerequisite:''' Joomla! CMS, PHP, some html, some css, and some javascript.

:'''Difficulty:''' Medium

:'''References:'''
:* Joomla! Forums topic: [[jtopic:793482|The ArrayObject - a different approach to document containers]]
:: (the editor would not allow me to post the link)

====Project: Add new "fancy" fieldtypes such as an 'oclock' field====

:'''Brief explanation:''' Joomla!'s form generation offers a fix group of field types, such as text, textarea, radio, calendar etc. Write a group of new, javascript/AJAX fields that will provide fancier field types for the cms. For example write another field that enables the developer to create a time field, call it 'oclock' or something else sensible. The display of the time should be configurable via a format attribute. It should have the look'n'feel of the calendar field ([[Calendar form field type|Calendar form field type]]) Another project would be to create a built in way to use AJAX to create new fields such as a field type that lets you enter multiple items, creating a new field each time an old one is submitted.

:'''Expected Results:''' Generation of a new set of advanced fields

:'''Knowledge Prerequisite:''' PHP, HTML, Javascript, web standards, Bootstrap

:'''Difficulty:''' Medium

====Project: Task scheduler and manager====

:'''Brief explanation:''' Manage ,schedule and create tasks, from CMS administrator side, such as backup, virus scan, billing, reports, emailing and so on

:'''Expected Results:''': The student will be expected to build an hosting agnostic solution that act as a framework to manage task, allowing to manage tasks from third party extensions too, and some ready to run common task

:'''References:'''
:* http://en.wikipedia.org/wiki/Batch_processing
:* http://en.wikipedia.org/wiki/Scheduling_(computing)
:* http://en.wikipedia.org/wiki/Cron
:* http://en.wikipedia.org/wiki/Webcron
:* http://en.wikipedia.org/wiki/Daemon_(computing)
:* https://github.com/joomla/joomla-platform-examples/blob/master/cli/cron-plugins/run.php

:'''Knowledge Prerequisite:''': PHP, Joomla CMS, Joomla Platform, Mysql, Operating Systems.
:'''Difficulty:''' Hard
:'''Possible Mentors:''' Nicola Galgano

====Project: Improvements to Template Manager for CMS 3====

:'''Brief explanation:''' Templates are one of the most important elements of the Joomla CMS but except for the addition of template styles and template copy the functionality of the template manager has not changed dramatically since 1.5. Currently users must go outside of the template manager to add CSS, to add or modify override files or to manage their LESS. This project will make working with templates easier and more user friendly.

:'''Expected Results:''' By the end of the summer the student will produce fully documented and system tested code to do at least the following tasks in the template manager user interface:
:* See a list of overrides for a template
:* Edit the overrides for a template
:* Create a new override for a template (ideally with option to copy the core layout as a starting point)
:* Add a new CSS file to a template
:* Edit LESS file
:* Compile LESS
:* Upload images to a template's image
:* Provide a method of simple interaction with web based font and other providers.
Exact details to be developed in discussion with mentors.

:'''Knowledge Prerequisite:''' Familiarity with the Joomla CMS and templates, PHP, file management, usability, javascript

:'''Difficulty:''' Medium

==== Project: Remote web services management system for CMS 3====
:'''Brief explanation:''' Integration with remote services is a central feature of the modern web. This Joomla CMS should provide ways for webmasters to seamlessly and easily manage their interactions withe external service providers.
:'''Expected Results:''' A system for managing interactions with external services. This would include but not be limited to:
:* Secure management of public and private keys using Keychain
:* Storage of relevant urls
:* Methods to safely manage embedding by front end users
:* Plugins for Google, Twitter and Facebook authentication

:'''Knowledge Prerequisite:''' PHP, Javascript, Joomla CMS, Web Servics
:'''Difficulty:''' Medium to Hard

====Project: Redesign Users Profiles as a Form of Content for CMS 3====

:'''Brief explanation:''' Build a new way to manage and display user profiles as a content type stored in the core content table with a combination of systems including both he current profile plugin system and new ways of approaching this including the use of the core fields for body, images, urls and xreference. At the same time improve integration with contact data providing the ability to easily search and sort and send email as well as to have complex layouts and integration of web services.

:'''Expected Results:''' A front end user profile system that provides a flexible way to create and manage use profiles. This system will follow Joomla design patterns and be fully documented, have unit tests for any classes, and have system tests.

:'''Knowledge Prerequisite:''' PHP, Javascript, usability, familiarity with the Joomla CMS.

:'''Difficulty:''' Medium to Hard

====Project: Create com_services for front end website administration for CMS 3====

:'''Brief explanation:''' The user experience for beginning site administrators in particular but also all site administrators will be improved if they can carry out basic administrative tasks such as updating the site title, meta data and email address, clearing cache, setting component defaults and doing basic user management in the front end. In this project you will provide a RESTful service and front end interface to that service to allow this. Specific tasks to be implemented will be decided in discussion with the mentors.

:'''Expected Results:''' A basic services based system for managing certain administrative tasks from the front end of the Joomla CMS. This will be fully documented, have automated tests, and follow Joomla development best practices. It will also be extensible so that additional tasks can be added over time. This project will not involve content, only administrative tasks.

:'''Knowledge Prerequisite:''' PHP, Javascript, web services, security practices, Joomla CMS and framework.

:'''Difficulty:''' Hard

====Project: Webdriver system tests for CMS ====

:'''Brief explanation:''' Automated system tests allow us to test the CMS by automatically running Joomla from a browser, selecting menu options, and evaluating results. At present, most of the system tests are written using the now-outdated Selenium RC program. A small number of tests are currently completed using the newer Selenium Webdriver technology and using the [https://code.google.com/p/selenium/wiki/PageObjects Page Objects] pattern to separate the page objects from the test objects. This project will build on the current base of Webdriver tests and expand the test coverage to include more of the CMS.

:'''Expected Results:''' The student will complete the following tasks.
:# Create a strategy & roadmap for Joomla system tests. This will include things like:
:## How to organize the tests.
:## How to cover the critical back-end and front-end functionality of Joomla.
:# Write the reusable foundation classes for the expanded test coverage. These classes will be used to create the page object classes and test classes for the various portions of the CMS.
:# Begin the implementation of the roadmap.

:'''Knowledge Prerequisite:''' PHP, object-oriented programming, Joomla CMS (from a user point of view), HTML

:'''Difficulty:''' Medium

:'''Possible Mentors:''' Mark Dexter

====Project: Create a '''translating tool''' extension for Joomla ====

:'''Brief explanation:''' Projects like Facebook (see [http://www.insidefacebook.com/2008/04/02/now-you-can-help-translate-facebook-into-any-language/ insidefacebook.com/...]), RememberTheMilk ([http://www.rememberthemilk.com/services/translate/ http://www.rememberthemilk.com/...]) or other projects using [https://www.transifex.com] are taking advantage of their communities in order to localize their software. Joomla is being translated by its community into 64 languages but there is plenty of space for more languages and more community participation.
At the same time many Joomla 3rd party developers are searching for a solution on how their communities can contribute in the translation of their extensions.

:'''Expected Results:''' It is a Goal for this GSoC 2013 project to create an improved tool based in [http://extensions.joomla.org/extensions/languages/language-edition/17755 com_localise] that allows to translators to easily translate and upload their translations to a GitHub repository using [http://developer.joomla.org/manual/chap-Joomla_Platform_Manual-Github.html JGithub package]. The tool also should allow frontend community members to suggest translated strings just like Facebook or Rememerthemilk does.

:'''Knowledge Prerequisite:''' PHP, Git/Github, Joomla CMS and framework.

:'''Difficulty:''' Medium-Hard

:'''Posible mentors:''' Javier Gómez, Jean Marie Simonet, Edvard Ananyan

====Project: Module Modernization====

:'''Brief explanation:''' Modules are an important part of the CMS but many of the modules have not been updated in many years and do not take advantage of new features like JImage or JQuery, JLayouts, or PHP 5. In addition aspects of module handling such as loadposition/loadmodule and the handling of modules in templates are due for refactoring and improvement as is the user interface of com_modules. This project will work on bringing modules up to date with the rest of the CMS.

:'''Expected Results:''' Updated modules and module handling. Although subject to discussion with mentors, some likely areas are:
*Review all modules and bring up to PHP 5.4 standards.
*Incorporate JImage into modules as appropriate for example embedding the introtext image in articles modules.
*Incorporate or add new modules incorporating JQuery features such as image carousels.
*Add new modules for obviously missing features such as display of contact information.
*Develop the use of JLayouts in modules for standardization.
*Update the handling of loadposition.
*Work on handling modules as content and treating them as assets (i.e. providing module level access control).
*Work on a way to create basic configurable module default settings for items such as show title or class suffix.

:'''Knowledge Prerequisite:''' PHP, SQL, Joomla CMS

:'''Difficulty:''' Easy to Medium

:'''Possible mentors:''' Elin Waring

====Project: Smart Search Improvements====

:'''Brief explanation:''' Smart Search is an advanced search system for the Joomla CMS. While extremely powerful, it does has some limitations that we would like to address. First, it does always not properly handle some multibyte character sets and languages that do not use spaces between words. While partial solutions have been implemented, we would like to have more generic solutions. Also we would like to have a smart search interface in the Joomla Administrator and with the move to the core content model, to have better ties between smart search and other parts of the code base as well as extensions (how about an automated way to create a smart search plugin?). Finally, we would like to see some ongoing issues addressed including time out problems in the CLI application and modernization of queries and code to take advantage of newer databases and PHP versions as well as more parts of the Joomla API.

:'''Expected Results:''' A much improved Smart Search shipped as part of Joomla CMS 3.2.

:'''Knowledge Prerequisite:''' PHP, SQL, search principles, Joomla platform, Smart Search.

:'''Difficulty:''' Medium to Hard

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

{{dablink|Please add your project ideas here, you can use this '''[[GSOC 2013 Project template]]'''}}

===Joomla Framework===

The Joomla Platform allows for ideas that can work within the Joomla CMS, or could be completely separate applications that have no connection at all. The Joomla Platform allows for applications to be built for the command line, process daemons and the web. The follow list outlines some ideas that will be immediately useful for the Joomla Platform project that a student may consider taking on. In addition to PHP libraries, the Joomla Platform also ships with MooTools and project ideas can be related to client-side operations as well as server-side. One emphasis on this year's list is on the incorporation of packages for accessing web services, however other ideas for libraries and packages are welcome. In some instances multiple students may work on different aspects of the project. Two examples of this are unit testing and JStemmer.

References:
*[http://github.com/joomla/joomla-platform github Source Code]
*[http://developer.joomla.org/strategy.html Development Strategy]
*[http://groups.google.com/d/forum/joomla-dev-platform Developer Mailing List]

All code contributions must follow Joomla coding standards and include full unit test coverage.

====Project: Platform Unit Testing====

:'''Brief explanation:''' The Joomla Platform has a good suite of automated Unit Tests, but code coverage is lacking in some areas. The goal of this project is to improve the code coverage by writing unit tests for the Joomla Platform.

:'''Expected Results:''' The student will be expected to review the current [http://developer.joomla.org/coverage/ code coverage report] for the Joomla Platform and write and agreed-upon number of unit tests with particular attention to packages that are below 50% coverage. Preference should be given to non-deprecated classes but the student may choose from either the core tree (/libraries/joomla) or the legacy tree (/libraries/legacy).

:'''Knowledge Prerequisite:''' PHP, PHPUnit

:'''Difficulty:''' Medium

====Project: Object Relational Mapping (ORM) in Joomla====

:'''Explanation:''' Implementation of Object Relational Mapping to provide an exiting new basis for building (complex) applications on or within Joomla.

:Joomla uses an Active Record implementation. Via JTable and JTableNested data are CRUDded in models to and from database tables. Tables for different content types share the same kind of data and therefore code is duplicated. There are plans to solve this with a Unified Content Model (UCM), which will use a shared table for all content and a specialised table per content type. In order to implement that a JData class was made to store data in and a JDataMapper to map the database tables to the data. In terms of Martin Fowler's Patterns of Enterprise Architecture Patterns: Class Table Inheritance. This UCM would be a replacement for the current JTable classes and components.

:Object Relational Mapping, especially when one-to-many and many-to-many relations are in play, has already been worked out in the PHP-world with ORM-frameworks like Propel and Doctrine. No need to reinvent a complete new wheel. Some work has been done to use Doctrine ORM in Joomla extensions, but it could be made more generally usable and easily available to open a lot of possibilities.

:'''Expected Results:'''
:The focus for such a GSOC-project could be one of the following:
:* a more general ORM interface in which specific ORM packages could fit; be it a "native" JDataMapper or other 3rd party ORM packages.
:* or a specific implementation (like Doctrine) with which core CMS extensions could be refactored. This would be a UCM-implementation using an existing ORM package.
:Both the Joomla Platform/Framework and the CMS would benefit from such projects.

:'''Knowledge Prerequisite:''' Object Relational Mapping theory.

:'''References:'''
:* http://martinfowler.com/eaaCatalog/ and http://www.martinfowler.com/books/eaa.html
:* http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/index.html
:* https://github.com/eBaySF/joomla-platform/blob/data-package/docs/manual/en-US/chapters/packages/data.md#jdatamapper

:'''Difficulty:''' Medium to Hard

:'''Possible Mentors:''' Herman Peeren

====Project: Expand Google API coverage====

:'''Brief explanation:''' The JGoogle package provides a basic structure for using Google APIs in Joomla based code. However it only includes classes for a limited set of APIs. Your task is to dramatically expand the coverage of Google data. Specific APIs to be agreed upon with mentors, with some preference for those of immediate usefulness to the Joomla CMS.

:'''Expected Results:''' A set of well coded, fully unit tested and documented implementations for a range of Google data.

:'''Knowledge Prerequisite:''' Github, PHPUnit, familiarity with web services and the Joomla CMS.

:'''Difficulty:''' Medium

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

{{dablink|Please add your project ideas here, you can use this '''[[GSOC 2013 Project template]]'''}}

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

GSOC 2013 Project Ideas

2013-04-04T04:17:01Z

Elin: /* Project: front-end editor for modules and menus */

<div style="float:right; margin-left:1em; width:40%;">__TOC__</div>
<div style="float:left; margin-right:1em;">[[Image:GSOC_2013.png|150px‎]]</div>

==Welcome!==
Welcome to the Joomla! Google Summer of Code (GSoC) 2013 project ideas page. As we move forward with the 2013 version of the Joomla! GSoC, we will use this page to develop possible project ideas. Please note that anyone who is interested can participate in this process. You do not have to be a GSoC student or mentor to suggest possible project ideas. Please keep in mind that projects need to be realistically something that is able to be functionally completed by a student working full time for about eight weeks. Thanks!

Discussion of ideas and other GSoC related items is welcome on our Google Group: https://groups.google.com/forum/?fromgroups#!forum/joomla-gsoc-2013

If you are interested in participating as a student please review the materials on applying that are available at [http://www.google-melange.com/gsoc/document/show/gsoc_program/google/gsoc2013/help_page Google]. We strongly encourage you to ask questions about process and ideas on the mailing list.

If you are interested in serving as a mentor, please fill out the [https://docs.google.com/a/community.joomla.org/spreadsheet/viewform?formkey=dHA2V1lJbThYQXpwMERiRG1FOTZlV3c6MA Mentor Application Form 2013].

==Ideas==

Opportunities exist for students to work with projects from either the Joomla CMS, the Joomla Platform or in some cases a combination of both.

In addition to this ideas list, the Joomla! Community is able to voice their opinion on features they would like to see via the [http://ideas.joomla.org/ Joomla! Idea Pool]. Those wishing to add ideas to this listing are encouraged to review the Idea Pool and base their idea on the input received there. You can also view the past lists for [http://docs.joomla.org/GSOC_2012_Project_Ideas 2012] [http://docs.joomla.org/Summer_of_Code_2010_Project_Ideas 2010] and [http://docs.joomla.org/Summer_of_Code_2009_Project_Ideas 2009], which may be useful for reference. We ask that you keep ideas realistic for the time frame that students will have to complete their projects.

Unless a mentor has proposed a specific project, mentors from the mentor pool will be matched with student projects. However members of the mentor pool are available to answer questions on the Joomla GSoC mailing list.

===Joomla CMS===

* [http://github.com/joomla/joomla-cms Source Code]
* [http://groups.google.com/d/forum/joomla-dev-cms Developer Mailing List]

====Project: Build New Media Manager for CMS 3====

:'''Brief Explanation:''' The current media manager is outdated and limited. Build a new media manager to include a better user interface, more robust functionality, and seamless integration for extensions to use. The improvements could include:
* Storage of media information in the database (including standard file property information, created by user and date, rights and other meta data and tracking of media as assets).
* Allow renaming of files
* Automated creation of thumbnails to dimensions that the webmaster can configure
* Support for a variety of media types that addresses security concerns
* Creation of a number of controllers for media manipulation such as cropping, resizing and filtering and implementation of their use.
* Use of nesting for management and display of media options
* Management of both local and remote media
* Support for creation of collections of media for example for display in a carousel as a separate content type.

:'''Expected Results:''' A new Media Manager component to improve the usability, functionality, and reusability of the extension. Work should be fully documented and include system tests as well as unit tests for all new classes.

: The work will likely include creation of a new media management package in the CMS library as well as reusable controllers for media related tasks.

: The work should align with other work in the content model and the student should expect to interact extensively with the team working on the Joomla 3.2 release.

:'''Knowledge Prerequisite:''' PHP, MySQL, Javascript, Joomla CMS, Joomla Platform, HTML5, Usability

:'''Difficulty:''' Medium

====Project: Convert JavaScript from MooTools to jQuery====

:'''Brief explanation:''' Version 3 of the CMS introduced [http://twitter.github.com/bootstrap Twitter Bootstrap] and [http://jquery.com jQuery] to the core code base. Previous versions of the CMS had been using MooTools as the preferred JavaScript library. Currently, both JavaScript libraries are shipped and used within the CMS, which occasionally causes conflicts with a user's JavaScript functionality. The CMS would like to reduce the dependency on MooTools by converting its core JavaScript behaviors from MooTools to jQuery or providing custom solutions.

:'''Expected Results:''' Dependency on MooTools is reduced within the CMS.

:'''Knowledge Prerequisite:''' Joomla CMS, PHP, JavaScript

:'''Difficulty:''' Medium

====Project: html contenteditable Ajax based front-end editor for articles, categories, tags and other content====

:'''Brief explanation:''' Allow seamless ajax-driven content-editing in the fronted of existing content.

:'''Expected Results:''' Authors with ACL permissions should be able to directly edit all content (content, weblinks, contacts, newsfeeds and categories as well as any new types that are added in the future) from the front-end. Administrators should be able to configure front end editing for appropriate users to have access to the full set of fields available in the back end in the front end (rather than the limited set of fields now available). All this should be done using Ajax. This project should focus on editing data from the core_content table and will involve work with the team implementing the migration to core_content.

:'''Knowledge Prerequisite:''' A good knowledge of Joomla, of jQuery and Ajax techniques would help a lot here.

:'''Difficulty:''' Medium to Hard

====Project: front-end editor for modules and menus====

:'''Brief explanation:''' Allow seamless ajax-driven content-editing in the fronted of existing content and allowing to insert new modules.

:'''Expected Results:''' Authors with ACL permissions should be able to directly edit modules (titles and content/settings, and inserting new modules including menus the front-end. There are a number of possible approaches this could take. For example, they could possibly use the administration interface in the front-end, otherwise with links to the corresponding administration page. This would at least allow to remove the guesswork of which module outputs what result. Using an open-source html-contenteditable javascript editor would help here in the formatting. Another possibility would be to use a services model.

Note: There will be some overlap here with the potential com_services project so project could be incorporated into that project or there could be coordination of the two projects.

:'''Knowledge Prerequisite:''' A good knowledge of Joomla, of jQuery and Ajax techniques would help a lot here.

:'''Difficulty:''' Medium to Hard

====Project: Update and add new editor plugins====

:'''Brief explanation:''' Joomla has a system of editor_xtd plugins that allow users to safely insert correct html for common items such as images, page breaks, and links to articles independent of the editor used. This project will involve updating and adding new plugins and improving usabilty. For example in terms of new plugins might include:
* A plugin that adds modal behaviour (JHTML::_('behavior.modal');). The plugin can be deactivated by a {}tag (like {modal state=0}).
* A plugin that allows safe embedding of external web services such as video or maps.

Updating plugins would include generalizing the article plugin to work across all content types using the core_content table.

Here is an example of how a plan for a modal plugin would look:

*Background: A link with the attribute 'class="modal"' is opened in a kind of lightbox. Thus easily galleries can be generated. Additionally prepare editor(s) (e. g. via editor.css in template folder) to offer the modal class in their link edit display.

*Expected Results: The modal behaviour is always available - if plugin is published and it is not forbidden by a tag. And a link with class 'modal' can easily be generated - via button and/or via editor.
Note that this may not be the ideal way to provide this functionality, it could be that the existing articles plugin is modified to allow a link type of modal for example. Thus this project would involve a careful review of existing plugins.

:'''Expected Results:''' New plugins for a number of useful items, updates to older plugins and improved user interface for the buttons.

:'''Knowledge Prerequisite:''' PHP, HTML, Javascript

:'''Difficulty:''' Easy/Medium

====Project: Add plugin 'mvc override'====

:'''Brief explanation:''' Generate a plugin that enables the developer to overwrite models and controllers.

:'''Expected Results:''' Any model and controller can be overridden.

:'''Knowledge Prerequisite:''' Joomla! CMS, PHP

:'''Difficulty:''' Medium

====Project: Hathor is beautiful====

:'''Brief explanation:''' Make the admin template 'Hathor' more beautiful. Hathor is Isis' little sister. While Isis is breathtaking, Hathor still lacks a little css: She's edgy, and pale, and boring. Yet she always does what she is told. She deserves being tended a little. No additional functionality needed, no html changes, just css beauty.

: Note that for Google Summer of Code here must be substantial coding involved in the project. In the case of Hathor this would likely involve work on making Bootstrap Javascript meet accessibility standards and work on the core administrator layouts.

:'''Expected Results:''' Hathor is beautiful.

:'''Knowledge Prerequisite:''' Javascript, CSS, HTML, PHP

:'''Difficulty:''' Easy

====Project: Accesssible Backend Template====

:'''Brief explanation:''' For most people, the internet has become the norm. Information from around the world is freely available. But not all people are benefitting from it, especially those with disabilities. For those who find it difficult to participate fully in social life, much can be gained from communication technology. But they often face barriers which make it difficult to access information and applications. Take "looking for a job" as an example. The computer gives people with disabilities excellent prospects in overcoming limitations to find employment. Wouldn't it be nice if they had full access to the Joomla backend? New career opportunties would be opened up. If the requirements of accessibility are carefully met, it would make the system easier to understand and easier to use for all users.

: We already, have an accessible backend Joomla template, but it is not very attractive and it is not using all the new technical possibilities.
: For this reason we are looking for someone who will use Bootstrap to build (with our support):

: - an attractive, accessible design with good user guidance (layout & colors, contrast)

: - a meaningful semantic structure based on web standards

: Some preliminary steps have been made to get you started, but this remains a very complex endeavor.

:'''Expected Results:''' Accessible admin template

:'''Knowledge Prerequisite:''' WAI-ARIA, Javascript, CSS, HTML, PHP

:'''Difficulty:''' Medium-Hard

: Posible mentors: Angie Radtke

====Project: Refactor document model containers====

:'''Brief explanation:''' When I say document model containers, what I'm really talking about is all those arrays in the document model that store things like metas, scripts, css, etc. Those can be rendered collectively in the template using the jdoc head tag. The project would refactor the document model to allow more robust methods of working with document containers. One solution would be to use PHP ArrayObjects instead of simple arrays.

:'''Expected Results:''' A robust solution should allow methods for appending and prepending items, method chaining, and the ability to create custom containers from within extensions and templates.

:'''Knowledge Prerequisite:''' Joomla! CMS, PHP, some html, some css, and some javascript.

:'''Difficulty:''' Medium

:'''References:'''
:* Joomla! Forums topic: [[jtopic:793482|The ArrayObject - a different approach to document containers]]
:: (the editor would not allow me to post the link)

====Project: Add fieldtype 'oclock' in fields====

:'''Brief explanation:''' Joomla!'s form generation offers a fix group of field types, such as text, textarea, radio, calendar etc. Write another field that enables the developer to create a time field, call it 'oclock' or something else sensible. The display of the time should be configurable via a format attribute. It should have the look'n'feel of the calendar field ([[Calendar form field type|Calendar form field type]])

:'''Expected Results:''' Generation of a time field called in xml via <field type="oclock" .../>

:'''Knowledge Prerequisite:''' PHP, HTML, Javascript

:'''Difficulty:''' Medium

====Project: Task scheduler and manager====

:'''Brief explanation:''' Manage ,schedule and create tasks, from CMS administrator side, such as backup, virus scan, billing, reports, emailing and so on

:'''Expected Results:''': The student will be expected to build an hosting agnostic solution that act as a framework to manage task, allowing to manage tasks from third party extensions too, and some ready to run common task

:'''References:'''
:* http://en.wikipedia.org/wiki/Batch_processing
:* http://en.wikipedia.org/wiki/Scheduling_(computing)
:* http://en.wikipedia.org/wiki/Cron
:* http://en.wikipedia.org/wiki/Webcron
:* http://en.wikipedia.org/wiki/Daemon_(computing)
:* https://github.com/joomla/joomla-platform-examples/blob/master/cli/cron-plugins/run.php

:'''Knowledge Prerequisite:''': PHP, Joomla CMS, Joomla Platform, Mysql, Operating Systems.
:'''Difficulty:''' Hard
:'''Possible Mentors:''' Nicola Galgano

====Project: Improvements to Template Manager for CMS 3====

:'''Brief explanation:''' Templates are one of the most important elements of the Joomla CMS but except for the addition of template styles and template copy the functionality of the template manager has not changed dramatically since 1.5. Currently users must go outside of the template manager to add CSS, to add or modify override files or to manage their LESS. This project will make working with templates easier and more user friendly.

:'''Expected Results:''' By the end of the summer the student will produce fully documented and system tested code to do at least the following tasks in the template manager user interface:
:* See a list of overrides for a template
:* Edit the overrides for a template
:* Create a new override for a template (ideally with option to copy the core layout as a starting point)
:* Add a new CSS file to a template
:* Edit LESS file
:* Compile LESS
:* Upload images to a template's image
:* Provide a method of simple interaction with web based font and other providers.
Exact details to be developed in discussion with mentors.

:'''Knowledge Prerequisite:''' Familiarity with the Joomla CMS and templates, PHP, file management, usability, javascript

:'''Difficulty:''' Medium

==== Project: Remote web services management system for CMS 3====
:'''Brief explanation:''' Integration with remote services is a central feature of the modern web. This Joomla CMS should provide ways for webmasters to seamlessly and easily manage their interactions withe external service providers.
:'''Expected Results:''' A system for managing interactions with external services. This would include but not be limited to:
:* Secure management of public and private keys using Keychain
:* Storage of relevant urls
:* Methods to safely manage embedding by front end users
:* Plugins for Google, Twitter and Facebook authentication

:'''Knowledge Prerequisite:''' PHP, Javascript, Joomla CMS, Web Servics
:'''Difficulty:''' Medium to Hard

====Project: Redesign Users Profiles as a Form of Content for CMS 3====

:'''Brief explanation:''' Build a new way to manage and display user profiles as a content type stored in the core content table with a combination of systems including both he current profile plugin system and new ways of approaching this including the use of the core fields for body, images, urls and xreference. At the same time improve integration with contact data providing the ability to easily search and sort and send email as well as to have complex layouts and integration of web services.

:'''Expected Results:''' A front end user profile system that provides a flexible way to create and manage use profiles. This system will follow Joomla design patterns and be fully documented, have unit tests for any classes, and have system tests.

:'''Knowledge Prerequisite:''' PHP, Javascript, usability, familiarity with the Joomla CMS.

:'''Difficulty:''' Medium to Hard

====Project: Create com_services for front end website administration for CMS 3====

:'''Brief explanation:''' The user experience for beginning site administrators in particular but also all site administrators will be improved if they can carry out basic administrative tasks such as updating the site title, meta data and email address, clearing cache, setting component defaults and doing basic user management in the front end. In this project you will provide a RESTful service and front end interface to that service to allow this. Specific tasks to be implemented will be decided in discussion with the mentors.

:'''Expected Results:''' A basic services based system for managing certain administrative tasks from the front end of the Joomla CMS. This will be fully documented, have automated tests, and follow Joomla development best practices. It will also be extensible so that additional tasks can be added over time. This project will not involve content, only administrative tasks.

:'''Knowledge Prerequisite:''' PHP, Javascript, web services, security practices, Joomla CMS and framework.

:'''Difficulty:''' Hard

====Project: Webdriver system tests for CMS ====

:'''Brief explanation:''' Automated system tests allow us to test the CMS by automatically running Joomla from a browser, selecting menu options, and evaluating results. At present, most of the system tests are written using the now-outdated Selenium RC program. A small number of tests are currently completed using the newer Selenium Webdriver technology and using the [https://code.google.com/p/selenium/wiki/PageObjects Page Objects] pattern to separate the page objects from the test objects. This project will build on the current base of Webdriver tests and expand the test coverage to include more of the CMS.

:'''Expected Results:''' The student will complete the following tasks.
:# Create a strategy & roadmap for Joomla system tests. This will include things like:
:## How to organize the tests.
:## How to cover the critical back-end and front-end functionality of Joomla.
:# Write the reusable foundation classes for the expanded test coverage. These classes will be used to create the page object classes and test classes for the various portions of the CMS.
:# Begin the implementation of the roadmap.

:'''Knowledge Prerequisite:''' PHP, object-oriented programming, Joomla CMS (from a user point of view), HTML

:'''Difficulty:''' Medium

:'''Possible Mentors:''' Mark Dexter

====Project: Create a '''translating tool''' extension for Joomla ====

:'''Brief explanation:''' Projects like Facebook (see [http://www.insidefacebook.com/2008/04/02/now-you-can-help-translate-facebook-into-any-language/ insidefacebook.com/...]), RememberTheMilk ([http://www.rememberthemilk.com/services/translate/ http://www.rememberthemilk.com/...]) or other projects using [https://www.transifex.com] are taking advantage of their communities in order to localize their software. Joomla is being translated by its community into 64 languages but there is plenty of space for more languages and more community participation.
At the same time many Joomla 3rd party developers are searching for a solution on how their communities can contribute in the translation of their extensions.

:'''Expected Results:''' It is a Goal for this GSoC 2013 project to create an improved tool based in [http://extensions.joomla.org/extensions/languages/language-edition/17755 com_localise] that allows to translators to easily translate and upload their translations to a GitHub repository using [http://developer.joomla.org/manual/chap-Joomla_Platform_Manual-Github.html JGithub package]. The tool also should allow frontend community members to suggest translated strings just like Facebook or Rememerthemilk does.

:'''Knowledge Prerequisite:''' PHP, Git/Github, Joomla CMS and framework.

:'''Difficulty:''' Medium-Hard

:'''Posible mentors:''' Javier Gómez, Jean Marie Simonet, Edvard Ananyan

====Project: Module Modernization====

:'''Brief explanation:''' Modules are an important part of the CMS but many of the modules have not been updated in many years and do not take advantage of new features like JImage or JQuery, JLayouts, or PHP 5. In addition aspects of module handling such as loadposition/loadmodule and the handling of modules in templates are due for refactoring and improvement as is the user interface of com_modules. This project will work on bringing modules up to date with the rest of the CMS.

:'''Expected Results:''' Updated modules and module handling. Although subject to discussion with mentors, some likely areas are:
*Review all modules and bring up to PHP 5.4 standards.
*Incorporate JImage into modules as appropriate for example embedding the introtext image in articles modules.
*Incorporate or add new modules incorporating JQuery features such as image carousels.
*Add new modules for obviously missing features such as display of contact information.
*Develop the use of JLayouts in modules for standardization.
*Update the handling of loadposition.
*Work on handling modules as content and treating them as assets (i.e. providing module level access control).
*Work on a way to create basic configurable module default settings for items such as show title or class suffix.

:'''Knowledge Prerequisite:''' PHP, SQL, Joomla CMS

:'''Difficulty:''' Easy to Medium

:'''Possible mentors:''' Elin Waring

====Project: Smart Search Improvements====

:'''Brief explanation:''' Smart Search is an advanced search system for the Joomla CMS. While extremely powerful, it does has some limitations that we would like to address. First, it does always not properly handle some multibyte character sets and languages that do not use spaces between words. While partial solutions have been implemented, we would like to have more generic solutions. Also we would like to have a smart search interface in the Joomla Administrator and with the move to the core content model, to have better ties between smart search and other parts of the code base as well as extensions (how about an automated way to create a smart search plugin?). Finally, we would like to see some ongoing issues addressed including time out problems in the CLI application and modernization of queries and code to take advantage of newer databases and PHP versions as well as more parts of the Joomla API.

:'''Expected Results:''' A much improved Smart Search shipped as part of Joomla CMS 3.2.

:'''Knowledge Prerequisite:''' PHP, SQL, search principles, Joomla platform, Smart Search.

:'''Difficulty:''' Medium to Hard

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

{{dablink|Please add your project ideas here, you can use this '''[[GSOC 2013 Project template]]'''}}

===Joomla Framework===

The Joomla Platform allows for ideas that can work within the Joomla CMS, or could be completely separate applications that have no connection at all. The Joomla Platform allows for applications to be built for the command line, process daemons and the web. The follow list outlines some ideas that will be immediately useful for the Joomla Platform project that a student may consider taking on. In addition to PHP libraries, the Joomla Platform also ships with MooTools and project ideas can be related to client-side operations as well as server-side. One emphasis on this year's list is on the incorporation of packages for accessing web services, however other ideas for libraries and packages are welcome. In some instances multiple students may work on different aspects of the project. Two examples of this are unit testing and JStemmer.

References:
*[http://github.com/joomla/joomla-platform github Source Code]
*[http://developer.joomla.org/strategy.html Development Strategy]
*[http://groups.google.com/d/forum/joomla-dev-platform Developer Mailing List]

All code contributions must follow Joomla coding standards and include full unit test coverage.

====Project: Platform Unit Testing====

:'''Brief explanation:''' The Joomla Platform has a good suite of automated Unit Tests, but code coverage is lacking in some areas. The goal of this project is to improve the code coverage by writing unit tests for the Joomla Platform.

:'''Expected Results:''' The student will be expected to review the current [http://developer.joomla.org/coverage/ code coverage report] for the Joomla Platform and write and agreed-upon number of unit tests with particular attention to packages that are below 50% coverage. Preference should be given to non-deprecated classes but the student may choose from either the core tree (/libraries/joomla) or the legacy tree (/libraries/legacy).

:'''Knowledge Prerequisite:''' PHP, PHPUnit

:'''Difficulty:''' Medium

====Project: Object Relational Mapping (ORM) in Joomla====

:'''Explanation:''' Implementation of Object Relational Mapping to provide an exiting new basis for building (complex) applications on or within Joomla.

:Joomla uses an Active Record implementation. Via JTable and JTableNested data are CRUDded in models to and from database tables. Tables for different content types share the same kind of data and therefore code is duplicated. There are plans to solve this with a Unified Content Model (UCM), which will use a shared table for all content and a specialised table per content type. In order to implement that a JData class was made to store data in and a JDataMapper to map the database tables to the data. In terms of Martin Fowler's Patterns of Enterprise Architecture Patterns: Class Table Inheritance. This UCM would be a replacement for the current JTable classes and components.

:Object Relational Mapping, especially when one-to-many and many-to-many relations are in play, has already been worked out in the PHP-world with ORM-frameworks like Propel and Doctrine. No need to reinvent a complete new wheel. Some work has been done to use Doctrine ORM in Joomla extensions, but it could be made more generally usable and easily available to open a lot of possibilities.

:'''Expected Results:'''
:The focus for such a GSOC-project could be one of the following:
:* a more general ORM interface in which specific ORM packages could fit; be it a "native" JDataMapper or other 3rd party ORM packages.
:* or a specific implementation (like Doctrine) with which core CMS extensions could be refactored. This would be a UCM-implementation using an existing ORM package.
:Both the Joomla Platform/Framework and the CMS would benefit from such projects.

:'''Knowledge Prerequisite:''' Object Relational Mapping theory.

:'''References:'''
:* http://martinfowler.com/eaaCatalog/ and http://www.martinfowler.com/books/eaa.html
:* http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/index.html
:* https://github.com/eBaySF/joomla-platform/blob/data-package/docs/manual/en-US/chapters/packages/data.md#jdatamapper

:'''Difficulty:''' Medium to Hard

:'''Possible Mentors:''' Herman Peeren

====Project: Expand Google API coverage====

:'''Brief explanation:''' The JGoogle package provides a basic structure for using Google APIs in Joomla based code. However it only includes classes for a limited set of APIs. Your task is to dramatically expand the coverage of Google data. Specific APIs to be agreed upon with mentors, with some preference for those of immediate usefulness to the Joomla CMS.

:'''Expected Results:''' A set of well coded, fully unit tested and documented implementations for a range of Google data.

:'''Knowledge Prerequisite:''' Github, PHPUnit, familiarity with web services and the Joomla CMS.

:'''Difficulty:''' Medium

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

{{dablink|Please add your project ideas here, you can use this '''[[GSOC 2013 Project template]]'''}}

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

Unified Content Model Working Group

2013-03-30T02:16:17Z

Elin: /* Roadmap */

The Unified Content Model Working Group is a Production Working Group. UCM is powerful new tool that is proposed for inclusion in the Platform. What use will the CMS make of it, what are the backward compatibility issues involved, what new coding would be needed to use it in the CMS, and what are the implications for third party extensions are all open questions.

==Coordinators & PLT Contact==

Elin Waring
==Announcements==

==External resources==

Background Materials

The original code from eBay

The first extended discussion on the platform mailing list.

Rob Schley talk at Joomla Day New York

Elin Waring slides for PWG lightning talks at Joomla and Beyond 2012

Video of PWG Meeting at JAB 2012

Video of session on UCM at Joomla World Conference

Slides from Elin's session on UCM at JWC

Sam's example of a web services application

Stefan's GSOC application using UCM

==Deliverables==

Long term, a new Joomla application for the management of content.

==Technical Work produced by this group==

==Communications==

==Roadmap==
This effort can be thought of as two coordinated efforts:
* Work on the CMS 3 series to implement UCM for the core and extensions that wish to opt into it.
* Work on a the CMS 4 series that would be built around this model as well as other architectural changes.

Steps
*Initial infrastructure for use of a single core table: 3.1.
*Migration to a he single core content table for all core components for 3.2

==Meetings==

[[Category:Documentation Working Group]]
[[Category:Working Groups]]

Unified Content Model Working Group

2013-03-30T02:10:35Z

Elin: /* Roadmap */

The Unified Content Model Working Group is a Production Working Group. UCM is powerful new tool that is proposed for inclusion in the Platform. What use will the CMS make of it, what are the backward compatibility issues involved, what new coding would be needed to use it in the CMS, and what are the implications for third party extensions are all open questions.

==Coordinators & PLT Contact==

Elin Waring
==Announcements==

==External resources==

Background Materials

The original code from eBay

The first extended discussion on the platform mailing list.

Rob Schley talk at Joomla Day New York

Elin Waring slides for PWG lightning talks at Joomla and Beyond 2012

Video of PWG Meeting at JAB 2012

Video of session on UCM at Joomla World Conference

Slides from Elin's session on UCM at JWC

Sam's example of a web services application

Stefan's GSOC application using UCM

==Deliverables==

Long term, a new Joomla application for the management of content.

==Technical Work produced by this group==

==Communications==

==Roadmap==
Initial infrastructure for use of a single core table: 3.1.
Migration to a single core content table for all core components for 3.2

==Meetings==

[[Category:Documentation Working Group]]
[[Category:Working Groups]]

GSOC 2013 Project Ideas

2013-03-29T04:21:27Z

Elin: /* Project: Module Modernization */

<div style="float:right; margin-left:1em; width:40%;">__TOC__</div>
<div style="float:left; margin-right:1em;">[[Image:GSOC_2013.png|150px‎]]</div>

==Welcome!==
Welcome to the Joomla! Google Summer of Code (GSoC) 2013 project ideas page. As we move forward with the 2013 version of the Joomla! GSoC, we will use this page to develop possible project ideas. Please note that anyone who is interested can participate in this process. You do not have to be a GSoC student or mentor to suggest possible project ideas. Please keep in mind that projects need to be realistically something that is able to be functionally completed by a student working full time for about eight weeks. Thanks!

Discussion of ideas and other GSoC related items is welcome on our Google Group: https://groups.google.com/forum/?fromgroups#!forum/joomla-gsoc-2013

If you are interested in participating as a student please review the materials on applying that are available at [http://www.google-melange.com/gsoc/document/show/gsoc_program/google/gsoc2013/help_page Google]. We strongly encourage you to ask questions about process and ideas on the mailing list.

If you are interested in serving as a mentor, please fill out the [https://docs.google.com/a/community.joomla.org/spreadsheet/viewform?formkey=dHA2V1lJbThYQXpwMERiRG1FOTZlV3c6MA Mentor Application Form 2013].

==Ideas==

Opportunities exist for students to work with projects from either the Joomla CMS, the Joomla Platform or in some cases a combination of both.

In addition to this ideas list, the Joomla! Community is able to voice their opinion on features they would like to see via the [http://ideas.joomla.org/ Joomla! Idea Pool]. Those wishing to add ideas to this listing are encouraged to review the Idea Pool and base their idea on the input received there. You can also view the past lists for [http://docs.joomla.org/GSOC_2012_Project_Ideas 2012] [http://docs.joomla.org/Summer_of_Code_2010_Project_Ideas 2010] and [http://docs.joomla.org/Summer_of_Code_2009_Project_Ideas 2009], which may be useful for reference. We ask that you keep ideas realistic for the time frame that students will have to complete their projects.

Unless a mentor has proposed a specific project, mentors from the mentor pool will be matched with student projects. However members of the mentor pool are available to answer questions on the Joomla GSoC mailing list.

===Joomla CMS===

* [http://github.com/joomla/joomla-cms Source Code]
* [http://groups.google.com/d/forum/joomla-dev-cms Developer Mailing List]

====Project: Build New Media Manager for CMS 3====

:'''Brief Explanation:''' The current media manager is outdated and limited. Build a new media manager to include a better user interface, more robust functionality, and seamless integration for extensions to use. The improvements could include:
* Storage of media information in the database (including standard file property information, created by user and date, rights and other meta data and tracking of media as assets).
* Allow renaming of files
* Automated creation of thumbnails to dimensions that the webmaster can configure
* Support for a variety of media types that addresses security concerns
* Creation of a number of controllers for media manipulation such as cropping, resizing and filtering and implementation of their use.
* Use of nesting for management and display of media options
* Management of both local and remote media
* Support for creation of collections of media for example for display in a carousel as a separate content type.

:'''Expected Results:''' A new Media Manager component to improve the usability, functionality, and reusability of the extension. Work should be fully documented and include system tests as well as unit tests for all new classes.

: The work will likely include creation of a new media management package in the CMS library as well as reusable controllers for media related tasks.

: The work should align with other work in the content model and the student should expect to interact extensively with the team working on the Joomla 3.2 release.

:'''Knowledge Prerequisite:''' PHP, MySQL, Javascript, Joomla CMS, Joomla Platform, HTML5, Usability

:'''Difficulty:''' Medium

====Project: Convert JavaScript from MooTools to jQuery====

:'''Brief explanation:''' Version 3 of the CMS introduced [http://twitter.github.com/bootstrap Twitter Bootstrap] and [http://jquery.com jQuery] to the core code base. Previous versions of the CMS had been using MooTools as the preferred JavaScript library. Currently, both JavaScript libraries are shipped and used within the CMS, which occasionally causes conflicts with a user's JavaScript functionality. The CMS would like to reduce the dependency on MooTools by converting its core JavaScript behaviors from MooTools to jQuery or providing custom solutions.

:'''Expected Results:''' Dependency on MooTools is reduced within the CMS.

:'''Knowledge Prerequisite:''' Joomla CMS, PHP, JavaScript

:'''Difficulty:''' Medium

====Project: html contenteditable Ajax based front-end editor for articles, categories, tags and other content====

:'''Brief explanation:''' Allow seamless ajax-driven content-editing in the fronted of existing content.

:'''Expected Results:''' Authors with ACL permissions should be able to directly edit all content (content, weblinks, contacts, newsfeeds and categories as well as any new types that are added in the future) from the front-end. Administrators should be able to configure front end editing for appropriate users to have access to the full set of fields available in the back end in the front end (rather than the limited set of fields now available). All this should be done using Ajax. This project should focus on editing data from the core_content table and will involve work with the team implementing the migration to core_content.

:'''Knowledge Prerequisite:''' A good knowledge of Joomla, of jQuery and Ajax techniques would help a lot here.

:'''Difficulty:''' Medium to Hard

====Project: front-end editor for modules and menus====

:'''Brief explanation:''' Allow seamless ajax-driven content-editing in the fronted of existing content and allowing to insert new modules.

:'''Expected Results:''' Authors with ACL permissions should be able to directly edit modules (titles and content/settings, and inserting new modules including menus the front-end. The modules and content parameters editing should not be re-invented but just use the administration interface, if possible in front-end, otherwise with links to the corresponding administration page. This would at least allow to remove the guesswork of which module outputs what result. Using an open-source html-contenteditable javascript editor would help here in the formatting.

Note: There will be some overlap here with the potential com_services project so project could be incorporated into that project or there could be coordination of the two projects.

:'''Knowledge Prerequisite:''' A good knowledge of Joomla, of jQuery and Ajax techniques would help a lot here.

:'''Difficulty:''' Medium to Hard

====Project: Update and add new editor plugins====

:'''Brief explanation:''' Joomla has a system of editor_xtd plugins that allow users to safely insert correct html for common items such as images, page breaks, and links to articles independent of the editor used. This project will involve updating and adding new plugins and improving usabilty. For example in terms of new plugins might include:
* A plugin that adds modal behaviour (JHTML::_('behavior.modal');). The plugin can be deactivated by a {}tag (like {modal state=0}).
* A plugin that allows safe embedding of external web services such as video or maps.

Updating plugins would include generalizing the article plugin to work across all content types using the core_content table.

Here is an example of how a plan for a modal plugin would look:

*Background: A link with the attribute 'class="modal"' is opened in a kind of lightbox. Thus easily galleries can be generated. Additionally prepare editor(s) (e. g. via editor.css in template folder) to offer the modal class in their link edit display.

*Expected Results: The modal behaviour is always available - if plugin is published and it is not forbidden by a tag. And a link with class 'modal' can easily be generated - via button and/or via editor.
Note that this may not be the ideal way to provide this functionality, it could be that the existing articles plugin is modified to allow a link type of modal for example. Thus this project would involve a careful review of existing plugins.

:'''Expected Results:''' New plugins for a number of useful items, updates to older plugins and improved user interface for the buttons.

:'''Knowledge Prerequisite:''' PHP, HTML, Javascript

:'''Difficulty:''' Easy/Medium

====Project: Add plugin 'mvc override'====

:'''Brief explanation:''' Generate a plugin that enables the developer to overwrite models and controllers.

:'''Expected Results:''' Any model and controller can be overridden.

:'''Knowledge Prerequisite:''' Joomla! CMS, PHP

:'''Difficulty:''' Medium

====Project: Hathor is beautiful====

:'''Brief explanation:''' Make the admin template 'Hathor' more beautiful. Hathor is Isis' little sister. While Isis is breathtaking, Hathor still lacks a little css: She's edgy, and pale, and boring. Yet she always does what she is told. She deserves being tended a little. No additional functionality needed, no html changes, just css beauty.

: Note that for Google Summer of Code here must be substantial coding involved in the project. In the case of Hathor this would likely involve work on making Bootstrap Javascript meet accessibility standards and work on the core administrator layouts.

:'''Expected Results:''' Hathor is beautiful.

:'''Knowledge Prerequisite:''' Javascript, CSS, HTML, PHP

:'''Difficulty:''' Easy

====Project: Accesssible Backend Template====

:'''Brief explanation:''' For most people, the internet has become the norm. Information from around the world is freely available. But not all people are benefitting from it, especially those with disabilities. For those who find it difficult to participate fully in social life, much can be gained from communication technology. But they often face barriers which make it difficult to access information and applications. Take "looking for a job" as an example. The computer gives people with disabilities excellent prospects in overcoming limitations to find employment. Wouldn't it be nice if they had full access to the Joomla backend? New career opportunties would be opened up. If the requirements of accessibility are carefully met, it would make the system easier to understand and easier to use for all users.

: We already, have an accessible backend Joomla template, but it is not very attractive and it is not using all the new technical possibilities.
: For this reason we are looking for someone who will use Bootstrap to build (with our support):

: - an attractive, accessible design with good user guidance (layout & colors, contrast)

: - a meaningful semantic structure based on web standards

: Some preliminary steps have been made to get you started, but this remains a very complex endeavor.

:'''Expected Results:''' Accessible admin template

:'''Knowledge Prerequisite:''' WAI-ARIA, Javascript, CSS, HTML, PHP

:'''Difficulty:''' Medium-Hard

: Posible mentors: Angie Radtke

====Project: Refactor document model containers====

:'''Brief explanation:''' When I say document model containers, what I'm really talking about is all those arrays in the document model that store things like metas, scripts, css, etc. Those can be rendered collectively in the template using the jdoc head tag. The project would refactor the document model to allow more robust methods of working with document containers. One solution would be to use PHP ArrayObjects instead of simple arrays.

:'''Expected Results:''' A robust solution should allow methods for appending and prepending items, method chaining, and the ability to create custom containers from within extensions and templates.

:'''Knowledge Prerequisite:''' Joomla! CMS, PHP, some html, some css, and some javascript.

:'''Difficulty:''' Medium

:'''References:'''
:* Joomla! Forums topic: [[jtopic:793482|The ArrayObject - a different approach to document containers]]
:: (the editor would not allow me to post the link)

====Project: Add fieldtype 'oclock' in fields====

:'''Brief explanation:''' Joomla!'s form generation offers a fix group of field types, such as text, textarea, radio, calendar etc. Write another field that enables the developer to create a time field, call it 'oclock' or something else sensible. The display of the time should be configurable via a format attribute. It should have the look'n'feel of the calendar field ([[Calendar form field type|Calendar form field type]])

:'''Expected Results:''' Generation of a time field called in xml via <field type="oclock" .../>

:'''Knowledge Prerequisite:''' PHP, HTML, Javascript

:'''Difficulty:''' Medium

====Project: Task scheduler and manager====

:'''Brief explanation:''' Manage ,schedule and create tasks, from CMS administrator side, such as backup, virus scan, billing, reports, emailing and so on

:'''Expected Results:''': The student will be expected to build an hosting agnostic solution that act as a framework to manage task, allowing to manage tasks from third party extensions too, and some ready to run common task

:'''References:'''
:* http://en.wikipedia.org/wiki/Batch_processing
:* http://en.wikipedia.org/wiki/Scheduling_(computing)
:* http://en.wikipedia.org/wiki/Cron
:* http://en.wikipedia.org/wiki/Webcron
:* http://en.wikipedia.org/wiki/Daemon_(computing)
:* https://github.com/joomla/joomla-platform-examples/blob/master/cli/cron-plugins/run.php

:'''Knowledge Prerequisite:''': PHP, Joomla CMS, Joomla Platform, Mysql, Operating Systems.
:'''Difficulty:''' Hard
:'''Possible Mentors:''' Nicola Galgano

====Project: Improvements to Template Manager for CMS 3====

:'''Brief explanation:''' Templates are one of the most important elements of the Joomla CMS but except for the addition of template styles and template copy the functionality of the template manager has not changed dramatically since 1.5. Currently users must go outside of the template manager to add CSS, to add or modify override files or to manage their LESS. This project will make working with templates easier and more user friendly.

:'''Expected Results:''' By the end of the summer the student will produce fully documented and system tested code to do at least the following tasks in the template manager user interface:
:* See a list of overrides for a template
:* Edit the overrides for a template
:* Create a new override for a template (ideally with option to copy the core layout as a starting point)
:* Add a new CSS file to a template
:* Edit LESS file
:* Compile LESS
:* Upload images to a template's image
:* Provide a method of simple interaction with web based font and other providers.
Exact details to be developed in discussion with mentors.

:'''Knowledge Prerequisite:''' Familiarity with the Joomla CMS and templates, PHP, file management, usability, javascript

:'''Difficulty:''' Medium

==== Project: Remote web services management system for CMS 3====
:'''Brief explanation:''' Integration with remote services is a central feature of the modern web. This Joomla CMS should provide ways for webmasters to seamlessly and easily manage their interactions withe external service providers.
:'''Expected Results:''' A system for managing interactions with external services. This would include but not be limited to:
:* Secure management of public and private keys using Keychain
:* Storage of relevant urls
:* Methods to safely manage embedding by front end users
:* Plugins for Google, Twitter and Facebook authentication

:'''Knowledge Prerequisite:''' PHP, Javascript, Joomla CMS, Web Servics
:'''Difficulty:''' Medium to Hard

====Project: Redesign Users Profiles as a Form of Content for CMS 3====

:'''Brief explanation:''' Build a new way to manage and display user profiles as a content type stored in the core content table with a combination of systems including both he current profile plugin system and new ways of approaching this including the use of the core fields for body, images, urls and xreference. At the same time improve integration with contact data providing the ability to easily search and sort and send email as well as to have complex layouts and integration of web services.

:'''Expected Results:''' A front end user profile system that provides a flexible way to create and manage use profiles. This system will follow Joomla design patterns and be fully documented, have unit tests for any classes, and have system tests.

:'''Knowledge Prerequisite:''' PHP, Javascript, usability, familiarity with the Joomla CMS.

:'''Difficulty:''' Medium to Hard

====Project: Create com_services for front end website administration for CMS 3====

:'''Brief explanation:''' The user experience for beginning site administrators in particular but also all site administrators will be improved if they can carry out basic administrative tasks such as updating the site title, meta data and email address, clearing cache, setting component defaults and doing basic user management in the front end. In this project you will provide a RESTful service and front end interface to that service to allow this. Specific tasks to be implemented will be decided in discussion with the mentors.

:'''Expected Results:''' A basic services based system for managing certain administrative tasks from the front end of the Joomla CMS. This will be fully documented, have automated tests, and follow Joomla development best practices. It will also be extensible so that additional tasks can be added over time. This project will not involve content, only administrative tasks.

:'''Knowledge Prerequisite:''' PHP, Javascript, web services, security practices, Joomla CMS and framework.

:'''Difficulty:''' Hard

====Project: Webdriver system tests for CMS ====

:'''Brief explanation:''' Automated system tests allow us to test the CMS by automatically running Joomla from a browser, selecting menu options, and evaluating results. At present, most of the system tests are written using the now-outdated Selenium RC program. A small number of tests are currently completed using the newer Selenium Webdriver technology and using the [https://code.google.com/p/selenium/wiki/PageObjects Page Objects] pattern to separate the page objects from the test objects. This project will build on the current base of Webdriver tests and expand the test coverage to include more of the CMS.

:'''Expected Results:''' The student will complete the following tasks.
:# Create a strategy & roadmap for Joomla system tests. This will include things like:
:## How to organize the tests.
:## How to cover the critical back-end and front-end functionality of Joomla.
:# Write the reusable foundation classes for the expanded test coverage. These classes will be used to create the page object classes and test classes for the various portions of the CMS.
:# Begin the implementation of the roadmap.

:'''Knowledge Prerequisite:''' PHP, object-oriented programming, Joomla CMS (from a user point of view), HTML

:'''Difficulty:''' Medium

:'''Possible Mentors:''' Mark Dexter

====Project: Create a '''translating tool''' extension for Joomla ====

:'''Brief explanation:''' Projects like Facebook (see [http://www.insidefacebook.com/2008/04/02/now-you-can-help-translate-facebook-into-any-language/ insidefacebook.com/...]), RememberTheMilk ([http://www.rememberthemilk.com/services/translate/ http://www.rememberthemilk.com/...]) or other projects using [https://www.transifex.com] are taking advantage of their communities in order to localize their software. Joomla is being translated by its community into 64 languages but there is plenty of space for more languages and more community participation.
At the same time many Joomla 3rd party developers are searching for a solution on how their communities can contribute in the translation of their extensions.

:'''Expected Results:''' It is a Goal for this GSoC 2013 project to create an improved tool based in [http://extensions.joomla.org/extensions/languages/language-edition/17755 com_localise] that allows to translators to easily translate and upload their translations to a GitHub repository using [http://developer.joomla.org/manual/chap-Joomla_Platform_Manual-Github.html JGithub package]. The tool also should allow frontend community members to suggest translated strings just like Facebook or Rememerthemilk does.

:'''Knowledge Prerequisite:''' PHP, Git/Github, Joomla CMS and framework.

:'''Difficulty:''' Medium-Hard

:'''Posible mentors:''' Javier Gómez, Jean Marie Simonet

====Project: Module Modernization====

:'''Brief explanation:''' Modules are an important part of the CMS but many of the modules have not been updated in many years and do not take advantage of new features like JImage or JQuery, JLayouts, or PHP 5. In addition aspects of module handling such as loadposition/loadmodule and the handling of modules in templates are due for refactoring and improvement as is the user interface of com_modules. This project will work on bringing modules up to date with the rest of the CMS.

:'''Expected Results:''' Updated modules and module handling. Although subject to discussion with mentors, some likely areas are:
*Review all modules and bring up to PHP 5.4 standards.
*Incorporate JImage into modules as appropriate for example embedding the introtext image in articles modules.
*Incorporate or add new modules incorporating JQuery features such as image carousels.
*Add new modules for obviously missing features such as display of contact information.
*Develop the use of JLayouts in modules for standardization.
*Update the handling of loadposition.
*Work on handling modules as content and treating them as assets (i.e. providing module level access control).
*Work on a way to create basic configurable module default settings for items such as show title or class suffix.

:'''Knowledge Prerequisite:''' PHP, SQL, Joomla CMS

:'''Difficulty:''' Easy to Medium

:'''Possible mentors:''' Elin Waring

====Project: Smart Search Improvements====

:'''Brief explanation:''' Smart Search is an advanced search system for the Joomla CMS. While extremely powerful, it does has some limitations that we would like to address. First, it does always not properly handle some multibyte character sets and languages that do not use spaces between words. While partial solutions have been implemented, we would like to have more generic solutions. Also we would like to have a smart search interface in the Joomla Administrator and with the move to the core content model, to have better ties between smart search and other parts of the code base as well as extensions (how about an automated way to create a smart search plugin?). Finally, we would like to see some ongoing issues addressed including time out problems in the CLI application and modernization of queries and code to take advantage of newer databases and PHP versions as well as more parts of the Joomla API.

:'''Expected Results:''' A much improved Smart Search shipped as part of Joomla CMS 3.2.

:'''Knowledge Prerequisite:''' PHP, SQL, search principles, Joomla platform, Smart Search.

:'''Difficulty:''' Medium to Hard

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

{{dablink|Please add your project ideas here, you can use this '''[[GSOC 2013 Project template]]'''}}

===Joomla Framework===

The Joomla Platform allows for ideas that can work within the Joomla CMS, or could be completely separate applications that have no connection at all. The Joomla Platform allows for applications to be built for the command line, process daemons and the web. The follow list outlines some ideas that will be immediately useful for the Joomla Platform project that a student may consider taking on. In addition to PHP libraries, the Joomla Platform also ships with MooTools and project ideas can be related to client-side operations as well as server-side. One emphasis on this year's list is on the incorporation of packages for accessing web services, however other ideas for libraries and packages are welcome. In some instances multiple students may work on different aspects of the project. Two examples of this are unit testing and JStemmer.

References:
*[http://github.com/joomla/joomla-platform github Source Code]
*[http://developer.joomla.org/strategy.html Development Strategy]
*[http://groups.google.com/d/forum/joomla-dev-platform Developer Mailing List]

All code contributions must follow Joomla coding standards and include full unit test coverage.

====Project: Platform Unit Testing====

:'''Brief explanation:''' The Joomla Platform has a good suite of automated Unit Tests, but code coverage is lacking in some areas. The goal of this project is to improve the code coverage by writing unit tests for the Joomla Platform.

:'''Expected Results:''' The student will be expected to review the current [http://developer.joomla.org/coverage/ code coverage report] for the Joomla Platform and write and agreed-upon number of unit tests with particular attention to packages that are below 50% coverage. Preference should be given to non-deprecated classes but the student may choose from either the core tree (/libraries/joomla) or the legacy tree (/libraries/legacy).

:'''Knowledge Prerequisite:''' PHP, PHPUnit

:'''Difficulty:''' Medium

====Project: Object Relational Mapping (ORM) in Joomla====

:'''Explanation:''' Implementation of Object Relational Mapping to provide an exiting new basis for building (complex) applications on or within Joomla.

:Joomla uses an Active Record implementation. Via JTable and JTableNested data are CRUDded in models to and from database tables. Tables for different content types share the same kind of data and therefore code is duplicated. There are plans to solve this with a Unified Content Model (UCM), which will use a shared table for all content and a specialised table per content type. In order to implement that a JData class was made to store data in and a JDataMapper to map the database tables to the data. In terms of Martin Fowler's Patterns of Enterprise Architecture Patterns: Class Table Inheritance. This UCM would be a replacement for the current JTable classes and components.

:Object Relational Mapping, especially when one-to-many and many-to-many relations are in play, has already been worked out in the PHP-world with ORM-frameworks like Propel and Doctrine. No need to reinvent a complete new wheel. Some work has been done to use Doctrine ORM in Joomla extensions, but it could be made more generally usable and easily available to open a lot of possibilities.

:'''Expected Results:'''
:The focus for such a GSOC-project could be one of the following:
:* a more general ORM interface in which specific ORM packages could fit; be it a "native" JDataMapper or other 3rd party ORM packages.
:* or a specific implementation (like Doctrine) with which core CMS extensions could be refactored. This would be a UCM-implementation using an existing ORM package.
:Both the Joomla Platform/Framework and the CMS would benefit from such projects.

:'''Knowledge Prerequisite:''' Object Relational Mapping theory.

:'''References:'''
:* http://martinfowler.com/eaaCatalog/ and http://www.martinfowler.com/books/eaa.html
:* http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/index.html
:* https://github.com/eBaySF/joomla-platform/blob/data-package/docs/manual/en-US/chapters/packages/data.md#jdatamapper

:'''Difficulty:''' Medium to Hard

:'''Possible Mentors:''' Herman Peeren

====Project: Expand Google API coverage====

:'''Brief explanation:''' The JGoogle package provides a basic structure for using Google APIs in Joomla based code. However it only includes classes for a limited set of APIs. Your task is to dramatically expand the coverage of Google data. Specific APIs to be agreed upon with mentors, with some preference for those of immediate usefulness to the Joomla CMS.

:'''Expected Results:''' A set of well coded, fully unit tested and documented implementations for a range of Google data.

:'''Knowledge Prerequisite:''' Github, PHPUnit, familiarity with web services and the Joomla CMS.

:'''Difficulty:''' Medium

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

{{dablink|Please add your project ideas here, you can use this '''[[GSOC 2013 Project template]]'''}}

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

GSOC 2013 Project Ideas

2013-03-25T06:56:44Z

Elin:

<div style="float:right; margin-left:1em; width:40%;">__TOC__</div>
<div style="float:left; margin-right:1em;">[[Image:GSOC_2013.png|150px‎]]</div>

==Welcome!==
Welcome to the Joomla! Google Summer of Code (GSoC) 2013 project ideas page. As we move forward with the 2013 version of the Joomla! GSoC, we will use this page to develop possible project ideas. Please note that anyone who is interested can participate in this process. You do not have to be a GSoC student or mentor to suggest possible project ideas. Please keep in mind that projects need to be realistically something that is able to be functionally completed by a student working full time for about eight weeks. Thanks!

Discussion of ideas and other GSoC related items is welcome on our Google Group: https://groups.google.com/forum/?fromgroups#!forum/joomla-gsoc-2013

If you are interested in participating as a student please review the materials on applying that are available at [http://www.google-melange.com/gsoc/document/show/gsoc_program/google/gsoc2013/help_page Google]. We strongly encourage you to ask questions about process and ideas on the mailing list.

If you are interested in serving as a mentor, please fill out the [https://docs.google.com/a/community.joomla.org/spreadsheet/viewform?formkey=dHA2V1lJbThYQXpwMERiRG1FOTZlV3c6MA Mentor Application Form 2013].

==Ideas==

Opportunities exist for students to work with projects from either the Joomla CMS, the Joomla Platform or in some cases a combination of both.

In addition to this ideas list, the Joomla! Community is able to voice their opinion on features they would like to see via the [http://ideas.joomla.org/ Joomla! Idea Pool]. Those wishing to add ideas to this listing are encouraged to review the Idea Pool and base their idea on the input received there. You can also view the past lists for [http://docs.joomla.org/GSOC_2012_Project_Ideas 2012] [http://docs.joomla.org/Summer_of_Code_2010_Project_Ideas 2010] and [http://docs.joomla.org/Summer_of_Code_2009_Project_Ideas 2009], which may be useful for reference. We ask that you keep ideas realistic for the time frame that students will have to complete their projects.

Unless a mentor has proposed a specific project, mentors from the mentor pool will be matched with student projects. However members of the mentor pool are available to answer questions on the Joomla GSoC mailing list.

===Joomla CMS===

* [http://github.com/joomla/joomla-cms Source Code]
* [http://groups.google.com/d/forum/joomla-dev-cms Developer Mailing List]

====Project: Build New Media Manager for CMS 3====

:'''Brief Explanation:''' The current media manager is outdated and limited. Build a new media manager to include a better user interface, more robust functionality, and seamless integration for extensions to use. The improvements could include:
* Storage of media information in the database (including standard file property information, created by user and date, rights and other meta data and tracking of media as assets).
* Allow renaming of files
* Automated creation of thumbnails to dimensions that the webmaster can configure
* Support for a variety of media types that addresses security concerns
* Creation of a number of controllers for media manipulation such as cropping, resizing and filtering and implementation of their use.
* Use of nesting for management and display of media options
* Management of both local and remote media
* Support for creation of collections of media for example for display in a carousel as a separate content type.

:'''Expected Results:''' A new Media Manager component to improve the usability, functionality, and reusability of the extension. Work should be fully documented and include system tests as well as unit tests for all new classes.

: The work will likely include creation of a new media management package in the CMS library as well as reusable controllers for media related tasks.

: The work should align with other work in the content model and the student should expect to interact extensively with the team working on the Joomla 3.2 release.

:'''Knowledge Prerequisite:''' PHP, MySQL, Javascript, Joomla CMS, Joomla Platform, HTML5, Usability

:'''Difficulty:''' Medium

====Project: Convert JavaScript from MooTools to jQuery====

:'''Brief explanation:''' Version 3 of the CMS introduced [http://twitter.github.com/bootstrap Twitter Bootstrap] and [http://jquery.com jQuery] to the core code base. Previous versions of the CMS had been using MooTools as the preferred JavaScript library. Currently, both JavaScript libraries are shipped and used within the CMS, which occasionally causes conflicts with a user's JavaScript functionality. The CMS would like to reduce the dependency on MooTools by converting its core JavaScript behaviors from MooTools to jQuery or providing custom solutions.

:'''Expected Results:''' Dependency on MooTools is reduced within the CMS.

:'''Knowledge Prerequisite:''' Joomla CMS, PHP, JavaScript

:'''Difficulty:''' Medium

====Project: html contenteditable Ajax based front-end editor for articles, categories, tags and other content====

:'''Brief explanation:''' Allow seamless ajax-driven content-editing in the fronted of existing content.

:'''Expected Results:''' Authors with ACL permissions should be able to directly edit all content (content, weblinks, contacts, newsfeeds and categories as well as any new types that are added in the future) from the front-end. Administrators should be able to configure front end editing for appropriate users to have access to the full set of fields available in the back end in the front end (rather than the limited set of fields now available). All this should be done using Ajax. This project should focus on editing data from the core_content table and will involve work with the team implementing the migration to core_content.

:'''Knowledge Prerequisite:''' A good knowledge of Joomla, of jQuery and Ajax techniques would help a lot here.

:'''Difficulty:''' Medium to Hard

====Project: front-end editor for modules and menus====

:'''Brief explanation:''' Allow seamless ajax-driven content-editing in the fronted of existing content and allowing to insert new modules.

:'''Expected Results:''' Authors with ACL permissions should be able to directly edit modules (titles and content/settings, and inserting new modules including menus the front-end. The modules and content parameters editing should not be re-invented but just use the administration interface, if possible in front-end, otherwise with links to the corresponding administration page. This would at least allow to remove the guesswork of which module outputs what result. Using an open-source html-contenteditable javascript editor would help here in the formatting.

Note: There will be some overlap here with the potential com_services project so project could be incorporated into that project or there could be coordination of the two projects.

:'''Knowledge Prerequisite:''' A good knowledge of Joomla, of jQuery and Ajax techniques would help a lot here.

:'''Difficulty:''' Medium to Hard

====Project: Update and add new editor plugins====

:'''Brief explanation:''' Joomla has a system of editor_xtd plugins that allow users to safely insert correct html for common items such as images, page breaks, and links to articles independent of the editor used. This project will involve updating and adding new plugins and improving usabilty. For example in terms of new plugins might include:
* A plugin that adds modal behaviour (JHTML::_('behavior.modal');). The plugin can be deactivated by a {}tag (like {modal state=0}).
* A plugin that allows safe embedding of external web services such as video or maps.

Updating plugins would include generalizing the article plugin to work across all content types using the core_content table.

Here is an example of how a plan for a modal plugin would look:

*Background: A link with the attribute 'class="modal"' is opened in a kind of lightbox. Thus easily galleries can be generated. Additionally prepare editor(s) (e. g. via editor.css in template folder) to offer the modal class in their link edit display.

*Expected Results: The modal behaviour is always available - if plugin is published and it is not forbidden by a tag. And a link with class 'modal' can easily be generated - via button and/or via editor.
Note that this may not be the ideal way to provide this functionality, it could be that the existing articles plugin is modified to allow a link type of modal for example. Thus this project would involve a careful review of existing plugins.

:'''Expected Results:''' New plugins for a number of useful items, updates to older plugins and improved user interface for the buttons.

:'''Knowledge Prerequisite:''' PHP, HTML, Javascript

:'''Difficulty:''' Easy/Medium

====Project: Add plugin 'mvc override'====

:'''Brief explanation:''' Generate a plugin that enables the developer to overwrite models and controllers.

:'''Expected Results:''' Any model and controller can be overridden.

:'''Knowledge Prerequisite:''' Joomla! CMS, PHP

:'''Difficulty:''' Medium

====Project: Hathor is beautiful====

:'''Brief explanation:''' Make the admin template 'Hathor' more beautiful. Hathor is Isis' little sister. While Isis is breathtaking, Hathor still lacks a little css: She's edgy, and pale, and boring. Yet she always does what she is told. She deserves being tended a little. No additional functionality needed, no html changes, just css beauty.

: Note that for Google Summer of Code here must be substantial coding involved in the project. In the case of Hathor this would likely involve work on making Bootstrap Javascript meet accessibility standards and work on the core administrator layouts.

:'''Expected Results:''' Hathor is beautiful.

:'''Knowledge Prerequisite:''' Javascript, CSS, HTML, PHP

:'''Difficulty:''' Easy

====Project: Accesssible Backend Template====

:'''Brief explanation:''' For most people, the internet has become the norm. Information from around the world is freely available. But not all people are benefitting from it, especially those with disabilities. For those who find it difficult to participate fully in social life, much can be gained from communication technology. But they often face barriers which make it difficult to access information and applications. Take "looking for a job" as an example. The computer gives people with disabilities excellent prospects in overcoming limitations to find employment. Wouldn't it be nice if they had full access to the Joomla backend? New career opportunties would be opened up. If the requirements of accessibility are carefully met, it would make the system easier to understand and easier to use for all users.

: We already, have an accessible backend Joomla template, but it is not very attractive and it is not using all the new technical possibilities.
: For this reason we are looking for someone who will use Bootstrap to build (with our support):

: - an attractive, accessible design with good user guidance (layout & colors, contrast)

: - a meaningful semantic structure based on web standards

: Some preliminary steps have been made to get you started, but this remains a very complex endeavor.

:'''Expected Results:''' Accessible admin template

:'''Knowledge Prerequisite:''' WAI-ARIA, Javascript, CSS, HTML, PHP

:'''Difficulty:''' Medium-Hard

: Posible mentors: Angie Radtke

====Project: Refactor document model containers====

:'''Brief explanation:''' When I say document model containers, what I'm really talking about is all those arrays in the document model that store things like metas, scripts, css, etc. Those can be rendered collectively in the template using the jdoc head tag. The project would refactor the document model to allow more robust methods of working with document containers. One solution would be to use PHP ArrayObjects instead of simple arrays.

:'''Expected Results:''' A robust solution should allow methods for appending and prepending items, method chaining, and the ability to create custom containers from within extensions and templates.

:'''Knowledge Prerequisite:''' Joomla! CMS, PHP, some html, some css, and some javascript.

:'''Difficulty:''' Medium

:'''References:'''
:* Joomla! Forums topic: [[jtopic:793482|The ArrayObject - a different approach to document containers]]
:: (the editor would not allow me to post the link)

====Project: Add fieldtype 'oclock' in fields====

:'''Brief explanation:''' Joomla!'s form generation offers a fix group of field types, such as text, textarea, radio, calendar etc. Write another field that enables the developer to create a time field, call it 'oclock' or something else sensible. The display of the time should be configurable via a format attribute. It should have the look'n'feel of the calendar field ([[Calendar form field type|Calendar form field type]])

:'''Expected Results:''' Generation of a time field called in xml via <field type="oclock" .../>

:'''Knowledge Prerequisite:''' PHP, HTML, Javascript

:'''Difficulty:''' Medium

====Project: Task scheduler and manager====

:'''Brief explanation:''' Manage ,schedule and create tasks, from CMS administrator side, such as backup, virus scan, billing, reports, emailing and so on

:'''Expected Results:''': The student will be expected to build an hosting agnostic solution that act as a framework to manage task, allowing to manage tasks from third party extensions too, and some ready to run common task

:'''References:'''
:* http://en.wikipedia.org/wiki/Batch_processing
:* http://en.wikipedia.org/wiki/Scheduling_(computing)
:* http://en.wikipedia.org/wiki/Cron
:* http://en.wikipedia.org/wiki/Webcron
:* http://en.wikipedia.org/wiki/Daemon_(computing)
:* https://github.com/joomla/joomla-platform-examples/blob/master/cli/cron-plugins/run.php

:'''Knowledge Prerequisite:''': PHP, Joomla CMS, Joomla Platform, Mysql, Operating Systems.
:'''Difficulty:''' Hard
:'''Possible Mentors:''' Nicola Galgano

====Project: Improvements to Template Manager for CMS 3====

:'''Brief explanation:''' Templates are one of the most important elements of the Joomla CMS but except for the addition of template styles and template copy the functionality of the template manager has not changed dramatically since 1.5. Currently users must go outside of the template manager to add CSS, to add or modify override files or to manage their LESS. This project will make working with templates easier and more user friendly.

:'''Expected Results:''' By the end of the summer the student will produce fully documented and system tested code to do at least the following tasks in the template manager user interface:
:* See a list of overrides for a template
:* Edit the overrides for a template
:* Create a new override for a template (ideally with option to copy the core layout as a starting point)
:* Add a new CSS file to a template
:* Edit LESS file
:* Compile LESS
:* Upload images to a template's image
:* Provide a method of simple interaction with web based font and other providers.
Exact details to be developed in discussion with mentors.

:'''Knowledge Prerequisite:''' Familiarity with the Joomla CMS and templates, PHP, file management, usability, javascript

:'''Difficulty:''' Medium

==== Project: Remote web services management system for CMS 3====
:'''Brief explanation:''' Integration with remote services is a central feature of the modern web. This Joomla CMS should provide ways for webmasters to seamlessly and easily manage their interactions withe external service providers.
:'''Expected Results:''' A system for managing interactions with external services. This would include but not be limited to:
:* Secure management of public and private keys using Keychain
:* Storage of relevant urls
:* Methods to safely manage embedding by front end users
:* Plugins for Google, Twitter and Facebook authentication

:'''Knowledge Prerequisite:''' PHP, Javascript, Joomla CMS, Web Servics
:'''Difficulty:''' Medium to Hard

====Project: Redesign Users Profiles as a Form of Content for CMS 3====

:'''Brief explanation:''' Build a new way to manage and display user profiles as a content type stored in the core content table with a combination of systems including both he current profile plugin system and new ways of approaching this including the use of the core fields for body, images, urls and xreference. At the same time improve integration with contact data providing the ability to easily search and sort and send email as well as to have complex layouts and integration of web services.

:'''Expected Results:''' A front end user profile system that provides a flexible way to create and manage use profiles. This system will follow Joomla design patterns and be fully documented, have unit tests for any classes, and have system tests.

:'''Knowledge Prerequisite:''' PHP, Javascript, usability, familiarity with the Joomla CMS.

:'''Difficulty:''' Medium to Hard

====Project: Create com_services for front end website administration for CMS 3====

:'''Brief explanation:''' The user experience for beginning site administrators in particular but also all site administrators will be improved if they can carry out basic administrative tasks such as updating the site title, meta data and email address, clearing cache, setting component defaults and doing basic user management in the front end. In this project you will provide a RESTful service and front end interface to that service to allow this. Specific tasks to be implemented will be decided in discussion with the mentors.

:'''Expected Results:''' A basic services based system for managing certain administrative tasks from the front end of the Joomla CMS. This will be fully documented, have automated tests, and follow Joomla development best practices. It will also be extensible so that additional tasks can be added over time. This project will not involve content, only administrative tasks.

:'''Knowledge Prerequisite:''' PHP, Javascript, web services, security practices, Joomla CMS and framework.

:'''Difficulty:''' Hard

====Project: Webdriver system tests for CMS ====

:'''Brief explanation:''' Automated system tests allow us to test the CMS by automatically running Joomla from a browser, selecting menu options, and evaluating results. At present, most of the system tests are written using the now-outdated Selenium RC program. A small number of tests are currently completed using the newer Selenium Webdriver technology and using the [https://code.google.com/p/selenium/wiki/PageObjects Page Objects] pattern to separate the page objects from the test objects. This project will build on the current base of Webdriver tests and expand the test coverage to include more of the CMS.

:'''Expected Results:''' The student will complete the following tasks.
:# Create a strategy & roadmap for Joomla system tests. This will include things like:
:## How to organize the tests.
:## How to cover the critical back-end and front-end functionality of Joomla.
:# Write the reusable foundation classes for the expanded test coverage. These classes will be used to create the page object classes and test classes for the various portions of the CMS.
:# Begin the implementation of the roadmap.

:'''Knowledge Prerequisite:''' PHP, object-oriented programming, Joomla CMS (from a user point of view), HTML

:'''Difficulty:''' Medium

:'''Possible Mentors:''' Mark Dexter

====Project: Create a '''translating tool''' extension for Joomla ====

:'''Brief explanation:''' Projects like Facebook (see [http://www.insidefacebook.com/2008/04/02/now-you-can-help-translate-facebook-into-any-language/ insidefacebook.com/...]), RememberTheMilk ([http://www.rememberthemilk.com/services/translate/ http://www.rememberthemilk.com/...]) or other projects using [https://www.transifex.com] are taking advantage of their communities in order to localize their software. Joomla is being translated by its community into 64 languages but there is plenty of space for more languages and more community participation.
At the same time many Joomla 3rd party developers are searching for a solution on how their communities can contribute in the translation of their extensions.

:'''Expected Results:''' It is a Goal for this GSoC 2013 project to create an improved tool based in [http://extensions.joomla.org/extensions/languages/language-edition/17755 com_localise] that allows to translators to easily translate and upload their translations to a GitHub repository using [http://developer.joomla.org/manual/chap-Joomla_Platform_Manual-Github.html JGithub package]. The tool also should allow frontend community members to suggest translated strings just like Facebook or Rememerthemilk does.

:'''Knowledge Prerequisite:''' PHP, Git/Github, Joomla CMS and framework.

:'''Difficulty:''' Medium-Hard

:'''Posible mentors:''' Javier Gómez, Jean Marie Simonet

====Project: Module Modernization====

:'''Brief explanation:''' Modules are an important part of the CMS but many of the modules have not been updated in many years and do not take advantage of new features like JImage or JQuery, JLayouts, or PHP 5. In addition aspects of module handling such as loadposition/loadmodule and the handling of modules in templates are due for refactoring and improvement as is the user interface of com_modules. This project will work on bringing modules up to date with the rest of the CMS.

:'''Expected Results:''' Updated modules and module handling. Although subject to discussion with mentors, some likely areas are:
*Review all modules and bring up to PHP 5.4 standards.
*Incorporate JImage into modules as appropriate for example embedding the introtext image in articles modules.
*Incorporate or add new modules incorporating JQuery features such as image carousels.
*Add new modules for obviously missing features such as display of contact information.
*Develop the use of JLayouts in modules for standardization.
*Update the handling of loadposition.
*Work on handling modules as content and treating them as assets (i.e. providing module level access control).

:'''Knowledge Prerequisite:''' PHP, SQL, Joomla CMS

:'''Difficulty:''' Easy to Medium

:'''Posible mentors:''' Elin Waring

{{dablink|Please add your project ideas here, you can use this '''[[GSOC 2013 Project template]]'''}}

===Joomla Framework===

The Joomla Platform allows for ideas that can work within the Joomla CMS, or could be completely separate applications that have no connection at all. The Joomla Platform allows for applications to be built for the command line, process daemons and the web. The follow list outlines some ideas that will be immediately useful for the Joomla Platform project that a student may consider taking on. In addition to PHP libraries, the Joomla Platform also ships with MooTools and project ideas can be related to client-side operations as well as server-side. One emphasis on this year's list is on the incorporation of packages for accessing web services, however other ideas for libraries and packages are welcome. In some instances multiple students may work on different aspects of the project. Two examples of this are unit testing and JStemmer.

References:
*[http://github.com/joomla/joomla-platform github Source Code]
*[http://developer.joomla.org/strategy.html Development Strategy]
*[http://groups.google.com/d/forum/joomla-dev-platform Developer Mailing List]

All code contributions must follow Joomla coding standards and include full unit test coverage.

====Project: Platform Unit Testing====

:'''Brief explanation:''' The Joomla Platform has a good suite of automated Unit Tests, but code coverage is lacking in some areas. The goal of this project is to improve the code coverage by writing unit tests for the Joomla Platform.

:'''Expected Results:''' The student will be expected to review the current [http://developer.joomla.org/coverage/ code coverage report] for the Joomla Platform and write and agreed-upon number of unit tests with particular attention to packages that are below 50% coverage. Preference should be given to non-deprecated classes but the student may choose from either the core tree (/libraries/joomla) or the legacy tree (/libraries/legacy).

:'''Knowledge Prerequisite:''' PHP, PHPUnit

:'''Difficulty:''' Medium

====Project: Object Relational Mapping (ORM) in Joomla====

:'''Explanation:''' Implementation of Object Relational Mapping to provide an exiting new basis for building (complex) applications on or within Joomla.

:Joomla uses an Active Record implementation. Via JTable and JTableNested data are CRUDded in models to and from database tables. Tables for different content types share the same kind of data and therefore code is duplicated. There are plans to solve this with a Unified Content Model (UCM), which will use a shared table for all content and a specialised table per content type. In order to implement that a JData class was made to store data in and a JDataMapper to map the database tables to the data. In terms of Martin Fowler's Patterns of Enterprise Architecture Patterns: Class Table Inheritance. This UCM would be a replacement for the current JTable classes and components.

:Object Relational Mapping, especially when one-to-many and many-to-many relations are in play, has already been worked out in the PHP-world with ORM-frameworks like Propel and Doctrine. No need to reinvent a complete new wheel. Some work has been done to use Doctrine ORM in Joomla extensions, but it could be made more generally usable and easily available to open a lot of possibilities.

:'''Expected Results:'''
:The focus for such a GSOC-project could be one of the following:
:* a more general ORM interface in which specific ORM packages could fit; be it a "native" JDataMapper or other 3rd party ORM packages.
:* or a specific implementation (like Doctrine) with which core CMS extensions could be refactored. This would be a UCM-implementation using an existing ORM package.
:Both the Joomla Platform/Framework and the CMS would benefit from such projects.

:'''Knowledge Prerequisite:''' Object Relational Mapping theory.

:'''References:'''
:* http://martinfowler.com/eaaCatalog/ and http://www.martinfowler.com/books/eaa.html
:* http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/index.html
:* https://github.com/eBaySF/joomla-platform/blob/data-package/docs/manual/en-US/chapters/packages/data.md#jdatamapper

:'''Difficulty:''' Medium to Hard

:'''Possible Mentors:''' Herman Peeren

====Project: Expand Google API coverage====

:'''Brief explanation:''' The JGoogle package provides a basic structure for using Google APIs in Joomla based code. However it only includes classes for a limited set of APIs. Your task is to dramatically expand the coverage of Google data. Specific APIs to be agreed upon with mentors, with some preference for those of immediate usefulness to the Joomla CMS.

:'''Expected Results:''' A set of well coded, fully unit tested and documented implementations for a range of Google data.

:'''Knowledge Prerequisite:''' Github, PHPUnit, familiarity with web services and the Joomla CMS.

:'''Difficulty:''' Medium

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>

{{dablink|Please add your project ideas here, you can use this '''[[GSOC 2013 Project template]]'''}}

<noinclude>[[Category:Google Summer of Code 2013]]</noinclude>