Table of Contents for
Magento 2 - Build World-Class online stores

Version ebook / Retour

Cover image for bash Cookbook, 2nd Edition Magento 2 - Build World-Class online stores by Jonathan Bownds Published by Packt Publishing, 2017
  1. Cover
  2. Table of Contents
  3. Magento 2 - Build World-Class online stores
  4. Magento 2 - Build World-Class online stores
  5. Credits
  6. Preface
  7. 1. Module 1
  8. 1. Magento Fundamentals
  9. XAMPP installation
  10. Magento
  11. Summary
  12. 2. Magento 2.0 Features
  13. An introduction to the Magento order management system
  14. Magento 2.0 command-line configuration
  15. The command-line utility
  16. Summary
  17. 3. Working with Search Engine Optimization
  18. Store configuration
  19. SEO and searching
  20. SEO catalog configuration
  21. Google Analytics tracking code
  22. Optimizing Magento pages
  23. Summary
  24. 4. Magento 2.0 Theme Development – the Developers' Holy Grail
  25. Magento 2.0 theme structure
  26. The Magento Luma theme
  27. Magento theme inheritance
  28. CMS blocks and pages
  29. Custom variables
  30. Creating a basic Magento 2.0 theme
  31. Summary
  32. 5. Creating a Responsive Magento 2.0 Theme
  33. Composer – the PHP dependency manager
  34. Building the CompStore theme
  35. CSS preprocessing with LESS
  36. Applying new CSS to the CompStore theme
  37. Creating the CompStore logo
  38. Applying the theme
  39. Creating CompStore content
  40. Customizing Magento 2.0 templates
  41. Summary
  42. 6. Write Magento 2.0 Extensions – a Great Place to Go
  43. Using the Zend framework
  44. Magento 2.0 extension structure
  45. Developing your first Magento extension
  46. The Twitter REST API
  47. The TweetsAbout module structure
  48. Using TwitterOAuth to authenticate our extension
  49. Developing the module
  50. Summary
  51. 7. Go Mobile with Magento 2.0!
  52. Adjusting the CompStore theme for mobile devices
  53. The Magento 2.0 responsive design
  54. The Magento UI
  55. Implementing a new CSS mixin media query
  56. Adjusting tweets about extensions for mobile devices
  57. Summary
  58. 8. Speeding up Your Magento 2.0
  59. Indexing and caching Magento
  60. Indexing and re-indexing data
  61. The Magento cron job
  62. Caching
  63. Fine-tuning the Magento hosting server
  64. Selecting the right Magento hosting service
  65. Apache web server deflation
  66. Enabling the expires header
  67. Minifying scripts
  68. Summary
  69. 9. Improving Your Magento Skills
  70. Magento knowledge center
  71. Improving your Magento skills
  72. Summary
  73. 2. Module 2
  74. 1. Magento 2 System Tools
  75. Installing Magento 2 sample data via GUI
  76. Installing Magento 2 sample data via the command line
  77. Managing Magento 2 indexes via the command line
  78. Managing Magento 2 cache via the command line
  79. Managing Magento 2 backup via the command line
  80. Managing Magento 2 set mode (MAGE_MODE)
  81. Transferring your Magento 1 database to Magento 2
  82. 2. Enabling Performance in Magento 2
  83. Configuring Redis for backend cache
  84. Configuring Memcached for session caching
  85. Configuring Varnish as the Full Page Cache
  86. Configuring Magento 2 with CloudFlare
  87. Configuring optimized images in Magento 2
  88. Configuring Magento 2 with HTTP/2
  89. Configuring Magento 2 performance testing
  90. 3. Creating Catalogs and Categories
  91. Create a Root Catalog
  92. Create subcategories
  93. Manage attribute sets
  94. Create products
  95. Manage products in a catalog grid
  96. 4. Managing Your Store
  97. Creating shipping and tax rules
  98. Managing customer groups
  99. Configuring inventories
  100. Configuring currency rates
  101. Managing advanced pricing
  102. 5. Creating Magento 2 Extensions – the Basics
  103. Initializing extension basics
  104. Working with database models
  105. Creating tables using setup scripts
  106. Creating a web route and controller to display data
  107. Creating system configuration fields
  108. Creating a backend data grid
  109. Creating a backend form to add/edit data
  110. 6. Creating Magento 2 Extensions – Advanced
  111. Using dependency injection to pass classes to your own class
  112. Modifying functions with the use of plugins – Interception
  113. Creating your own XML module configuration file
  114. Creating your own product type
  115. Working with service layers/contracts
  116. Creating a Magento CLI command option
  117. 3. Module 3
  118. 1. Planning for Magento
  119. Technical considerations
  120. Global-Website-Store methodology
  121. Planning for multiple stores
  122. Summary
  123. 2. Managing Products
  124. Managing products the customer focused way
  125. Creating products
  126. Managing inventory
  127. Pricing tools
  128. Autosettings
  129. Related products, up-sells, and cross-sells
  130. Importing products
  131. Summary
  132. 3. Designs and Themes
  133. The concept of theme inheritance
  134. Default installation of design packages and themes
  135. Installing third-party themes
  136. Inline translations
  137. Working with theme variants
  138. Customizing themes
  139. Customizing layouts
  140. Summary
  141. 4. Configuring to Sell
  142. Payment methods
  143. Shipping methods
  144. Managing taxes
  145. Transactional e-mails
  146. Summary
  147. 5. Managing Non-Product Content
  148. Summary
  149. 6. Marketing Tools
  150. Promotions
  151. Newsletters
  152. Using sitemaps
  153. Optimizing for search engines
  154. Summary
  155. 7. Extending Magento
  156. The new Magento module architecture
  157. Extending Magento functionality with Magento plugins
  158. Building your own extensions
  159. Summary
  160. 8. Optimizing Magento
  161. Indexing and caching
  162. Caching in Magento 2 – not just FPC
  163. Tuning your server for speed
  164. Summary
  165. 9. Advanced Techniques
  166. Version control
  167. Magento cron
  168. Backing up your database
  169. Upgrading Magento
  170. Summary
  171. 10. Pre-Launch Checklist
  172. System configurations
  173. Design configurations
  174. Search engine optimization
  175. Sales configurations
  176. Product configurations
  177. Maintenance configurations
  178. Summary
  179. Index

Creating tables using setup scripts

When using database models, as explained in the previous recipe, the corresponding tables needs to be created during setup. These operations are placed in setup scripts and executed during the installation of an extension.

Getting ready

While running the installation of a module, there are four files executed to create schemas and insert data. To create schemas, the files used are as follows:

Setup/InstallSchema.php

Setup/UpgradeSchema.php

The installation file is executed only when there is no record in the setup_module table for the module. The upgrade file is executed only when the current version number in the setup_module table is lower than the version configured in your etc/module.xml file.

When it's necessary to insert default values into a table or new EAV attributes need to be created, these actions need to be configured in the following files:

Setup/InstallData.php

Setup/UpgradeData.php

Magento keeps track of which version is installed for an extension in the setup_module table; here, the current installed version for the schema and data is stored:

Getting ready

How to do it…

Follow these steps to create your database tables:

  1. The following is the table schema installation:

    Setup/InstallSchema.php

    <?php
    namespace Genmato\Sample\Setup;
    
    use Magento\Framework\Setup\InstallSchemaInterface;
    use Magento\Framework\Setup\ModuleContextInterface;
    use Magento\Framework\Setup\SchemaSetupInterface;
    use Magento\Framework\DB\Adapter\AdapterInterface;
    
    class InstallSchema implements InstallSchemaInterface
    {
      public function install(SchemaSetupInterface $setup, ModuleContextInterface $context)
      {
        $installer = $setup;
    
        $installer->startSetup();
    
        /**
        * Create table 'genmato_demo'
        */
        $table = $installer->getConnection()->newTable(
          $installer->getTable('genmato_demo')
        )->addColumn(
          'demo_id',
          \Magento\Framework\DB\Ddl\Table::TYPE_SMALLINT,
          null,
          ['identity' => true, 'nullable' => false, 'primary' => true],
          'Demo ID'
        )->addColumn(
          'title',
          \Magento\Framework\DB\Ddl\Table::TYPE_TEXT,
          255,
          ['nullable' => false],
          'Demo Title'
        )->addColumn(
          'creation_time',
          \Magento\Framework\DB\Ddl\Table::TYPE_TIMESTAMP,
          null,
          [],
          'Creation Time'
        )->addColumn(
          'update_time',
          \Magento\Framework\DB\Ddl\Table::TYPE_TIMESTAMP,
          null,
          [],
          'Modification Time'
        )->addColumn(
          'is_active',
          \Magento\Framework\DB\Ddl\Table::TYPE_SMALLINT,
          null,
          ['nullable' => false, 'default' => '1'],
          'Is Active'
        )->addIndex(
          $setup->getIdxName(
            $installer->getTable('genmato_demo'),
            ['title'],
            AdapterInterface::INDEX_TYPE_FULLTEXT
          ),
          ['title'],
          ['type' => AdapterInterface::INDEX_TYPE_FULLTEXT]
        )->setComment(
          'Demo Table'
        );
        $installer->getConnection()->createTable($table);
    
        $installer->endSetup();
      }
    }
  2. Trigger the execution of the setup scripts:
    bin/magento setup:upgrade
    

How it works…

In Magento 2, the running of the setup scripts is no longer triggered by the first request after flushing the cache; to initiate the running of these scripts, run the command specified in step 2. When running the upgrade command, all modules are evaluated on their current version and module version in the configuration file. First, all schema installations/updates are executed, and next, the data installations/updates are processed.

The InstallData and InstallSchema files are executed only when there is no prior registration of the extension in the setup_module table. To run the installation files during testing, it is possible to remove the module row from the table and run the bin/magento setup:upgrade command.

The available methods to create a new table are defined in the Magento\Framework\DB\Adapter\AdapterInterface\Table class and are as follows:

  • addColumn: This adds a new column to the table; this method has the following parameters:
    • name: This is the name of the table
    • type: This is the table type; the available column types are defined as constants in the Magento\Framework\DB\Adapter\AdapterInterface\Table class as TYPE_*:

      TYPE_BOOLEAN

      TYPE_SMALLINT

      TYPE_INTEGER

      TYPE_BIGINT

      TYPE_FLOAT

      TYPE_NUMERIC

      TYPE_DECIMAL

      TYPE_DATE

      TYPE_TIMESTAMP

      TYPE_DATETIME

      TYPE_TEXT

      TYPE_BLOB

      TYPE_VARBINARY

    • size: This specifies the size of the column
    • options: This is used to specify extra column options; the available options are as follows:

      unsigned: This is only for number types; allows True/False (default: False)

      precision: This is only for decimal and numeric types (default: calculated from size parameter or 0 if not set)

      scale: This is only for decimal and numeric types (default: calculated from size parameter or 10 if not set)

      default: The default value is used when creating a new record

      nullable: In case a column is NULL (default: True)

      primary: This makes a column a primary key

      primary_position: This is only for primary keys and sets the sort order for the primary keys

      identity/auto_increment: This auto-increments a column on inserting a new record (used to identify a unique record ID)

    • comment: This is the description of the column
  • addForeignKey: This adds a foreign key relation to another table; the parameters allowed are as follows:
    • fkName: This is the name of the foreign key
    • column: This is the column used as the foreign key
    • refTable: This is the table where the key references to
    • refColumn: This is the column name in the referenced table
    • onDelete: This sets the action to be performed when deleting a record; the available options are (constants as defined in Magento\Framework\DB\Adapter\AdapterInterface\Table):

      ACTION_CASCADE

      ACTION_RESTRICT

      ACTION_SET_DEFAULT

      ACTION_SET_NULL

      ACTION_NO_ACTION

  • addIndex: This adds a column to the search index; the available parameters are as follows:
    • indexName: This is the name used for the index
    • fields: These are the column(s) used for the index (can be a single column or an array of columns)
    • options: This is an array with extra options; currently, only the option type is used to specify the index type

When changing an existing table, it is possible to use the following methods; these are the methods that can be used directly on the $installer->getConnection() class:

  • dropTable: This removes a table from the database; the available parameters are as follows:
    • tableName: This is the name of the table to delete
    • schemaName: This is the optional schema name used
  • renameTable: This renames a table from the database; the available parameters are as follows:
    • oldTableName: This is the current name of the table
    • newTableName: This is the new name for the table
    • schemaName: This is the optional schema name
  • addColumn: This adds an extra column to a table; the available parameters are as follows:
    • tableName: This is the name of the table to alter
    • columnName: This is the name of the new column
    • definition: This is an array with the following parameters:

      Type: Column type

      Length: Column size

      Default: Default value

      Nullable: If a column can be NULL

      Identify/Auto_Increment: Used as an identity column

      Comment: Column description

      After: Specify where to add the column

    • schemaName: This is the optional schema name
  • changeColumn: This changes the column name and definition; the available parameters are as follows:
    • tableName: This is the name of the table to change
    • oldColumnName: This is the current column name
    • newColumnName: This is the new name for the column
    • definition: This is the table definition; see addColumn for available values
    • flushData: This flushes the table cache
    • schemaName: This is the optional schema name
  • modifyColumn: This changes the column definition; the available parameters are as follows:
    • tableName: This is the name of the table
    • columnName: This is the column name to change
    • definition: This is the table definition; see addColumn for available values
    • flushData: This flushes the table cache
    • schemaName: This is the optional schema name
  • dropColumn: This removes a column from the table; the available parameters are as follows:
    • tableName: This is the name of the column
    • columnName: This is the name of the column to remove
    • schemaName: This is the optional schema name
  • addIndex: This adds a new index; the available parameters are as follows:
    • tableName: This is the name of the table to change
    • indexName: This is the name of the index to add
    • fields: These are the columns to be used as the index
    • indexType: This is the type of index; the available options (constants defined in (Magento\Framework\DB\Ddl\Table\AdapterInterface) are as follows:

      INDEX_TYPE_PRIMARY

      INDEX_TYPE_UNIQUE

      INDEX_TYPE_INDEX

      INDEX_TYPE_FULLTEXT

    • schemaName: This is the optional schema name
  • dropIndex: This removes an index from a table; the available parameters are as follows:
    • tableName: This is the name of the column
    • indexName: This is the name of the index
    • schemaName: This is the optional schema name
  • addForeignKey: This adds a new foreign key; the available parameters are as follows:
    • fkName: This is the name of the foreign key
    • tableName: This is the name of the table
    • columnName: This is the name of the column used in the foreign key
    • refTableName: This is the name of the referenced table
    • refColumnName: This is the name of the referenced column
    • onDelete: This is the action to perform on delete (see the preceding addForeignKey description for available options)
    • purge: This removes invalid data (default: false)
    • schemaName: This is the optional schema name
    • refSchemaName: This is the option-referenced schema name

There's more…

When, in a later version of the extension, there are extra fields necessary (or the current fields need to be changed), this is handled through the UpgradeSchema function, upgrade:

Setup/UpgradeSchema.php

<?php
namespace Genmato\Sample\Setup;

use Magento\Framework\DB\Ddl\Table;
use Magento\Framework\Setup\UpgradeSchemaInterface;
use Magento\Framework\Setup\ModuleContextInterface;
use Magento\Framework\Setup\SchemaSetupInterface;

class UpgradeSchema implements UpgradeSchemaInterface
{
  public function upgrade(SchemaSetupInterface $setup, ModuleContextInterface $context)
  {
    $setup->startSetup();

    if (version_compare($context->getVersion(), '0.1.1', '<')) {
      $connection = $setup->getConnection();

      $column = [
        'type' => Table::TYPE_SMALLINT,
        'length' => 6,
        'nullable' => false,
        'comment' => 'Is Visible',
        'default' => '1'
      ];
      $connection->addColumn($setup->getTable('genmato_demo'), 'is_visible', $column);
    }

    $setup->endSetup();
  }
}

As this file is run every time the module version is different than the currently installed version, it is necessary to check the current version that is installed to execute only the updates necessary:

if (version_compare($context->getVersion(), '0.1.1', '<')) {

The preceding statement will make sure that the schema changes are executed only if the current version is less than 0.1.1.

Data installation

In order to provide default content during installation (this can be records in a table or adding extra attributes to some entity), the data installation function is used:

Setup/InstallData.php

<?php
namespace Genmato\Sample\Setup;

use Genmato\Sample\Model\Demo;
use Genmato\Sample\Model\DemoFactory;
use Magento\Framework\Setup\InstallDataInterface;
use Magento\Framework\Setup\ModuleContextInterface;
use Magento\Framework\Setup\ModuleDataSetupInterface;

class InstallData implements InstallDataInterface
{
  /**
  * Demo factory
  *
  * @var DemoFactory
  */
  private $demoFactory;

  /**
  * Init
  *
  * @param DemoFactory $demoFactory
  */
  public function __construct(DemoFactory $demoFactory)
  {
    $this->demoFactory = $demoFactory;
  }

  /**
  * {@inheritdoc}
  * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
  */
  public function install(ModuleDataSetupInterface $setup, ModuleContextInterface $context)
  {
    $demoData = [
      'title' => 'Demo Title',
      'is_active' => 1,
    ];

    /**
    * Insert demo data
    */
    $this->createDemo()->setData($demoData)->save();

  }

  /**
  * Create demo
  *
  * @return Demo
  */
  public function createDemo()
  {
    return $this->demoFactory->create();
  }
}

In this example, there is one record created in the table created during setup. For this, the DemoFactory class is injected through dependency injection into the constructor function of this class. DemoFactory is an automatically created class that allows you to instantiate a class (in this case, Genmato\Sample\Model\Demo) without injecting this directly into the constructor. Here, this is done in the createDemo function:

$this->demoFactory->create();

Similar to SchemaUpgrade, there is also a DataUpgrade option to insert data while upgrading to a newer version.