Jak zacząć tworzyć moduły do PrestaShop?

Spis treści pokaż

Czym są moduły w PrestaShop i dlaczego warto je tworzyć?

Moduły w PrestaShop to rozszerzenia, które umożliwiają dostosowanie sklepu do indywidualnych potrzeb. Dzięki nim możesz dodawać nowe funkcje, integrować zewnętrzne systemy, modyfikować wygląd strony czy usprawniać działanie sklepu bez ingerencji w kod źródłowy platformy. Moduły działają niezależnie, co sprawia, że są łatwe w zarządzaniu i aktualizacji.

Dlaczego warto tworzyć moduły? Przede wszystkim dlatego, że pozwalają one wprowadzać spersonalizowane rozwiązania, które wyróżnią Twój sklep na tle konkurencji. Dla właścicieli sklepów to szansa na unikalne funkcje, a dla programistów – okazja do rozwijania swoich umiejętności i tworzenia wartościowych rozwiązań, które mogą być sprzedawane jako produkty na platformach takich jak PrestaShop Addons.

tpay szybkie płatności

Aby rozpocząć pracę nad modułami, wystarczy podstawowa znajomość PHP, HTML, CSS, JavaScript oraz MySQL. CSS i JavaScript pozwalają na tworzenie atrakcyjnych i interaktywnych elementów, które można zintegrować z funkcjami modułu. MySQL z kolei umożliwia zarządzanie danymi w bazie, co jest szczególnie przydatne w przypadku bardziej zaawansowanych modułów, takich jak integracje z zewnętrznymi systemami czy dynamiczne raporty.

Nie musisz być ekspertem w tych technologiach – wystarczy znajomość podstaw, które będą rozwijane wraz z postępem prac nad modułem. W tym poradniku znajdziesz wszystkie niezbędne kroki, które pomogą Ci stworzyć swój pierwszy moduł i w pełni wykorzystać możliwości PrestaShop.

Podstawowa struktura modułu

Każdy moduł w PrestaShop opiera się na precyzyjnie zdefiniowanej strukturze plików i folderów, która umożliwia jego prawidłowe działanie w systemie. Zrozumienie tej struktury to kluczowy krok w procesie tworzenia własnych modułów.

Tworzenie katalogu modułu

Pierwszym krokiem jest utworzenie katalogu dla modułu w folderze /modules/ Twojej instalacji PrestaShop. Nazwa katalogu powinna być unikalna i oparta na konwencji, np. mymodule. Ważne jest, aby używać wyłącznie małych liter i unikać spacji.

Plik główny modułu

Kluczowym plikiem każdego modułu jest plik PHP, którego nazwa musi odpowiadać nazwie katalogu modułu, np. mymodule.php. Plik ten zawiera klasę modułu, która dziedziczy po klasie Module dostarczonej przez PrestaShop. W tej klasie definiowane są wszystkie podstawowe informacje o module, takie jak nazwa, opis czy wersja.

Przykład podstawowego pliku głównego mymodule.php:

class MyModule extends Module
{
	public function __construct()
	{
		$this->name = 'mymodule';
		$this->tab = 'front_office_features';
		$this->version = '1.0.0';
		$this->author = 'Twoje Imię';
		$this->need_instance = 0;

		parent::__construct();

		$this->displayName = $this->l('Mój moduł');
		$this->description = $this->l('Opis modułu.');
	}

	public function install()
	{
		return parent::install();
	}

	public function uninstall()
	{
		return parent::uninstall();
	}
}

Kluczowe elementy pliku config.xml

Dodatkowo moduł powinien zawierać plik config.xml, który przechowuje metadane takie jak kompatybilność z wersjami PrestaShop czy wymagania modułu. Plik ten należy umieścić w katalogu głównym modułu.

Przykład zawartości config.xml:

<module>
	<name>mymodule</name>
	<displayName>Mój moduł</displayName>
	<version>1.0.0</version>
	<description>Opis modułu.</description>
	<author>Twoje Imię</author>
	<compatibility>
		<min>1.7.0.0</min>
		<max>1.7.8.0</max>
	</compatibility>
</module>

Struktura katalogów

Przykładowa struktura katalogu modułu:

mymodule/
├── mymodule.php
├── config.xml
├── views/
│   ├── templates/
│   │   ├── front/
│   │   └── admin/
│   ├── css/
│   │   └── mymodule.css
│   ├── js/
│   │   └── mymodule.js
│   └── img/
│	   └── myimage.png
└── controllers/
	├── front/
	└── admin/

Wszystkie grafiki, które chcesz wykorzystać w module (np. ikony, banery, obrazy do frontendu), powinny być przechowywane w katalogu views/img/. Dzięki temu będą one łatwe do zarządzania i można je łatwo załadować za pomocą odpowiednich ścieżek w module.

Na przykład, aby załadować obraz w pliku szablonu, możesz użyć ścieżki:

<img src="{$module_dir}views/img/myimage.png" alt="Mój obraz" />

Generowanie podstawy modułu

Proces tworzenia modułu w PrestaShop można znacząco uprościć, korzystając z generatorów modułów lub tworząc strukturę ręcznie. Dzięki temu możesz szybko rozpocząć pracę nad swoim projektem i skupić się na dodawaniu unikalnych funkcji.

Korzystanie z generatora modułów

PrestaShop udostępnia narzędzie online – PrestaShop Module Generator, które umożliwia automatyczne wygenerowanie podstawowego szkieletu modułu. Wystarczy wypełnić kilka pól, takich jak nazwa modułu, wersja czy autor, a generator utworzy kompletną strukturę plików i folderów, gotową do dalszej pracy.

Aby skorzystać z generatora:

  1. Otwórz stronę PrestaShop Module Generator.
  2. Wprowadź wymagane dane, takie jak nazwa modułu, opis i wersja.
  3. Pobierz wygenerowany plik ZIP i rozpakuj go w folderze /modules/ Twojej instalacji PrestaShop.

Narzędzie to idealnie nadaje się dla początkujących, ponieważ eliminuje konieczność ręcznego tworzenia struktury modułu, a jednocześnie pozwala szybko rozpocząć pracę.

Ręczne tworzenie struktury modułu

Jeśli wolisz pełną kontrolę nad procesem, możesz stworzyć moduł ręcznie. W tym celu:

Utwórz nowy katalog w folderze /modules/ swojej instalacji PrestaShop. Nazwij go np. mymodule.

W katalogu utwórz plik PHP o nazwie mymodule.php. Ten plik będzie zawierał klasę modułu, która dziedziczy po klasie Module.

Dodaj plik config.xml z metadanymi modułu.

Utwórz foldery, takie jak views/, controllers/, czy translations/, zgodnie z potrzebami modułu.

Rejestrowanie hooków i dodawanie funkcji

Hooki w PrestaShop to kluczowy element umożliwiający integrację modułów z platformą. Służą one do:

  • Wywoływania przy konkretnej akcji: Na przykład po złożeniu zamówienia, aktualizacji statusu lub dodaniu nowego użytkownika.
  • Wyświetlania treści w określonym miejscu: Na przykład w nagłówku strony, stopce lub na stronie produktu.

Rejestracja hooka

Aby hook działał w module, musi być zarejestrowany podczas instalacji modułu. Rejestracja odbywa się w metodzie install() Twojej klasy modułu. Przykład rejestracji hooka:

public function install()
{
	return parent::install() && $this->registerHook('displayHeader') &&   $this->registerHook('actionOrderStatusUpdate');
}

W powyższym przykładzie moduł rejestruje dwa hooki: displayHeader (do wyświetlania treści w nagłówku strony) oraz actionOrderStatusUpdate (do wykonania akcji przy zmianie statusu zamówienia).

Dodawanie logiki do hooków

Po zarejestrowaniu hooka należy utworzyć metodę, która zostanie wywołana, gdy hook zostanie aktywowany. Nazwa metody musi odpowiadać nazwie hooka, np. hookDisplayHeader() dla hooka displayHeader. Przykład:

public function hookDisplayHeader()
{
	$this->context->controller->addCSS($this->_path . 'views/css/mymodule.css');
	$this->context->controller->addJS($this->_path . 'views/js/mymodule.js');
}

Metoda hookDisplayHeader() dodaje pliki CSS i JS modułu do nagłówka strony, co umożliwia ich użycie w frontendzie.

Debugowanie hooków

Jeśli nie masz pewności, gdzie dodać hooka lub jakie hooki są dostępne w danym szablonie, włącz tryb debugowania w PrestaShop. W pliku /config/defines.inc.php zmień wartość _PS_MODE_DEV_ na true. W trybie debug zobaczysz dostępne hooki oraz ich lokalizacje w szablonie.

Podsumowanie

Hooki są podstawą działania modułów w PrestaShop. Pamiętaj, aby zawsze rejestrować hooki podczas instalacji modułu. Pozwoli to Twojemu modułowi na wywoływanie akcji w odpowiednich momentach lub na wstawianie treści w określonych miejscach sklepu.

Tworzenie i obsługa kontrolerów

Kontrolery w PrestaShop odgrywają kluczową rolę w obsłudze logiki komunikacji modułów. Odpowiadają za przetwarzanie żądań użytkownika, przekazywanie danych do widoków oraz interakcję z bazą danych. W zależności od potrzeb kontrolery mogą być tworzone zarówno dla frontendu, jak i backendu sklepu.

Rodzaje kontrolerów

W PrestaShop można tworzyć dwa główne typy kontrolerów w ramach modułów:

Kontrolery frontowe:
Znajdują się w katalogu controllers/front/ i obsługują żądania użytkowników odwiedzających sklep. Przykładowo mogą służyć do wyświetlania dedykowanych stron lub obsługi dynamicznych działań na froncie.

Kontrolery administracyjne:
Znajdują się w katalogu controllers/admin/ i są odpowiedzialne za zarządzanie funkcjami modułu w panelu administracyjnym PrestaShop. Muszą być zarejestrowane w menu administracyjnym, aby mogły być poprawnie używane.

Tworzenie kontrolera administracyjnego

Kontrolery administracyjne obsługują działania modułu w panelu administracyjnym PrestaShop. Aby utworzyć kontroler administracyjny:

Utwórz katalog controllers/admin/ w folderze modułu, jeśli jeszcze go nie ma.

W katalogu controllers/admin/ stwórz plik PHP. Nazwa pliku musi być zgodna z konwencją PrestaShop, np. AdminMyModuleController.php.

Klasa w pliku kontrolera musi dziedziczyć po klasie ModuleAdminController, która zapewnia integrację z funkcjonalnościami panelu administracyjnego.

Przykład pliku AdminMyModuleController.php:

class AdminMyModuleController extends ModuleAdminController
{
	public function __construct()
	{
		parent::__construct();

		// Włączenie szablonów opartych na Bootstrapie
		$this->bootstrap = true;

		// Tytuł strony w panelu administracyjnym
		$this->meta_title = $this->l('Mój moduł - Zarządzanie');
	}

	public function renderList()
	{
		// Przykład wyświetlenia tabeli w panelu administracyjnym
		$this->fields_list = [
			'id_example' => [
				'title' => $this->l('ID'),
				'align' => 'center',
				'type' => 'int',
			],
			'example_field' => [
				'title' => $this->l('Przykładowe pole'),
				'type' => 'text',
			],
		];

		$this->list_no_link = true;

		return parent::renderList();
	}
}

Rejestracja kontrolera administracyjnego

Aby kontroler administracyjny był dostępny w panelu administracyjnym PrestaShop, należy go zarejestrować jako kartę menu (ang. tab) w metodzie install() modułu. W tym celu używamy klasy Tab.

Przykład rejestracji kontrolera w menu administracyjnym:

public function install()
{
	if (!parent::install() || !$this->registerAdminTab()) {
		return false;
	}
	return true;
}

private function registerAdminTab()
{
	$tab = new Tab();
	$tab->active = 1;
	$tab->class_name = 'AdminMyModule'; // Nazwa klasy kontrolera
	$tab->name = [];
			
	foreach (Language::getLanguages(true) as $lang) {
		$tab->name[$lang['id_lang']] = 'Mój moduł';
	}

	$tab->id_parent = (int)Tab::getIdFromClassName('AdminParentModulesSf'); // Domyślna kategoria "Moduły"
	$tab->module = $this->name; // Nazwa modułu
	$tab->icon = 'settings'; // Opcjonalna ikona

	return $tab->add();
}

Rejestracja karty zapewnia, że kontroler będzie dostępny w menu „Moduły” w panelu administracyjnym.

Usuwanie karty przy odinstalowaniu modułu administracyjnego

Podczas odinstalowywania modułu należy usunąć kartę menu związaną z kontrolerem, aby uniknąć niepotrzebnych konfliktów.

public function uninstall()
{
	if (!parent::uninstall() || !$this->unregisterAdminTab()) {
		return false;
	}
	return true;
}

private function unregisterAdminTab()
{
	$id_tab = (int)Tab::getIdFromClassName('AdminMyModule');
	if ($id_tab) {
		$tab = new Tab($id_tab);
		return $tab->delete();
	}
	return false;
}

Generowanie linków do kontrolerów administracyjnych

Po zarejestrowaniu kontrolera możesz generować do niego linki w panelu administracyjnym PrestaShop:

$adminLink = $this->context->link->getAdminLink('AdminMyModule');
echo '<a href="' . $adminLink . '">Zarządzaj modułem</a>';

Podsumowanie

Kontrolery administracyjne w PrestaShop umożliwiają tworzenie rozbudowanych funkcjonalności dostępnych dla administratorów sklepu. Prawidłowa rejestracja kontrolera za pomocą klasy Tab jest kluczowa dla jego działania. Upewnij się również, że klasy kontrolerów i pliki są poprawnie nazwane oraz umieszczone w odpowiednich lokalizacjach.

Tworzenie niezależnych plików PHP w module

Niezależne pliki PHP w module PrestaShop mogą być wykorzystywane do wielu różnych celów, takich jak automatyzacja procesów (cron), obsługa żądań API, czy też dynamiczne przetwarzanie danych. Ich elastyczność sprawia, że są ważnym elementem zaawansowanego modułu.

Podstawowe zastosowania

Oto najczęstsze zastosowania niezależnych plików PHP w module:

  • Zadania cron:
    Automatyzacja procesów, takich jak czyszczenie danych, synchronizacja zewnętrznych systemów czy generowanie raportów.
  • Integracja z zewnętrznymi API:
    Wysyłanie i odbieranie danych z zewnętrznych usług, takich jak systemy płatności lub magazynowe.
  • Obsługa żądań AJAX:
    Dynamiczne przetwarzanie danych w module bez potrzeby odświeżania strony.
  • Specjalistyczne zadania:
    Tworzenie niestandardowych procesów, które wymagają oddzielnej logiki.

Tworzenie niezależnego pliku PHP

Aby utworzyć niezależny plik PHP, wykonaj następujące kroki:

Utwórz nowy plik w katalogu modułu, np. custom_task.php.

Załaduj kontekst PrestaShop w pliku, aby mieć dostęp do funkcji i klas systemu. Możesz to zrobić za pomocą config.inc.php lub init.php.

Dodaj logikę, która ma być realizowana w pliku, pamiętając o wydajności i bezpieczeństwie.

Przykład prostego pliku PHP:

<?php
require_once dirname(__FILE__) . '/../../config/config.inc.php';
require_once dirname(__FILE__) . '/../../init.php';

// Logika przetwarzania
$sql = 'DELETE FROM `' . _DB_PREFIX_ . 'custom_table` WHERE date_add < NOW() - INTERVAL 30 DAY';
Db::getInstance()->execute($sql);

echo 'Dane zostały przetworzone.';

Jak używać funkcji z głównego pliku PHP modułu?

W celu ponownego użycia logiki modułu można wywoływać funkcje zdefiniowane w głównym pliku PHP modułu. Aby to zrobić:

  1. Załaduj główny plik modułu, np. mymodule.php, w swoim niezależnym pliku PHP.
  2. Uzyskaj instancję modułu za pomocą Module::getInstanceByName().

Przykład:

<?php
require_once dirname(__FILE__) . '/../../config/config.inc.php';
require_once dirname(__FILE__) . '/../../init.php';
require_once dirname(__FILE__) . '/mymodule.php';

// Załadowanie instancji modułu
$module = Module::getInstanceByName('mymodule');

if ($module && $module->active) {
	$module->exampleFunction();
}

echo 'Funkcja modułu została wywołana.';

Dzięki temu można korzystać z funkcji modułu w różnych kontekstach, co znacznie zwiększa jego elastyczność.

Bezpieczeństwo i ograniczenia dostępu

Aby zabezpieczyć dostęp do niezależnych plików PHP, zaleca się:

  • Dodanie tokena lub hasła, które będzie weryfikowane przed wykonaniem logiki.
  • Ustawienie odpowiednich nagłówków HTTP, aby zablokować nieautoryzowane żądania.
if (Tools::getValue('token') !== 'your_secret_token') {
	die('Nieautoryzowany dostęp.');
}

Podsumowanie

Niezależne pliki PHP w module PrestaShop oferują dużą elastyczność w realizacji różnych procesów. Dzięki nim możesz tworzyć zarówno automatyczne zadania, jak i niestandardowe rozwiązania, które integrują moduł z zewnętrznymi systemami. Pamiętaj jednak o odpowiednich zabezpieczeniach, aby uniknąć nieautoryzowanego dostępu do Twojego modułu.

Tworzenie formularzy konfiguracyjnych

Formularze konfiguracyjne są nieodłącznym elementem modułów w PrestaShop. Pozwalają administratorowi na dostosowanie ustawień modułu bez konieczności edycji kodu. Dzięki klasie HelperForm, tworzenie formularzy w panelu administracyjnym jest proste i intuicyjne.

Podstawowe elementy formularza

Formularze konfiguracyjne składają się z kilku kluczowych elementów, takich jak pola formularza, przyciski akcji i obsługa zapisanych danych. Wszystko to możesz skonfigurować w metodzie getContent() swojej klasy modułu.

Przykład podstawowego formularza:

public function getContent()
{
	$output = '';

	if (Tools::isSubmit('submit_mymodule')) {
		$customValue = Tools::getValue('MYMODULE_CUSTOM_VALUE');
		Configuration::updateValue('MYMODULE_CUSTOM_VALUE', $customValue);
		$output .= $this->displayConfirmation($this->l('Ustawienia zapisane.'));
	}

	return $output . $this->renderForm();
}

Tworzenie formularza za pomocą HelperForm

Klasa HelperForm ułatwia tworzenie formularzy w panelu administracyjnym PrestaShop. Przykład prostego formularza:

private function renderForm()
{
	$fieldsForm[0]['form'] = [
		'legend' => [
			'title' => $this->l('Ustawienia modułu'),
			'icon' => 'icon-cogs',
		],
		'input' => [
			[
				'type' => 'text',
				'label' => $this->l('Nazwa ustawienia'),
				'name' => 'MYMODULE_CUSTOM_VALUE',
				'size' => 20,
				'required' => true,
			],
		],
		'submit' => [
			'title' => $this->l('Zapisz'),
		],
	];

	$helper = new HelperForm();
	$helper->module = $this;
	$helper->name_controller = $this->name;
	$helper->token = Tools::getAdminTokenLite('AdminModules');
	$helper->currentIndex = AdminController::$currentIndex . '&configure=' . $this->name;
	$helper->default_form_language = (int) Configuration::get('PS_LANG_DEFAULT');
	$helper->allow_employee_form_lang = Configuration::get('PS_BO_ALLOW_EMPLOYEE_FORM_LANG') ? Configuration::get('PS_BO_ALLOW_EMPLOYEE_FORM_LANG') : 0;
	$helper->title = $this->displayName;
	$helper->submit_action = 'submit_mymodule';
	$helper->fields_value = [
		'MYMODULE_CUSTOM_VALUE' => Configuration::get('MYMODULE_CUSTOM_VALUE'),
	];

	return $helper->generateForm($fieldsForm);
}

W powyższym przykładzie formularz zawiera jedno pole tekstowe MYMODULE_CUSTOM_VALUE oraz przycisk do zapisania ustawień.

Walidacja danych

PrestaShop umożliwia walidację danych wprowadzonych w formularzu. Przykład prostego sprawdzania poprawności:

if (Tools::isSubmit('submit_mymodule')) {
	$customValue = Tools::getValue('MYMODULE_CUSTOM_VALUE');

	if (!Validate::isGenericName($customValue)) {
		$output .= $this->displayError($this->l('Nieprawidłowa wartość.'));
	} else {
		Configuration::updateValue('MYMODULE_CUSTOM_VALUE', $customValue);
		$output .= $this->displayConfirmation($this->l('Ustawienia zapisane.'));
	}
}

Przechowywanie ustawień

PrestaShop wykorzystuje klasę Configuration do przechowywania ustawień modułu w bazie danych. Aby zapisać wartość, użyj metody Configuration::updateValue(), a do jej pobrania Configuration::get().

Przykład:

Configuration::updateValue('MYMODULE_CUSTOM_VALUE', 'example_value');
$value = Configuration::get('MYMODULE_CUSTOM_VALUE');

Podsumowanie

Formularze konfiguracyjne w PrestaShop pozwalają na łatwe zarządzanie ustawieniami modułu bez potrzeby edycji kodu. Dzięki klasie HelperForm możesz w prosty sposób tworzyć funkcjonalne i czytelne formularze, które znacznie ułatwiają administratorom obsługę Twojego modułu.

Integracja z frontendem

Integracja modułu z frontendem PrestaShop pozwala na wyświetlanie dynamicznych treści i wprowadzanie funkcjonalności widocznych dla użytkowników sklepu. Dzięki temu możesz dostosować interfejs do potrzeb klienta, dodawać interaktywne elementy i optymalizować wygląd strony.

Ładowanie zasobów CSS i JavaScript

Aby moduł mógł korzystać z własnych stylów CSS i skryptów JavaScript, należy je załadować za pomocą hooka displayHeader. Przykład implementacji w pliku modułu:

public function hookDisplayHeader()
{
	$this->context->controller->addCSS($this->_path . 'views/css/mymodule.css');
	$this->context->controller->addJS($this->_path . 'views/js/mymodule.js');
}

W powyższym przykładzie pliki CSS i JS są ładowane z katalogu views/ modułu. Dzięki temu zasoby są dostępne na każdej stronie sklepu.

Ładowanie zasobów tylko na wybranych stronach

Aby zoptymalizować działanie sklepu i poprawić szybkość ładowania stron, warto ładować CSS i JS wyłącznie na stronach, które ich wymagają. Dzięki temu zmniejszysz liczbę niepotrzebnych zasobów ładowanych przez przeglądarkę. Możesz to zrobić, sprawdzając, jaka strona jest aktualnie wyświetlana.

Przykład ładowania zasobów tylko na stronie produktu:

public function hookDisplayHeader()
{
	// Ładowanie CSS i JS tylko na stronie produktu
	if ($this->context->controller->php_self === 'product') {
		$this->context->controller->addCSS($this->_path . 'views/css/product.css');
		$this->context->controller->addJS($this->_path . 'views/js/product.js');
	}
}

Możesz także sprawdzać inne typy stron, np.:

  • ’index’ – strona główna
  • ’category’ – strona kategorii
  • ’order’ – proces składania zamówienia
  • ’cart’ – koszyk

Przykład ładowania zasobów na stronie głównej:

public function hookDisplayHeader()
{
	if ($this->context->controller->php_self === 'index') {
		$this->context->controller->addCSS($this->_path . 'views/css/home.css');
	}
}

Takie podejście nie tylko poprawia szybkość działania strony, ale również zmniejsza wykorzystanie zasobów serwera oraz ilość transferu danych, co pozytywnie wpływa na doświadczenie użytkowników i wyniki SEO.

Wyświetlanie treści za pomocą hooków

Hooki typu display umożliwiają dodawanie treści w określonych miejscach sklepu, takich jak strona główna, stopka czy karta produktu. Przykład dodania niestandardowego komunikatu na stronie głównej:

public function hookDisplayHome()
{
	return 'Witaj na naszej stronie głównej!
';
}

Kod zwrócony przez metodę zostanie automatycznie wstawiony w miejscu przypisanym do hooka.

Przekazywanie danych do szablonów

Aby przekazać dane z modułu do widoków, użyj tablicy:

$this->context->smarty->assign()

Przykład wyświetlenia dynamicznej treści w szablonie:

public function hookDisplayHome()
{
	$this->context->smarty->assign([
		'custom_message' => 'Witaj, to dynamiczna wiadomość z modułu!'
	]);

	return $this->display(__FILE__, 'views/templates/hook/display_home.tpl');
}

W pliku szablonu Smarty możesz odwołać się do przekazanej zmiennej:

<div class="custom-message">{$custom_message}</div>

Podsumowanie

Integracja modułu z frontendem to kluczowy element wpływający na interakcję użytkowników ze sklepem. Poprawne wykorzystanie hooków, ładowanie zasobów oraz ich optymalizacja pod kątem specyficznych stron pozwalają stworzyć szybki, dynamiczny i przyjazny dla użytkownika sklep. Pamiętaj, że wydajność sklepu ma znaczący wpływ na zadowolenie klientów oraz na pozycję w wynikach wyszukiwania.

Obsługa AJAX w module PrestaShop

Obsługa AJAX w module PrestaShop pozwala na dynamiczne przetwarzanie danych bez konieczności odświeżania strony. Jest to kluczowy element tworzenia nowoczesnych, interaktywnych modułów. Poniżej znajdziesz kompletną instrukcję dotyczącą tworzenia i obsługi żądań AJAX w PrestaShop.

Tworzenie kontrolera obsługującego AJAX

Kontroler obsługujący AJAX jest specjalnym rodzajem kontrolera frontowego w PrestaShop. Aby go utworzyć:

Utwórz katalog controllers/front/ w folderze modułu, jeśli jeszcze go nie ma.

W katalogu controllers/front/ stwórz plik PHP. Nazwa pliku powinna być napisana małymi literami, np. ajaxhandler.php.

Klasa kontrolera w tym pliku powinna dziedziczyć po ModuleFrontController i mieć nazwę w formacie mymoduleajaxhandlerModuleFrontController, gdzie:

  • mymodule to nazwa katalogu modułu,
  • ajaxhandler to nazwa kontrolera w małych literach, dopasowana do nazwy pliku.

Przykład pliku ajaxhandler.php:

class mymoduleajaxhandlerModuleFrontController extends ModuleFrontController
{
	public function initContent()
	{
		parent::initContent();

		// Przykład przetwarzania danych
		$data = [
			'status' => 'success',
			'message' => 'Dane zostały przetworzone pomyślnie!',
		];

		// Zwracanie odpowiedzi w formacie JSON
		header('Content-Type: application/json');
		die(json_encode($data));
	}
}

Tworzenie adresu URL dla żądania AJAX

W PrestaShop adres URL kontrolera można wygenerować dynamicznie przy użyciu metody:

Link::getModuleLink()

Przykład generowania URL w pliku modułu:

$ajaxUrl = $this->context->link->getModuleLink('mymodule', 'ajaxhandler');
$this->context->smarty->assign('ajaxUrl', $ajaxUrl);

Następnie adres URL można przekazać do JavaScript za pomocą widoku Smarty:

<script>
	var ajaxUrl = '{$ajaxUrl}';
</script>

Tworzenie żądania AJAX w JavaScript

Przykład żądania AJAX w JavaScript za pomocą jQuery:

$.ajax({
	url: ajaxUrl,
	type: 'POST',
	data: { action: 'processData' },
	success: function(response) {
		if (response.status === 'success') {
			alert(response.message);
		} else {
			alert('Coś poszło nie tak.');
		}
	},
	error: function() {
		alert('Błąd podczas przetwarzania żądania.');
	}
});

Zabezpieczenia w obsłudze AJAX

Ze względu na możliwość nadużyć, warto zabezpieczyć obsługę AJAX przed nieautoryzowanym dostępem. Możesz to zrobić, na przykład:

  • Weryfikując token użytkownika (np. z wykorzystaniem klasy Tools::getToken()).
  • Sprawdzając, czy żądanie pochodzi od zalogowanego użytkownika.
  • Ograniczając dostęp do wybranych adresów IP.

Przykład zabezpieczenia kontrolera AJAX:

public function initContent()
{
	parent::initContent();

	// Weryfikacja tokena
	$token = Tools::getValue('token');
	if ($token !== Tools::getToken(false)) {
		die(json_encode(['status' => 'error', 'message' => 'Nieautoryzowany dostęp.']));
	}

	// Przetwarzanie żądania
	$data = ['status' => 'success', 'message' => 'Dane zostały przetworzone.'];
	header('Content-Type: application/json');
	die(json_encode($data));
}

Debugowanie żądań AJAX

Aby ułatwić debugowanie żądań AJAX, możesz:

Sprawdzać odpowiedzi kontrolera za pomocą narzędzi deweloperskich w przeglądarce (np. Google Chrome DevTools).

Logować błędy i odpowiedzi w plikach logów PrestaShop za pomocą metody:

PrestaShopLogger::addLog()

Przykład logowania:

PrestaShopLogger::addLog('Żądanie AJAX zostało przetworzone.', 1);

Podsumowanie

Obsługa AJAX w module PrestaShop to potężne narzędzie do dynamicznego przetwarzania danych i interakcji z użytkownikami. Kluczem do sukcesu jest prawidłowa konfiguracja kontrolera, bezpieczne przetwarzanie danych oraz optymalizacja wydajności. Dzięki AJAX możesz stworzyć bardziej responsywny i przyjazny dla użytkownika sklep.

Publikacja i testowanie modułu

Ostatnim krokiem w procesie tworzenia modułu jest jego odpowiednie przetestowanie oraz przygotowanie do publikacji. Dzięki dokładnym testom upewnisz się, że moduł działa poprawnie we wszystkich warunkach, a jego publikacja pozwoli na udostępnienie go szerszej grupie użytkowników.

Testowanie modułu

Przed udostępnieniem modułu upewnij się, że został dokładnie przetestowany. Oto kilka kluczowych kroków, które warto wykonać:

Testy funkcjonalne: Sprawdź, czy moduł działa zgodnie z założeniami. Przetestuj wszystkie funkcje i upewnij się, że wyświetlane treści oraz wprowadzone dane są poprawne.

Testy wydajności: Upewnij się, że moduł nie wpływa negatywnie na szybkość działania sklepu. Możesz użyć narzędzi takich jak Google PageSpeed Insights czy Lighthouse.

Testy kompatybilności: Przetestuj moduł na różnych wersjach PrestaShop oraz w połączeniu z innymi popularnymi modułami, aby upewnić się, że nie powoduje konfliktów.

Debugowanie w trybie developerskim: Włącz tryb developerski w PrestaShop, aby łatwo wykryć błędy i ostrzeżenia. Możesz to zrobić, edytując plik /config/defines.inc.php i ustawiając:

define('_PS_MODE_DEV_', true);

W trybie developerskim wszelkie błędy PHP, problemy z bazą danych czy nieprawidłowe wywołania hooków zostaną wyświetlone na stronie, co znacznie ułatwia ich diagnostykę i poprawę.

Debugowanie z użyciem print_r

Podczas testowania modułu możesz użyć funkcji PHP, takich jak print_r lub var_dump, aby wyświetlić zawartość zmiennych i zrozumieć, co dzieje się w kodzie. Jest to szczególnie przydatne, gdy musisz sprawdzić, jakie dane są przekazywane między funkcjami.

Przykład użycia print_r w module:

public function hookDisplayHome()
{
	$data = ['name' => 'PrestaShop', 'version' => '1.7.8'];
	print_r($data); // Wyświetlenie danych na ekranie
}

Warto pamiętać, aby przed publikacją usunąć wszystkie debugowe wywołania print_r, ponieważ mogą one spowalniać działanie sklepu i ujawniać niepotrzebne informacje użytkownikom.

Przygotowanie modułu do publikacji

Aby opublikować moduł, należy go odpowiednio spakować. Oto kroki, które należy wykonać:

  1. Upewnij się, że w katalogu modułu znajdują się wyłącznie potrzebne pliki (np. mymodule.php, config.xml, katalog views/).
  2. Usuń wszystkie pliki tymczasowe, debugowe oraz niepotrzebne komentarze w kodzie.
  3. Spakuj cały katalog modułu do pliku ZIP. Nazwa archiwum powinna odpowiadać nazwie modułu, np. mymodule.zip.

Jeśli planujesz udostępnić moduł na platformie PrestaShop Addons, upewnij się, że spełnia wymagania dotyczące zgodności z regulaminem oraz dostarcz odpowiednią dokumentację.

Publikacja modułu w PrestaShop Addons

PrestaShop Addons to oficjalny marketplace modułów i szablonów dla PrestaShop. Publikacja modułu na tej platformie wymaga:

  1. Utworzenia konta deweloperskiego na stronie PrestaShop Addons.
  2. Przygotowania dokładnego opisu modułu, w tym jego funkcjonalności, kompatybilności oraz korzyści dla użytkownika.
  3. Dołączenia zrzutów ekranu prezentujących działanie modułu.
  4. Przesłania pliku ZIP z modułem oraz wymaganej dokumentacji.
  5. Po przesłaniu modułu zespół PrestaShop przeprowadzi jego weryfikację. Jeśli wszystko będzie zgodne z wymaganiami, moduł zostanie zatwierdzony i opublikowany.

Testowanie i publikacja modułu to kluczowe etapy, które wpływają na jego jakość i sukces. Wykorzystanie trybu developerskiego, funkcji debugujących takich jak print_r, oraz dokładne sprawdzenie funkcjonalności zapewnią, że Twój moduł będzie działał płynnie i spełniał oczekiwania użytkowników.

Podsumowanie

Tworzenie modułów w PrestaShop to świetna okazja, aby w pełni wykorzystać potencjał tej platformy i dostosować ją do specyficznych wymagań swojego sklepu. Proces ten, choć może wydawać się skomplikowany na początku, staje się znacznie prostszy dzięki jasno określonym zasadom i narzędziom oferowanym przez PrestaShop.

Podczas pracy nad modułem warto pamiętać o kilku kluczowych elementach:

  1. Zrozumienie struktury:
    Prawidłowo zaprojektowana struktura plików i folderów modułu to podstawa jego poprawnego działania.
  2. Wykorzystanie hooków:
    Hooki pozwalają na bezproblemową integrację modułu z istniejącymi funkcjonalnościami sklepu.
  3. Obsługa kontrolerów:
    Tworzenie dedykowanych kontrolerów umożliwia realizację bardziej zaawansowanych funkcji zarówno na frontendzie, jak i w panelu administracyjnym.
  4. Automatyzacja:
    Zadania cron pozwalają na zautomatyzowanie powtarzalnych operacji i oszczędzanie czasu.
  5. Testowanie i optymalizacja:
    Dobrze przetestowany moduł działa płynnie i jest gotowy do wdrożenia lub publikacji.

Warto także pamiętać, że moduły nie tylko pomagają w personalizacji sklepu, ale mogą być również źródłem dodatkowego dochodu. Dzięki udostępnianiu ich na platformach takich jak PrestaShop Addons, możesz podzielić się swoimi rozwiązaniami z innymi użytkownikami i jednocześnie zmonetyzować swoją pracę.

Jeśli dopiero zaczynasz przygodę z PrestaShop, nie zrażaj się początkowymi trudnościami. Każdy nowy moduł to krok w kierunku rozwijania swoich umiejętności i lepszego poznania platformy. A przede wszystkim – nie bój się eksperymentować i testować nowych rozwiązań!

Co dalej?

Po stworzeniu swojego pierwszego modułu możesz kontynuować naukę, zgłębiając bardziej zaawansowane tematy, takie jak:

  • Tworzenie modułów wielojęzycznych i kompatybilnych z różnymi wersjami PrestaShop.
  • Integracja z zewnętrznymi API.
  • Optymalizacja modułów pod kątem wydajności i bezpieczeństwa.

Twój moduł to dopiero początek możliwości, jakie daje PrestaShop. Niezależnie od tego, czy rozwijasz sklep dla siebie, czy tworzysz rozwiązania dla klientów, zawsze pamiętaj, że dobrze zaprojektowany moduł może być zarówno narzędziem, jak i wizytówką Twoich umiejętności.

Powodzenia w tworzeniu modułów i dalszej pracy z PrestaShop!

Darmowy kurs WooCommerce
Artykuł odpowiedział na twoje pytanie? Udostępnij go dalej:
Obrazek domyślny
Damian Wyszywacz
Założyciel FriQ.SITE, 29-letni Full Stack Web Developer, który od 14. roku życia pasjonuje się programowaniem. Specjalizuje się w tworzeniu dedykowanych rozwiązań dla PrestaShop i WordPress, a także w budowaniu stron od podstaw w oparciu o autorski kod. Uwielbia wyzwania programistyczne i nieustannie poszukuje innowacyjnych rozwiązań w swoich projektach.

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *