← Back to Frameworks

Magento Commerce

EcommerceEnterpriseAdobeB2BMulti-storeCustomizationPHP

E-commerce Platform

Magento Commerce

Overview

Magento Commerce is an enterprise-grade e-commerce platform under Adobe's umbrella. It supports B2B, B2C, and multi-site operations, providing advanced customization and scalability. Primarily adopted by large enterprises, it maintains its position in the enterprise market through its ability to handle complex requirements and integration with Adobe Experience Cloud.

Details

Magento was first released in 2008 and was acquired by Adobe in 2018. Currently operating as Adobe Commerce (formerly Magento Commerce), it provides enterprise-level e-commerce solutions. Both open-source (Magento Open Source) and commercial (Adobe Commerce) versions exist, chosen for large-scale and complex e-commerce projects.

Key Features

  • Enterprise-Grade: Handles large-scale traffic and complex requirements
  • B2B & B2C Support: Supports both business-to-business and consumer transactions
  • Multi-Store Management: Unified management of multiple brands, regions, and languages
  • Advanced Customization: Flexible extension at the architectural level
  • Adobe Integration: Seamless integration with Adobe Experience Cloud
  • Modular Design: Component-based functionality addition and modification
  • API-First: RESTful and GraphQL APIs for external system integration
  • Internationalization: Comprehensive support for multi-currency, multi-language, and tax calculations

Supported Payment Methods

  • Adobe Payment Services
  • PayPal, Stripe, Braintree
  • Major credit card payments
  • Bank transfers and digital wallets
  • B2B invoice payments and purchase approval workflows
  • Installment and pay-later payments

Pros and Cons

Pros

  • Enterprise Features: Handles large business requirements
  • High Customizability: Flexible response to unique requirements
  • B2B Specialized Features: Rich features specialized for business-to-business transactions
  • Multi-Site: Unified operation of multiple brands and regions
  • Adobe Ecosystem: Integration with marketing and analytics tools
  • Powerful APIs: Headless commerce and system integration
  • Performance: Enterprise-grade scalability

Cons

  • High Cost: High expenses for licensing, implementation, and operation
  • Complexity: Technical complexity in setup and management
  • Resource Requirements: High-spec servers and development teams required
  • Learning Curve: Specialized knowledge acquisition required for administrators and developers
  • Updates: Complexity and impact scope of version upgrades
  • Vendor Lock-in: Dependency on Adobe ecosystem

Reference Links

Implementation Examples

1. Basic Module Development

<?php
// app/code/Vendor/Module/registration.php
use Magento\Framework\Component\ComponentRegistrar;

ComponentRegistrar::register(
    ComponentRegistrar::MODULE,
    'Vendor_Module',
    __DIR__
);

// app/code/Vendor/Module/etc/module.xml
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
    <module name="Vendor_Module" setup_version="1.0.0">
        <sequence>
            <module name="Magento_Catalog"/>
            <module name="Magento_Customer"/>
        </sequence>
    </module>
</config>

// Model/CustomModel.php
<?php
namespace Vendor\Module\Model;

use Magento\Framework\Model\AbstractModel;

class CustomModel extends AbstractModel
{
    protected function _construct()
    {
        $this->_init(\Vendor\Module\Model\ResourceModel\CustomModel::class);
    }
}

2. Product Catalog Management

<?php
// Programmatic product creation
use Magento\Catalog\Api\ProductRepositoryInterface;
use Magento\Catalog\Model\ProductFactory;
use Magento\Framework\App\State;

class ProductCreator
{
    private $productFactory;
    private $productRepository;
    
    public function __construct(
        ProductFactory $productFactory,
        ProductRepositoryInterface $productRepository
    ) {
        $this->productFactory = $productFactory;
        $this->productRepository = $productRepository;
    }
    
    public function createProduct($data)
    {
        $product = $this->productFactory->create();
        
        $product->setName($data['name']);
        $product->setSku($data['sku']);
        $product->setPrice($data['price']);
        $product->setAttributeSetId(4); // Default attribute set
        $product->setStatus(\Magento\Catalog\Model\Product\Attribute\Source\Status::STATUS_ENABLED);
        $product->setVisibility(\Magento\Catalog\Model\Product\Visibility::VISIBILITY_BOTH);
        $product->setTypeId(\Magento\Catalog\Model\Product\Type::TYPE_SIMPLE);
        
        // Custom attribute settings
        $product->setCustomAttribute('description', $data['description']);
        $product->setCustomAttribute('short_description', $data['short_description']);
        
        // Stock settings
        $product->setStockData([
            'use_config_manage_stock' => 0,
            'manage_stock' => 1,
            'is_in_stock' => 1,
            'qty' => $data['qty']
        ]);
        
        return $this->productRepository->save($product);
    }
}

3. Payment Integration

<?php
// Custom payment method
namespace Vendor\Payment\Model;

use Magento\Payment\Model\Method\AbstractMethod;

class CustomPayment extends AbstractMethod
{
    protected $_code = 'custom_payment';
    protected $_isOffline = false;
    protected $_canCapture = true;
    protected $_canRefund = true;
    
    public function capture(\Magento\Payment\Model\InfoInterface $payment, $amount)
    {
        $order = $payment->getOrder();
        
        // Payment API call
        $response = $this->processPayment([
            'amount' => $amount,
            'currency' => $order->getBaseCurrencyCode(),
            'order_id' => $order->getIncrementId(),
            'customer_email' => $order->getCustomerEmail()
        ]);
        
        if ($response['success']) {
            $payment->setTransactionId($response['transaction_id']);
            $payment->setIsTransactionClosed(false);
        } else {
            throw new \Magento\Framework\Exception\PaymentException(
                __('Payment failed: %1', $response['error_message'])
            );
        }
        
        return $this;
    }
    
    private function processPayment($data)
    {
        // Actual payment API integration logic
        return [
            'success' => true,
            'transaction_id' => 'txn_' . uniqid()
        ];
    }
}

4. Order Management System

<?php
// Order Management System
use Magento\Sales\Api\OrderRepositoryInterface;
use Magento\Sales\Model\OrderFactory;

class OrderManager
{
    private $orderRepository;
    private $orderFactory;
    
    public function __construct(
        OrderRepositoryInterface $orderRepository,
        OrderFactory $orderFactory
    ) {
        $this->orderRepository = $orderRepository;
        $this->orderFactory = $orderFactory;
    }
    
    public function createOrderFromQuote($quoteId, $paymentData)
    {
        $quote = $this->quoteRepository->get($quoteId);
        
        // Shipping information setup
        $shippingAddress = $quote->getShippingAddress();
        $shippingAddress->setCollectShippingRates(true);
        $shippingAddress->collectShippingRates();
        
        // Payment information setup
        $quote->getPayment()->importData($paymentData);
        
        // Order creation
        $order = $this->quoteManagement->submit($quote);
        
        if ($order) {
            // Post-order processing
            $this->sendOrderConfirmationEmail($order);
            $this->updateInventory($order);
        }
        
        return $order;
    }
    
    public function processOrderShipment($orderId, $trackingInfo)
    {
        $order = $this->orderRepository->get($orderId);
        
        // Shipment processing
        $shipment = $this->shipmentFactory->create($order);
        $shipment->addTrack($trackingInfo);
        $shipment->register();
        
        $this->shipmentRepository->save($shipment);
        
        return $shipment;
    }
}

5. B2B Feature Implementation

<?php
// B2B Company Account Management
namespace Vendor\B2B\Model;

use Magento\Company\Api\CompanyRepositoryInterface;
use Magento\Company\Model\CompanyFactory;

class CompanyManager
{
    private $companyRepository;
    private $companyFactory;
    
    public function createCompany($companyData)
    {
        $company = $this->companyFactory->create();
        
        $company->setCompanyName($companyData['name']);
        $company->setCompanyEmail($companyData['email']);
        $company->setStatus(\Magento\Company\Api\Data\CompanyInterface::STATUS_APPROVED);
        
        // Company address setup
        $company->setStreet($companyData['street']);
        $company->setCity($companyData['city']);
        $company->setCountryId($companyData['country_id']);
        $company->setPostcode($companyData['postcode']);
        
        return $this->companyRepository->save($company);
    }
    
    public function setupPurchaseOrderWorkflow($companyId, $rules)
    {
        // Purchase approval workflow setup
        foreach ($rules as $rule) {
            $purchaseOrderRule = $this->purchaseOrderRuleFactory->create();
            $purchaseOrderRule->setCompanyId($companyId);
            $purchaseOrderRule->setConditions($rule['conditions']);
            $purchaseOrderRule->setApprovers($rule['approvers']);
            
            $this->purchaseOrderRuleRepository->save($purchaseOrderRule);
        }
    }
}

// B2B pricing
class B2BPricingManager
{
    public function setCustomerGroupPricing($productId, $groupPricing)
    {
        $product = $this->productRepository->getById($productId);
        
        foreach ($groupPricing as $groupId => $price) {
            $tierPrice = [
                'website_id' => 0,
                'cust_group' => $groupId,
                'price_qty' => 1,
                'price' => $price
            ];
            
            $tierPrices = $product->getTierPrice();
            $tierPrices[] = $tierPrice;
            $product->setTierPrice($tierPrices);
        }
        
        $this->productRepository->save($product);
    }
}

6. Performance Optimization & Analytics

<?php
// Cache Management
class CacheManager
{
    private $cacheManager;
    private $redis;
    
    public function warmupProductCache($productIds)
    {
        foreach ($productIds as $productId) {
            $product = $this->productRepository->getById($productId);
            
            // Cache key generation
            $cacheKey = 'product_' . $productId;
            
            // Cache in Redis
            $this->redis->setex($cacheKey, 3600, serialize([
                'name' => $product->getName(),
                'price' => $product->getPrice(),
                'stock' => $product->getStockItem()->getQty()
            ]));
        }
    }
    
    public function clearCustomCache($tags)
    {
        $this->cacheManager->clean($tags);
    }
}

// Performance Monitoring
class PerformanceMonitor
{
    public function trackPageLoad($pageType, $loadTime)
    {
        // Adobe Analytics integration
        $analyticsData = [
            'pageType' => $pageType,
            'loadTime' => $loadTime,
            'timestamp' => time(),
            'userId' => $this->customerSession->getCustomerId()
        ];
        
        $this->analyticsClient->track('page_load', $analyticsData);
    }
    
    public function generatePerformanceReport()
    {
        // Performance metrics collection
        $metrics = [
            'average_page_load' => $this->getAveragePageLoad(),
            'cache_hit_ratio' => $this->getCacheHitRatio(),
            'database_query_time' => $this->getAverageDbQueryTime(),
            'concurrent_users' => $this->getConcurrentUsers()
        ];
        
        return $metrics;
    }
}