La categoria contiene tutta la documentazione disponibile per la consultazione
Vuoi verificare la versione php usata in wordpress ? Niente di più facile. Installa il plugin Display PHP Version disponibile al link https://wordpress.org/plugins/display-php-version o ricercalo tramite la funzione disponibile nella sezione Aggiungi nuovo plugin e accedi alla sezione in Sintesi presente nella dashboard e avrai modo di verificare l’esatta versione di PHP.
Solitamente uso WordPress come CMS, lo trovo comodo e semplice da usare qualora non siano presenti particolare esigenze da parte del cliente. Da poco tempo ho scoperto la presenza della APi Rest pienamente supportate dalla versione 4.7, il che fa si che WordPress possa essere utilizzato come backend per architetture a servizi di tipo REST. In breve WordPress permette di definire agevolmente endpoint in grado di ricevere e inviare oggetti di tipo JSON (JavaScript Object Notation). JSON è un formato leggero per l’interscambio di dati, più leggero dell’XML e ciò ha fatto che l’architettura REST con JSON si presenti come alternativa ad una architettura SOAP con XML. Per chi volesse maggiori dettagli su REST rimando ai ragazzi di HTML.IT
Nel mio caso l’esigenza è quella di realizzare un app android che acceda ai contenuti gestiti su una piattaforma WordPress e ne consenta la lettura e/o la modifica.
In questo articolo vedremo come realizzare un servizio REST. Per fare questo occorre realizzare un plugin wordpress, definire l’endpoint da gestire e la logica con cui gestire le chiamate ricevute.
Andiamo per ordine, per realizzare il plugin occorre caricare un file php nella cartella /wp-content/plugins. Tale file deve presentare una intestazione particolare, che consenta a WordPress di individuarlo e di consentire tramite la dashboard di attivarlo. Di seguito un esempio:
|
1 2 3 4 5 6 7 8 9 |
<?php /* Plugin Name: Valerio Finazzo Plugin Plugin URI: http://www.valeriofinazzo.it/ Description: Plugin per la lettura dei posts Author: Valerio Finazzo Version: 1.0 */ ?> |
Se avete fatto correttamente, accedendo alla sezione plugin di WordPress trovere il plugin da attivare
A questo punto attiviamo il file ma non essendoci alcun endpoint definito non vedremo effetti. Per definire l’endpoint ci avvaliamo della direttiva add_action che consente di stabilire le regole di invocazione del servizio e la logica con cui restituire il dato
|
1 2 3 4 5 6 |
add_action( 'vfplugin_api_init', function () { register_rest_route( 'vfplugin/v1', '/posts/', array( 'methods' => 'GET', 'callback' => 'api_get_posts', )); }); |
Il comando add action invoca la direttiva register_rest_route che stabilisce l’url da invocare, il metodo HTTP con cui invocare il servizio e la funzione da invocare). Nell’esempio fornito il plugin risponde alla chiamata GET del servizio http://www.valeriofinazzo.it/wp-json/vfplugin/v1/posts/.
Il metodo cakllback prevede di chiamare la routine api_get_posts che recupera tutti gli articoli presenti nel sito serializzati in formato json
|
1 2 3 4 5 6 7 |
function api_get_posts( $data ) { $all_posts = array(); $posts = get_posts(); if ( empty($posts) ) return null; return $posts; } |
La serializzazione viene gestita in modo trasparente da WordPress. Pertanto il servizio è attivo e non è richiesto altro.
A seguire il codice completo
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
<?php /* Plugin Name: Valerio Finazzo Plugin Plugin URI: http://www.valeriofinazzo.it/ Description: Plugin per la lettura dei posts Author: Valerio Finazzo Version: 1.0 */ add_action( 'rest_api_init', function () { register_rest_route( 'vfplugin/v1', '/posts/', array( 'methods' => 'GET', 'callback' => 'api_get_posts', )); }); function api_get_posts( $data ) { $all_posts = array(); $posts = get_posts(); if ( empty($posts) ) return null; return $posts; } ?> |
Da poco ho iniziato a usare questo prodotto per l’ecommerce. Sull’installazione non mi soffermo perchè è abbastanza intuitiva, oltretutto è già offerta dai siti di hosting come aruba. Mi soffermerò di più sugli aspetti di configurazione, che l’interfaccia di back-end non permette di gestire in modo naturale.
La prima cosa che ho dovuto fare è stata rimuovere la condizione del prodotto. L’interfaccia di back-end non consente di agire su questo oggetto. Navigando sul forum ho trovato varie soluzioni che prevedevano la modifica al template tpl del prodotto. Personalmente ho preferito agire sul css e nascondere l’oggetto al momento della presentazione.
Per fare questo dovete modificare il file css product.css e aggiungere in coda la definizione
|
1 2 3 |
#product_condition{ display:none; } |
A questo punto ricaricando la pagina di dettaglio del prodotto il campo condizione risulterà scomparso.
Se per qualche motivo non potete modificare il css o il vedere il tag nell’html urta la vostra sensibilità potete sempre commentare il sorgente del file product.tpl all’interno del vostro tema
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
{if $product->condition} <p id="product_condition"> <label>{l s='Condition'} </label> {if $product->condition == 'new'} <link itemprop="itemCondition" href="http://schema.org/NewCondition"/> <span class="editable">{l s='New'}</span> {elseif $product->condition == 'used'} <link itemprop="itemCondition" href="http://schema.org/UsedCondition"/> <span class="editable">{l s='Used'}</span> {elseif $product->condition == 'refurbished'} <link itemprop="itemCondition" href="http://schema.org/RefurbishedCondition"/> <span class="editable">{l s='Refurbished'}</span> {/if} </p> {/if} |
Il comportamento è stato implementato e testato sulla versione 1.6, con il thema di defautl
Ho continuato lo studio per gestire il tooltip in un datagrid gxt. Il giro è un pò più complesso di quello che pensavo, ma neanche tanto, basta cambiare il punto di vista.
Il Grid è definito aggiungendo le colonne una per una e associando a ciascuna di esse una configurazione, tramite la classe ColumnConfig.
Ipotizziamo di voler creare un classico grid con 2 colonne e di voler attivare il tooltip sia sull’intestazione che sul contenuto.
|
1 2 3 4 5 |
ColumnConfig<BandoDG, String> dataOperazione = new ColumnConfig<BandoDG, String>(props.dataPubblicazione(), 10, "Data Operazione"); dataOperazione.setToolTip(SafeHtmlUtils.fromString("Data Operazione")); dataOperazione.setHorizontalAlignment(ColumnConfig.ALIGN_RIGHT); ColumnConfig<BandoDG, String> descrizione = new ColumnConfig<BandoDG, String>(props.oggetto(), 50, "Descrizione"); descrizione.setToolTip(SafeHtmlUtils.fromString("Descrizione")); |
Con la chiamata setToolTip stabiliamo il tooltip associato all’intestazione.
Adesso definiamo il tooltip a livello di cella. Per fare ciò ci viene in soccorso la classe TextCell, e ridefinendo la funzione di render in modo da associare un tooltip alla singola cella
|
1 2 3 4 5 6 7 8 9 10 11 |
TextCell textCell = new TextCell(){ @Override public void render(com.google.gwt.cell.client.Cell.Context context, String value, SafeHtmlBuilder sb) { String tooltipValue = value; String cellValue = value; sb.appendHtmlConstant("<span qtip=\""+tooltipValue+"\">"+cellValue+"</span>"); } }; descrizione.setCell(textCell); dataOperazione.setCell(textCell); |
Per attivare il tooltip occorre instanziare un oggetto QuickTip associandolo al grid
|
1 |
new QuickTip(grid); |
e a questo punto invocando il datagrid sarà visibile il tooltip a livello di cella.
Nell’articolo di oggi vedremo come integrare un tooltip in una datagrid sencha. Nel fare questa attività ho avuto qualche rimpianto per la semplicità di utilizzo di Flex, che permette di definire in modo semplice (tramite una sola properties) Il tooltip da far apparire per una determinata colonna.
Con Sencha la cosa non è così intuitiva, probabilmente esiste un modo molto semplice, ma non ho trovato una soluzione che mi soddisfacesse a pieno. La soluzione che vi presento permette di definire un tooltip su un datagrid ed è provata e testata su gxt 3.1.0 e gwt 2.6.1.
La classe grid presenta una properties tooltip, ma essa riceve una string come argomento, pertanto si presta solo per tooltip statici, mentre la mia esigenza è quella di un tooltip funzione della riga selezionata e ancora meglio della cella selezionata.
Per soddisfare la necessità ho dovuto gestire gli eventi dell’oggetto, avrei sperato in una property della row ma le mie ricerche non hanno avuto esito positivo.
Pertanto considerando di avere a che fare con un oggetto Grid della classe com.sencha.gxt.widget.core.client.grid.Grid possiamo definire un handler sul mouse hover in questo modo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
grid.addHandler(new MouseMoveHandler() { @Override public void onMouseMove(MouseMoveEvent event) { BandoDG newHover = null; NativeEvent natev = event.getNativeEvent(); if (Element.is(natev.getEventTarget())) { int hoverIdx = grid.getView().findRowIndex( Element.as(natev.getEventTarget()) ); newHover = grid.getStore().get(hoverIdx); } if (newHover == null) { return; } String note = newHover.getNote(); String html = newHover.getOggetto(); if (note!=null && !note.isEmpty()) { html = "<span qtip='" + note + "'>" + note + "<br/>" + newHover.getOggetto() + "</span>"; } grid.setToolTip(html); } }, MouseMoveEvent.getType()); |
Tramite tale approccio riusciremo a vedere il tooltip al passare del mouse, un tooltip funzione del model associato al grid.
Nei miei piano avrei v oluto anche gestire la comparsa e scomparsa del tooltip in funzione della colonna, ma i comandi relativi non hanno avuto l’effetto desiderato.
In questo caso direi meglio questo che niente. Alla prossima
Dopo aver integrato il database oggi realizziamo il form per l’inserimento dei dati e agganciamo ad esso una funzione di validazione, che evidenzi i campi obbligatori.
Prevediamo tre campi obbligatori:
Questi 3 campi vengono definiti come EditText
|
1 2 |
<EditText android:id="@+id/cityMarketValue" android:inputType="textCapWords" /> |
L’attributo inputType impone il controllo sul formato del campo. Al salvataggio del form il sistema invoca la funzione di validazione che verificherà se il campo è valorizzato o no tramite la routine
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Boolean controllo = true; if (name.getText().toString().length()==0) { controllo = false; name.setError(getResources().getString(R.string.mandatory)); } if (city.getText().toString().length()==0) { controllo = false; city.setError(getResources().getString(R.string.mandatory)); } if (address.getText().toString().length()==0) { controllo = false; address.setError(getResources().getString(R.string.mandatory)); } return controllo; |
Qualora il controllo fallisse la classe EditText mette a disposizione il metodo setErrorr che consente di abilitare il messaggio di errore attivo sul singolo campo, come si può vedere in foto
In Android molte applicazioni necessitano di un database per conservare le informazioni per un uso successivo. Realizzeremo insieme un crud, ovvero un app che consente le tipiche operazioni di gestione di una entità:
creazione, ricerca, aggionrnamento e cancellazione.
Il database di riferimento è SQLite, il package offerto da android è android.database.sqlite.
Per poter accedere al nostro database occorre estendere la classe SQLiteOpenHelper, che prevede l’implementazione dei metodi creazione del database.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
public class DatabaseHelper extends SQLiteOpenHelper { public static final String DB = "gestoremarket"; public static final int SCHEMA_VERSION = 1; public static final String DATABASE_NAME = "gestoremarket.db"; public DatabaseHelper(Context context) { super(context, DATABASE_NAME, null, SCHEMA_VERSION); } @Override public void onCreate(SQLiteDatabase db) {} @Override public void onUpgrade(SQLiteDatabase db, int arg1, int arg2) {} } |
Il costruttore prevede la creazione di un database con una determinata versione e sono previsti i metodi che verranno lanciati alla creazione del database e/o al suo aggiornamento., All’interno dei metodi è possibile lanciare degli script sql per aggiornare il database.
A questo punto dobbiamo definire la classe per la gestione della nostra tabella, tale classe implementa l’interfaccia BaseColumns, che prevede la presenza di una primary key _ID (tale approccio non è obbligatorio, ma è consigliato da Google per uno sviluppo più armonico)
Nel nostro caso prevediamo una classe così fatta
|
1 2 3 4 5 6 7 8 9 10 11 |
public class MarketTable implements BaseColumns { public static String TABLE_NAME = "MARKET"; public static String NAME = "NAME"; public static String CITY = "CITY"; public static String ADDRESS = "ADDRESS"; public static String CANCELLATO = "CANCELLATO"; public static String[] COLUMNS = new String[] {_ID, NAME, CITY, ADDRESS, CANCELLATO }; } |
Non resta che definire la classe DAO responsabile dei metodi di lettura e scrittura sul nostro db
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
public class MarketDao { private DatabaseHelper databaseHelper; public MarketDao(Context context) { databaseHelper = new DatabaseHelper(context); } public List<Market> getAll() { SQLiteDatabase database = databaseHelper.getReadableDatabase(); List<Market> list = new ArrayList<Market>(); String sql = String.format("select " + "market._id, " + "market.name, " + "market.city, " + "market.address " + "from market " + "where market.cancellato = 0") ; Log.i(DatabaseHelper.DATABASE_NAME, sql); Cursor cursor = database.rawQuery(sql, null); cursor.moveToFirst(); while (!cursor.isAfterLast()) { Market market = getMarket(cursor); list.add(market); cursor.moveToNext(); } cursor.close(); database.close(); return list; } public void delete(Long id) { SQLiteDatabase database = databaseHelper.getWritableDatabase(); String sql = String.format("update market " + "set cancellato = 1 " + " where _id = %d ", id) ; Log.i(DatabaseHelper.DATABASE_NAME, sql); database.execSQL(sql); database.close(); } public void save(Market item) { SQLiteDatabase database = databaseHelper.getWritableDatabase(); ContentValues contentValues = creaContentValues(item); if (item.getId()==null) { long insertOrThrow = database.insertOrThrow(MarketTable.TABLE_NAME, null, contentValues); item.setId(insertOrThrow); } else database.update(MarketTable.TABLE_NAME, contentValues, " _id = " + item.getId(), null); database.close(); } private ContentValues creaContentValues(Market item) { ContentValues contentValues = new ContentValues(); contentValues.put(MarketTable._ID, item.getId()); contentValues.put(MarketTable.NAME, item.getName()); contentValues.put(MarketTable.CANCELLATO, item.getCancellato()); contentValues.put(MarketTable.CITY, item.getCity()); contentValues.put(MarketTable.ADDRESS, item.getAddress()); return contentValues; } } |
Dall’analisi della classe si vede come la classe Helper permetta di accedere al database in lettura e/o scrittura tramite i metodi
|
1 |
SQLiteDatabase database = databaseHelper.getWritableDatabase(); |
|
1 |
SQLiteDatabase database = databaseHelper.getReadableDatabase(); |
Ottenuta l’istanza del database la classe mette a disposizione dei metodi per la gestione dei dati, che permettono di eseguire del codice sql oppure tramite l’uso di classi container, tipo ContentValues, che consentono l’interazione con il database anche con una limitata conoscenza di sql.
Buona sperimentazione.
L’articolo illustra come aggiungere dei nuovi campi al livello di presentazione di un libro. La gestione di un nuovo campo si articola nelle seguenti fasi:
Il record driver è la classe php responsabile di recuperare il dato esposta da Solr. Nella configurazione standard occorre aggiungere i metodi di get alla classe SolrDefault, tale operazione è sufficiente se il campo è già disponibile in Solr, altrimenti deve essere aggiunto modificando lo schema opportunamente, come illustrato in un articolo precedente.
Ipotizzando di gestire un campo di nome abstract modificheremo la classe SolrDefault aggiungendo il metodo
|
1 2 3 4 5 |
public function getAbstract() { return isset($this->fields['abstract']) ? $this->fields['abstract'] : ''; } |
A questo punto il metodo è invocabile nel tema, quindi modifichiamo il file core.phtml aggiungendo l’invocazione del metodo
|
1 2 3 4 5 |
<? $abstract = $this->driver->getAbstract(); ?> <tr valign="top"> <th><?=$this->transEsc('abstract')?>: </th> <td property="abstract"><?=$this->escapeHtml($abstract)?></td> </tr> |
E’ possibile modificare la presentazione aggiungendo anche un tab nella sezione a scheda. Per fare questo occorre agire sul file di configurazione del modulo VUFIND nella sezione recorddriver_tabs e definire un nuovo tab
|
1 2 3 4 5 6 7 8 9 10 11 |
'VuFind\RecordDriver\SolrDefault' => array( 'tabs' => array ( 'Holdings' => 'HoldingsILS2', 'Description' => 'Description2', 'TOC' => 'TOC2', 'UserComments' => 'UserComments2', 'Reviews' => 'Reviews2', 'Excerpt' => 'Excerpt2', 'HierarchyTree' => 'HierarchyTree2', 'Map' => 'Map2', 'Details' => 'StaffViewArray2', <strong>'altreInfo' => 'AltreInfo',</strong> ), 'defaultTab' => null, ), |
LA configurazione si conclude con la creazione di un controller in RecordTab del modulo VuFind e la vista altreInfo.phtml relativa nel tema configurato.
Se abbiamo operato bene otterremo questo effetto
L’articolo illustra la creazione di un modulo in VUFIND e la sua integrazione, in particolare vedremo la creazione di un modulo per la lettura delle news.
Il modulo ha una struttura ben definita, è una directory all’interno della cartella module e presenta la seguente alberatura
|
1 2 3 |
config src Module.php |
Il file Module.pho definisce il modulo e ha un contenuto di questo
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
<?php namespace VuFindNews; use Zend\ModuleManager\ModuleManager, Zend\Mvc\MvcEvent; class Module { public function getConfig() { return include __DIR__ . '/config/module.config.php'; } public function getAutoloaderConfig() { return array( 'Zend\Loader\StandardAutoloader' => array( 'namespaces' => array( __NAMESPACE__ => __DIR__ . '/src/' . __NAMESPACE__, ), ), ); } public function init(ModuleManager $m) { } public function onBootstrap(MvcEvent $e) { } } |
Come si può notare il modulo recupera la configurazione dal file module.config.php presente nella directory config. Definiamo nel file il nostro controller tramite la sintassi:
|
1 2 3 4 5 6 7 |
<?php namespace VuFindNews\Module\Configuration; $config = array( 'controllers' => array( 'invokables' => array( 'vufindnews' => 'VuFindNews\Controller\VuFindNewsController',),),); return $config; |
A questo punto implementiamo il controller e la relativa action
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<?php namespace VuFindNews\Controller; class VuFindNewsController extends \VuFind\Controller\AbstractBase { public function testAction() { $view = $this->createViewModel(); return $view; } public function homeAction() { $view = $this->createViewModel(); return $view; } } |
e la view relativa ad ogni action all’interno del nostro tema nel percorso
\vufind\themes\<nomeTema>\templates\<nomeModulo>
nel nostro caso definiamo i file test.phtml e home.phtml
Non resta che dichiarare il modulo nel file application.config.ini
|
1 2 3 4 |
<?php $config = array( 'modules' => array( 'VuFindHttp', 'VuFindTheme', 'VuFindSearch', 'VuFind', 'VuFindAdmin', 'VuFindNews'), |
A questo punto è possibile verificare la correttezza delle operazioni chiamando l’url
|
1 |
http://localhost/site1/VuFindNews/test |
Infine possiamo definire il nostro modulo come la homepage agendo sul file config.ini agendo sul parametro
|
1 2 3 |
; The base VuFind URL will load the "Home" action of this module unless the user ; is logged in: defaultModule = VuFindNews |
In tal modo invocando la home VUFIND chiamerà la action home del modulo scelto
Nell’articolo di oggi illustro la procedura per aggiungere un controller al modulo VUFIND. Per controller si intende la classe responsabile di interpretare la richiesta e caricare la pagina di presentazione dati (VIEW).
Occorre creare la classe all’interno del package di VUFIND
|
1 |
module/VuFind/src/VuFind/controller |
I controller sono classi php che estendono la classe “AbstractBase”, i cui metodi con suffisso Action individuano le action esposta dal controller.
Consideriamo la classe TestController.php contenente il seguente codice:
|
1 2 3 4 5 6 7 8 9 10 |
<?php namespace VuFind\Controller; class TestController extends AbstractBase { public function testAction() { $view = $this->createViewModel(); return $view; } } |
Tale controller va configurato nel file di configurazione centrale del modulo VUFIND disponibile al path
|
1 |
module/VuFind/config/ module.config.php. |
Tale configurazione prevede la definizione di un alias nela sezione invokables del file
|
1 2 |
'invokables' => array( 'test' => 'VuFind\Controller\TestController', |
e la definizione della “Route”, che individua la action da invocare agendo sulla sezione delle rotte statiche
|
1 2 |
$staticRoutes = array( 'test/test', |
Il metodo testAction prevede la presenza di una view che si chiami come la action, nel nostro caso test.phtml, presente all’interno del nostro tema all’interno di una directory pari al nome del controller
“themes/<tema>/templates/test/test.phtml”
Il cui contenuto è
|
1 2 3 |
<? echo 'TEST'; ?> |
E’ possibile verificare la correttezza di quanto fatto invocando l’url
http://localhost/vufind/test/test