3 Extension Development Third Edition Create your own plugins, modules, and components examples Tim Plummer BIRMINGHAM - MUMBAI Learning Joomla! eBook versions of every book published, with PDF and ePub files available?. Learning Joomla! 3 Extension Development, 3rd Edition by Tim Plummer Packt Publishing; 3rd Edition (July ) | ISBN: | PDF +. Learning Joomla! 3 Extension Development, 3rd Edition by Tim Plummer Packt Publishing; 3rd Edition (July ) | ISBN: | PDF + EPUB |
|Language:||English, Spanish, Dutch|
|Distribution:||Free* [*Registration needed]|
Joomla 3 is the first of the major open source content management systems that was meant to be mobile friendly by default. PDF下载地址( MB) 3 Extension Development, Third Edition” is an integrated series of practical, hands- on. Learning Joomla! 3 Extension Development-Third Edition. Clear steps to create your own plugins, modules, and components for Joomla 3. If you have ideas for additional Joomla 3! features, this book will allow you to realize them. It's a complete practical guide to building and.
There is no need to supply a username and password, which is all done for you by Joomla!. If you were to take a look in your configuration. The true parameter in the qetQuery states that we are starting a new query and not continuing a previous one. Each of these query lines can be in any order, so if you wanted to put the order clause before the select statement, that would still work fine.
This is why we are sorting in descending order indicated by DESC. Although it will still work, you should refrain from doing so as it won't be database agnostic.
You can see that this returns all the data we would like to display in our module. Here is the output of this query, which shows the data that we will be displaying in our module.
After the query, we add in a bit of error checking, so if our query has an error in it or something goes wrong, we can raise a error. Because we are expecting multiple values from this query, we use loadObjectList.
Here is an example of how we would have used getErrorNum in the past; any code like this should be rewritten to use try catch as per the previous code. Notice the use of htmlspecialchars function, which will convert any HTML code in these fields into text content rather than interpreting the content as HTML.
Also notice how the id is cast as an integer using int , which we will talk more about in Chapter 8, Security — Avoiding Common Vulnerabilities. Zip it up and install your module Now it is time to test the module out on your Joomla!
We will start by manually installing the module on our development site, and then we will create an installable ZIP file that you can distribute to other people.
Administrator, navigate to Extensions Extension Manager, and select the Discover view on the left. Click on the Discover button and you should see the Latest Extensions module appearing. You will then need to navigate to Extensions Module Manager, and change the filter on the left to Administrator, so you can see all the backend modules.
Click the New button and select Latest Extensions module. Now navigate to System Control Panel and take a look; you should see the module appearing. You will notice that the most recently installed module is Latest Extensions, then the second most recent should be the plugin we created earlier, that is, Content — Click To Call. Navigate to Module Module Manager.
Make sure the filter on the left is still set to Administrator and select the Latest Extensions Module. Click on the Options tab and change the count from 5 to If you have Firebug installed in the Firefox browser, you can right-click with your mouse on the text and select Inspect element from the menu, and you will see the div around the module has the class latestextensionspackt which shows our Module Class Suffix is working.
All the major browsers now have some kind of similar development tools built in, so what you choose to use is entirely up to you, but I still like Firebug. Backwards compatibility for Joomla! We will change the version attribute to indicate that this module will work on Joomla!
In fact, this module isn't using any legacy MVC classes, so it would also work on earlier versions of Joomla! Could not find a Joomla! XML setup file in the package. This is because the extension tag used to be called install, so Joomla!
Install and publish the module on your Joomla! You will notice that we don't have those nice columns anymore, the extension type and ID number appear on lines underneath.
This is due to the fact that Joomla! The purpose of the media folder is for extensions to save CSS, images, and related media. Don't forget to add an index.
Packaging for distribution Since we have made these changes, you will need to zip all this up again to create the installable package. This is really easy to do, just edit your installation XML file and change the client to "site".
You will notice that in the Module Manager, it now shows as a site extension. Publish your module and give it a module position, for example, position Congratulations, you've now created a frontend module, which should now be visible on your site. English speakers will not need to translate, but may want to override your text and show some custom text that they feel is more appropriate, and we don't want them having to edit source code.
We are going to use the administrator version of our module, not the frontend "site" version, but the same changes could be made to the frontend module. Firstly, we have added a language file to our module which is going to contain the language strings.
The module class suffix is already using language strings from the core, so we don't need to add these language strings. In this example, we are creating a field call count and defining a label and a description. If all goes well, you should not notice any difference as we are using the exact same language strings that we had previously hardcoded.
Then, go into your module and take a look at the count option and you should see this new text appear. Let's assume you want to translate the module into Dutch. In the folder you are using to create your installable package, create the folder nl-NL in the language folder, and copy into this folder your en-GB. Ideally you should have a native speaker of that language to adjust the language file.
You can read more about this at http: I would estimate that over 40 percent of my customers are not native English speakers. The extension of mine that supports the most languages only has 17 different language files, so I challenge you to beat me. Adding a help file When you distribute your module, you may want to include a help file that will help the user understand how to use your module.
You may have noticed a Help button in your toolbar when you edit your module. By default, this is a generic help file for modules, however you can customize this button to make it link to a help file that is specific to your module. You can do this through your language file. Now obviously you are going to have to create the yourhelpfile.
For demonstration purposes, you can just set the URL to http: As you can see, clicking on the help button will make that URL appear in a pop-up window. A template override basically tells your Joomla!
You end up with two copies of the file: This way you can make whatever customizations you like including adding new features, or removing or hiding the ones you don't want.
When customizing a module someone else has developed, it is much better to use a template override than to hack the code of the module, because any changes will be lost when the module is upgraded if you edit the code directly.
In case you have never been told this, you should never ever change a core Joomla! You wouldn't normally create a template override of your own module, but it's important to understand how they work so you get an idea of what other people will be doing with your module.
When providing support, it is a good idea to check to make sure the user has not introduced the problem themselves through bad code in a template override. There is nothing special you need to do to make your module support layout overrides, just the fact you are using MVC means you get this feature for free. Note that you drop the tmpl folder name when creating the template override. Make some minor changes such as removing the ID column and save the file.
Template overrides change every instance of the module, whereas alternative layouts give you the flexibility of presenting the same module in different ways on the same site.
Although we created the template override in the backend, this works exactly the same for the frontend of Joomla!. You can use template overrides to change the contents of core Joomla!
Template overrides for components works in the same way as modules, however since a component usually has multiple views, you need to include the view in the folder structure. This doesn't happen very often, as most of the files you are overriding are views which don't change much, but it's something to keep in mind, and it may be worth notifying your users when you make major changes to your views.
We will need to make a slight change to your module to enable this, but as you will see, it is very easy to implement. We don't even need to add language strings, as it is using core language strings. So now let's try it out and see what we have just done. This is very similar to how you would normally create a template override of a view, but in this case we are giving the file a different name. The HTML folder in your template is where all the overrides and alternative layouts are placed; if this folder does not exist then you can just create it.
For example, put the extension type in brackets after the component name, delete the second column, and change the first column to span9. We are still using the same data, just displaying it differently or leaving some information out. This demonstrates the advantages of the MVC architecture where the content is separated from the presentation.
Any user of your module can just copy your view, make some minor changes, and they easily have a custom version of your module that exactly suits their needs, without touching any of the complex code.
You can see that adding this alternative layout parameter is effortless but adds a lot of flexibility and will make your users very happy. The same thing can be done for frontend modules. Mobile devices have very small screens, so we can hide the unnecessary details and just show the important information to the mobile users, but still show the additional information to our desktop users.
We can take advantage of Bootstrap and apply some classes that will do all the hard work. Obviously this assumes that the user's template is using Bootstrap.
Don't forget to get rid of the template override from the previous section, otherwise you are not going to see your changes. The first one, hidden-phone, will show this column on a desktop computer, and on a tablet device such as an iPad, but will hide this column when viewed on a mobile device such as an iPhone, Blackberry or Android device.
The hidden-tablet class is similar; however it will hide the column on tablet devices, but will show the column on desktop computers and mobile devices. You can apply more than one class, as you can see here, we are going to hide the ID column on both tablets and phones.
This is all based on the browser width, so if you drag the edge of your browser and make the window smaller, you will see firstly the ID column will disappear, and then the type column will disappear as shown in the following screenshots. Notice how only two columns are visible when the browser window is narrower as shown in the following screenshot: As you can see, our module now responds to the browser size and adjusts what the user can see dynamically.
Summary Congratulations, you have now created your first module for Joomla! The module we initially created was for the Joomla! You've learned how to connect to your database to retrieve information and display it in a view within your module.
We've also made some changes to the module to allow it to work in Joomla! We added a language file to your module and made it more user-friendly with a help file. We also added the flexibility of alternative layouts, played around with template overrides, and made our module responsive.
You should now have a good understanding of the differences between plugins and modules, and now you are ready to tackle the big challenge of creating a component which is coming up in the next chapter. At the end of this chapter you will have built a very simple component, which we will make much more complex in the following couple of chapters.
In this chapter, we are going to create the building blocks of our component. We are not going to worry too much about all the functionality yet, you need to learn the basics first. If you haven't yet gone through the plugin and module examples in the previous chapters, I encourage you to go back and do them first, as we will be building on the knowledge you have already gained. You will learn: Components are the most complex Joomla!
That said, components allow you to really take full advantage of the power of Joomla! Once you get your head around it, you will see they are really not as daunting as they may seem at first.
Getting Started with Component Development Once again, before you start coding you need to have a good idea about what it is you are trying to implement. Let's assume that you want to create a simple portfolio extension for your website. You've had a look on the JED, and haven't found quite what you are looking for, and the existing extensions are either way too complex or they don't suit your needs. You've searched the JED and Google and this name is available.
For each portfolio item, we want to show an image, have a descriptive title, and a URL link that the user will go to when they click on the image or logo, and we will add a phone number too. Although we will not be implementing all this functionality in this chapter, it's still worth knowing what we will eventually end up with. The installation XML file contains details such as the version number, all the files and folders used by the component, database installation file details, and component parameters.
This time we are going to create the files directly on your development website rather than in a folder on your desktop.
Put the following code in the file. We will then go through each line and take a look at what it all does. Version 3. If we fixed a minor bug and that was the only thing that changed, our next version would be 1.
If we introduced a new feature that added some new functionality, we might call the next Version 1. If we did some massive changes to the component, perhaps refactoring some of the code, then we might call the next Version 2.
It's important that you stick to the three part version numbering, as it will make it easier when you create updates later, particularly those that alter the database structure such as when a new field is added.
The description of the component is shown when you install it, or view it by going to Components Component Manager, so we want this to appear in the local language if the user's site uses another language. When you install your component, you need to run some SQL command to create the table, so the install tag tells Joomla! If you are supporting multiple database types, you'll need a separate database installation file for each database type.
The uninstall SQL files allow you to do that. As with the install SQL files, if you are supporting multiple database types, you will need a separate file for each database type. The site folder contains all the files used by the frontend of the Joomla! For individual files, you use the filename tag, but if you want to include an entire folder with all files and subfolders within it, you can use the folder tag.
This makes it really easy for a user to create a language override and change the text of your component without having to edit any of the source code.
You'll notice that in here is a menu tag, this is the menu item that will appear on the component menu in the backend of your website. Each menu item has an image defined, which is not used by the default template in Joomla!
Some Joomla! The files used by the backend of the component are in the admin folder. Just like the frontend files, you can list files individually using the filename tag, and entire folders of files using the folder tag. There are two files, the. Any language string used in the XML files come from the. Each index. After that you include a short description of what this language string is for, making sure you don't use any spaces, only uppercase characters and underscores.
The right-hand side of the language string is enclosed within speech marks, and is the actual text shown on the site.
When your extension is translated into another language, the translator only needs to change this right-hand side of the language string in their new language file. Creating a simple component In addition to the installation XML file, there are quite a few files you need to create to make a simple component. We'll start out by creating all the folders for the backend.
This is the first file that is executed when Joomla! Next we check the permissions. Specifically we are checking to make sure that the current user has a manage permission to this component. By default, all administrators and super administrators have a manage permission on every component that is installed on the website, however it is possible to adjust the permissions to allow people to log onto the backend of the site and only access specific components.
The JFactory:: If the user does not have access to manage this component, they will get a error. The manage permission is called Access Administration Interface in the permissions for the component.
This name will be used as the prefix for all the classes; for example, FolioViewFolios or FolioHelper. You can also include your own custom permissions if you wanted to. We will add some options later, but for now we just want the Folio tab to appear. This file will contain most of the language strings used by the backend of our component. Your local development environment should include phpMyAdmin which allows you to access the database directly.
Select your database. Press the GO button. For now we are just creating three fields, an id field that contains a unique reference number for that record, the title field, and an alias field.
When we distribute our component to other people, we don't want them to have to manually add the table into their own database, so we can create an install SQL script that will run when the component is installed. However, there are a couple of files we referred to in our installation XML file that we have not created yet, so we need to create these even if they are empty , otherwise the install will fail.
Create the following files, and just leave the contents of them empty for now: Go to Extensions Extension Manager Discover. Select the Folio component. Press the install button. If you click on this menu item, it's not going to work yet because we haven't created the views, but your component has now been registered in the database.
Creating the controllers Joomla! So we need to create the controllers for this component. There is a main controller file for the component, and each view will have its own controller. We then create the class for the controller, which is the component name followed by Controller.
We are extending the JControllerLegacy class, so we get a lot of functionality for free. In our case, our default view is folios, whereas our component is called folio, so we need to define this.
If nothing is defined, it will default to the folios view using the default layout. When you examine the URL, while using a component, you'll notice the view and layout variables; for example, index. This code will protect the component from someone trying to access the edit form directly, and will just show them an error message and redirect them back to the default view: In our case, our edit view is going to be folio, so our list view must be called folios.
The controller names should match the view, so we are going to create two more controllers, one for each of these views. You'll notice that the model has a prefix ComponentnameModel and a name that matches our edit view, so put it together and our model class will be called FolioModelFolio: Creating the model for the list view Now we will need to create the model files that Joomla! You will notice that we are not using the alias field, it is not necessary to use every field in the database for every view.
It prepares the query to select the information we need from our database. This adds some flexibility to the query, as potentially a developer could override the fields selected by setting a custom statement in the state variable, but that is an advanced topic which is out of scope for this book.
We then define a prefix that is used with controller messages, which is just the name of the component. The table has a prefix ComponentnameTable, and a type which matches our view name, in this case Folio. At the moment we are just loading the function from the parent class, but later on we'll add some more code in here. This is just an XML file that defines the fields we are going to use on our form.
We group fields together using the fieldset tag, you can have multiple fieldsets in a form, but as this is a simple extension it only has the one fieldset.
Within fieldset there is a field definition for each of the fields in our database. The label is the text that appears to the left of the field to describe it. The description is the text that appears when you hover the mouse over the label, and it is a description of what this field does that will help the user. This is a mandatory field, so required is set to true. This will trigger form validation and force the user to enter something in this field before the form is saved.
Leave this blank and Joomla will fill in a default value from the title. It has to be unique for each folio item in the same category. You can skip the next few pages if you just want to get stuck in with the rest of the hands-on example, and just go straight to the Creating a view section, but you may want to refer back to this bit later when you are creating your own components. Accesslevel The accesslevel field creates a drop-down list that is populated with all the viewing access levels.
This field is used in your global configuration. This field does not work on the backend of Joomla! Category The category field will show a drop-down list of all the available categories for the extension. You need to specify which component you are getting the categories for in the extension attribute. Firstly, you will need to apply some CSS styles to make it look good, because you can see by default in the Isis template that there are bullet points next to each checkbox.
More importantly, while JForm will display this question type, it does not store the results in the database; it just returns an array containing the options selected, and you will need to write some custom code to correctly store this into your database.
Many Joomla! You will notice that none of the core components use the checkboxes question type. But from what I can tell, this field doesn't work as intended, and no one actually uses it.
At the time of writing, either there is a bug causing it not to work, or this field is only partially implemented, as the list of options has the display: And if you look at the HTML code generated, all the options are in a hidden ul: What this field type should produce is something like this, where the first option allows you to type text, or you can choose one of the other predefined options available: Componentlayout The componentlayout field provides a drop-down list of all the available layouts for a view of an extension.
It is used in conjunction with the language switcher plugin. It provides a list of all content types. The value of this field is set via code, and there is nothing visible to the user. It will only list images with. It should be noted that the media manager does not resize images or create thumbnails, but it does allow you to upload new files or select existing ones. Essentially, this will just put the filename of the image selected into the database. This field does not work in components.
This field stores the actual password as plain text, and it does not obscure it with any hash function. No value is stored in the database. It does not allow you to query external databases. It allows you to show a nested list of tags. Tel The tel field type is like a textbox, but it can be used to make sure the user enters a phone number.
The user profile plugin is the only place in the core that uses this field type. An advantage of using an HTML5 input is that devices using a virtual keyboard such as a smartphone will display a different keyboard to the user depending on the type of input field they are using.
However, it appears that the tel field has not been fully implemented yet. It currently just outputs the same as if you had used a text input. Apparently this field type is just a place holder that people wanted to have in place in anticipation of full HTML5 support. If you start using this field type now, presumably you will be able to benefit from the new HTML5 functionality when it is implemented in a future Joomla!
The rows and cols determine the size of the field. Like the tel field type, it appears that the url field has not been fully implemented yet.
Usergroup The usergroup field type allows you to create a list of user groups on your Joomla! Our component has two views: The list view There are several files that work together to create the view. We have already created the controller file that calls the view, and the model file that prepares the data. But we have not yet created the view files that display the information. The view. Remember to put an index. To do this permission check, we have created a function in our helper file, as we probably want to share this functionality with other views that we add in future.
We will create this helper file after we have finished examining this file. In this case, we are adding a new record to the folio form. Before we show the edit button, we first check to make sure the current user has edit permission for this component. Before we show the options button, we need to check to make sure the current user has admin permission for this component also known as the configure action.
Essentially, it is just looking at the component permission settings for the groups that this user is in. By default, Joomla! Whenever this form is submitted, it just goes back to the same view you are currently in, which is also the default view in our component. The name and id of adminForm is important, if you leave these out then the buttons on your form such as Save and Close will not work. Notice the hidden- phone class applied to the checkall column.
This is one of the styles in Bootstrap that will hide this content when viewed on a mobile device. For the first column checkall, instead of showing a text title, we will put a checkbox that will select all items currently shown on the view rather than the user having to select each one individually.
You could put your own custom language string in here instead to display some other text, if you wanted. You could also use hidden-desktop for content that you want to hide when viewed on desktop computers, but want to show on tablet devices and mobile devices such as iPhone, Android, or Blackberry.
For each record, we are going to display a checkbox to select that individual item, and a title which is clickable to open up that record. Notice how we are using the JRoute function again to make sure clicking on this link doesn't have any SEF issues.
The boxchecked value is used to determine which items have the checkbox next to them selected. This ensures that the form that is submitted is from the same Joomla! It should have the singular version of the plural name you used for your list view.
Since our list view was called folios, we will call our edit view folio. If your list view was called books, your edit view would be book, or another example is if the list view was called cars, then the edit view would be called car.
An example of when an error may occur is if one of the fields is missing from our database table, which could happen if the software is upgraded to a newer version and the update script hasn't added all the new fields. Since our component doesn't have any other views, it's not really an issue yet, but later on when we add more views it would be come a problem.
We will need to add a language string for this title. This will show a Cancel button if you create a new record, or a Close button if you are editing an existing record. So within this folder create an edit. Instead of using expandable sections like in previous Joomla! The title on our tab will change depending on whether you are creating a new item or editing an existing one.
We will need to add these new language strings to our language file.
In our case, we are only showing one field, however we will add more fields to our component in the next chapter. Go ahead and try it out, you should now be able to create new items, enter a title, and save the form. You can also edit the form and change the title.
Installer script The installer script file allows you to run code when your component is installed, uninstalled, or updated, and also before and after the component is installed. At the moment it just redirects to the default view of the component after installation. You could potentially add some code in here, for example, to install sample data The uninstall function is run when someone uninstalls your component, and currently it will just show some text. The update function is run whenever you update your component.
You can add your own custom code in here as required. The preflight function runs before the component is installed. You may want to add code in here to check prerequisites, such as the PHP version, or check to see if a library package you are using is installed or not.
The postflight function runs after your component has been installed. You may want to use this function to set default values for component parameters. Copy into the site folder an index. We haven't built a frontend to our component yet. If you try installing this component on Joomla! We haven't made this component Joomla!
So far our component is only for Joomla! You have now built your first Joomla! In Chapter 5, Backend Component Development — Part 1 and Chapter 6, Component Development — Part 2, we will continue the development of the backend of our component, then in Chapter 7, Frontend Component Development, we will create the frontend.
In this chapter, you have learned how to: Although we have only looked at the backend so far, a lot of what you've learned will be applied to the frontend later. You should now understand the difference between a component, a module, and a plugin. You will learn the following: We can make it a whole lot better by adding a few more fields to capture some more information.
For each portfolio item, we want to show an image, company name, phone number, website link, and description about that item. We will also show a couple of standard Joomla! We will only show published portfolio items on the frontend, but we also want to be able to unpublish items, archive old ones, and trash and potentially delete unwanted items. This field type also gives us the ability to upload new files; however, note that the upload does not generate thumbnail images, or perform any image manipulation such as resizing, so we will need to make sure our images are suitably prepared at the right size and resolution prior to upload.
We are making it required, so the form validation will force the user to enter something in this field. In a later chapter, when we create the frontend, we will integrate this field with our click to call it a plugin.
We are setting maxlength to ensure that the URL will not be truncated by the field we are using to store it in our database. It just lists all of the fields, each one with a label that shows the text next to the field, and an input that is the field itself. We simply pass the name of the field we defined in folio. Alternative method for displaying fields in the view Another method is to just loop through an entire fieldset, rather than listing the individual fields.
To do this, you would need to give your fieldset a name in folio. Doing so will show the fields in the exact order that they are defined in folio. The advantage of the first method is that we can change the order of the fields without having to modify folio. The advantage of looping through the fieldset is that the view file has less code. The method you should use depends on what you are trying to achieve. You need to decide whether or not you want to show all the fields in the exact order as defined in the model.
It is important to add any new fields to your installation SQL script, so that when you distribute your extension to other people, it will create all the fields required for the software to work. Now, when you open an existing record, it should display the value you entered in each field. If you have any problems, you can compare your code to Version 1. Adding columns to your view In our default list view that shows all our portfolio items in the backend, we currently only have a checkbox and the Title column, so we need to add a few more columns in here.
We will concentrate on the company and id columns initially, and then add status and ordering columns which are a bit more complex. As you can see, we are just adding the columns that we want to select from the database to query.
Within the construct function, we are listing each field which is placed between single quotation marks and separated by commas. We also repeat the same field with a.
Within the getListQuery function, because the fields we are selecting are within the getState function, we just put them all within the same single quotation marks, and commas separate each field.
You can split it into multiple lines using string concatenation as shown above, or you could write the same thing all on one line; however, this becomes impractical when you are selecting a lot of fields. So, since we are changing the list view, it's the plural folios view that we want to change. We are only adding company and id columns for now. We haven't implemented the column sorting yet, so grid. Each field is displayed in the appropriate column. Just like the headings, we are hiding the company and id fields when displayed on a mobile device.
We are escaping the output of the company field, and casting the id field as an integer. You can see this in Version 1. So, we need to implement this functionality. If you click on the Company column again, it will change the sorting from ascending to descending order. We already have a state field in our database that will store these status values: Undefined property: Note the subtle full stops and commas.
The Status column now shows a check mark for published and a cross for unpublished, but it does not yet allow us to click on the check mark to toggle between published and unpublished.
Are you sure you want to claim this product using a token? Tim Plummer July Quick links: What do I get with a Packt subscription? What do I get with an eBook? What do I get with a Video? Frequently bought together. Learn more Add to cart. Paperback pages. Book Description Joomla 3 is the first of the major open source content management systems that was meant to be mobile friendly by default.
Table of Contents Chapter 1: Before you Start. Upgrading a Joomla! Chapter 2: Getting Started with Plugin Development.
Chapter 3: Getting Started with Module Development. Chapter 4: Getting Started with Component Development. Chapter 5: Backend Component Development — Part 1. Chapter 6: Backend Component Development — Part 2.
Chapter 7: Frontend Component Development. Chapter 8: Security — Avoiding Common Vulnerabilities. Chapter 9: Packing Everything Together.
Chapter Extending your Component with Plugins and Modules. What You Will Learn Extend Joomla using plugins Develop both frontend and backend modules Build a Joomla component that looks and behaves like the core components, to reduce the learning curve for your users Discover common security vulnerabilities and what you can do to avoid them Prepare your extensions for distribution Manage updates and set up an update server Integrate third party extensions in your component.
Authors Tim Plummer. Read More. Read More Reviews. Recommended for You. Mastering Microsoft Power BI. Microsoft Power BI Cookbook. Complete Bootstrap: Responsive Web Development with Bootstrap 4. Then if focuses on API, plugins and modules and then it goes to backend and frontend component development. Next part is about common security vulnerabilities and what you can do to avoid them.
After that the author explains how to prepare your extensions for distribution and updates, as well as how you can extend your components with various plugins and modules. Each chapter introduces and describes more enhanced functionality with each chapter building and adding to your knowledge learned in the previous chapters.
I like the way it's explained how to do it That leads you to a fully working example that you can modify and learn from. Clear division has another easy advantage - when you have a problem with something, you just need to find the relevant chapter and read it.
So at the end you will stand with a package of functionable extensions ready to use! I am sure that this book is just perfect for anyone who want to explore the Joomla Development world. I do not have any other choice but to recommend it. It's a obligatory copy if you want to build your own custom extensions in Joomla.