nyúlkál, piszkál, szétszed...

A SEO témakör margójára :)

2012-01-18T08:59:00.000-08:00

Már régebben is szerettem volna írni a SEO-ról, de végül mindig elhalasztottam, mert úgy éreztem, hogy túlságosan sok negatív élményem volt a témával kapcsolatban és emiatt elfogult lennék. Mindegy, ez egy szubjektív blog. Belefér. :)
Azt nem szeretném boncolgatni, hogy mi a SEO , vagyis a keresőoptimalizálás (Search Engine Optimization), ez sok helyen le van írva, elég ha elolvasod például a Wikit.

Nekem a keresőoptimalizálással (mostantól SEO, mert így rövidebb) alapvetően semmi bajom nincs, hiszen ez nekem, mint olyan programozónak, aki webes alkalmazásokat is fejleszt, valójában a megélhetésem egyik "alapköve", ugyanis ha az ügyfelek, akiknek dolgozom, vagy a cég amiben dolgozom, sikertelen, alacsony látogatottságú weboldalakat készít, vagy üzemeltet, akkor felkopik az állam - tehát, a SEO fontos. Ez evidens, de nem jelenti azt, hogy minden siker csakis egy mechanikus műveletsoron, egy Csodarecepttel elérhető Nagy Ugráson múlna, amit egy úgynevezett SEO mágus birtokol, de ezen a ponton ismét megjegyezném, hogy nem szeretnék beleesni az elfogultság csapdájába, tehát leszögezném, hogy nem gondolom azt, hogy a SEO és a SEO-val foglalkozó minden szakember sarlatán, de a tapasztalataim alapján úgy gondolom, hogy ezen a területen akadnak zavarosban halászó "szakértők". Hagyjuk ezt, aki nem becsületes, azt ez úgysem zavarja, vigyorogva fog továbbra is "varázsolni".

A sikeres internetes projektet a látogatottsággal szoktuk mérni, ebből nagyon sok fajta van, hiszen nem mindegy, hogy a látogató visszatérő látogató-e, nem mindegy, hogy 5 másodpercet, vagy 15 percet töltött-e nálunk, az sem mindegy, hogy belépett-e, eljutott-e a vásárlásig, befejezte-e azt, és sorolhatnám, hiszen ahány fajta oldal van, annyi fajta szempont-rendszert tudunk leképezni és mérni, egészen a legapróbb részletekig, egy blognál teljesen más szempontok vannak, mint egy zoknit áruló webáruháznál, de a cél minden esetben az, hogy lehetőleg minden típusú látogatottsága növekedjen az oldalnak. Szerintem ezen a ponton lehet eldönteni egy SEO szakemberről, hogy amit ígér az blabla, vagy tényleg egy komolyan vehető, megvalósítható módszer, amely elvezethet a sikerhez, vagyis a keresők szeretni fognak bennünket, a látogatottság nő.

Először ezen a blogon szeretném bemutatni, hogy én hogyan növeltem meg a látogatottságomat, alig két hónap alatt körülbelül háromszorosára az addiginak, majd egy folyamatos, dinamikus növekedés következett és utána stagnálás :). Én nem vagyok SEO szakértő, nem ebből élek, csak úgy gondoltam, hogy ezen a példán tudom legjobban szemléltetni azt, ami szerintem a látogatottság növekedésének legfontosabb összetevője: a saját tartalom.

Ezt a blogot 2009-ben kezdtem írni, akkor még Magyarországon éltem, Budapesten dolgoztam egy fejlesztő cégben és egyik délután unatkoztam és gondoltam csinálok egy szakmai blogot, csak úgy, cél nélkül. Tehát volt egy ötlet, igaz nem túl fantáziadús :) nem is volt nagy eredménye, körülbelül 2 évig nem is érdekelt az, hogy olvassák-e, vagy sem, a látogatottság szinte ugyanakkora volt. Ezután eszembe jutott, hogy megpróbálom megnövelni a látogatottságot, első lépésben felcímkéztem rendesen a már meglévő bejegyzéseket, ez persze nem segített semmit. :) Majd elkezdtem olyan témájú cikkeket írni, amilyen témákban én is keresgéltem az interneten, de nem találtam megfelelő leírásokat, nah, ez meg is hozta az eredményt, lassan növekedni kezdett a látogatottság. Ezek után jött az, hogy rendszeresen publikáltam újabb bejegyzéseket és mindig tudatosan olyan témákban, ami szerintem hiánypótló volt és valójában ennyi volt a nagy trükk, a "csoda" megtörtént... :) Elkezdtek rám mutatni külső hivatkozások, és ami nagyon fontos megjöttek az első "kommentek" - ez valószínűleg nagyon fontos (bár nem ismerem a keresők algoritmusát, de ez lenne a logikus). Utána nem írtam 1-2 hónapig, a növekedés lassan le is állt, de nem süllyedt, csak stagnált.

Persze, nyilván más egy webáruház, vagy egy céges honlap, és sokat számítanak a hirdetések, de nincs csoda. Nincs varázspálca. Szerintem ha nincs saját, egyedi tartalom, akkor nem lehet komoly sikert elérni, és igazán komoly látogatottsághoz szerintem legalább 1-2 év felfutási idő kell, állandó, friss tartalommal, aki mást ígér az szerintem gyanús. :)

Szerintem egy korrekt, becsületes SEO szakember elsődleges feladata az, hogy el tudja magyarázni a laikus ügyfélnek, hogy nem létezik csoda, és a marketinges eszközök csak segíteni tudják a meglévő saját energiákat abban, hogy elérjék a célt, de ha nincs saját koncepció, nincs saját ötlet, szenvedély, akarat stb., akkor a marketingre költött pénzt akár a WC-ben is lehúzhatták volna. Csak sajnos nagyon sok ügyfél nem is tudja mit akar, vagy nem érdekli, csak látogatottságot szeretne (mert a főnöke utasította, mert egy megbeszélésen így döntöttek stb.), bármi áron és nagyon-nagyon boldog ha jön valaki - egy mágus, aki elhiteti vele és esetleg a főnökeivel, hogy csodák márpedig léteznek, minden csak pénz kérdése... hát így lehet a zavarosban halászni és ebből megélni. Ez olyan egy kicsit mint a csodatoktorok, akik kézrátétellel operálnak... (amiben kik hisznek?) :) Ezt nem írom le, mindenki találja ki! :)

Symfony 1.4, 1.3 űrlapok és ajax validáció

2012-01-18T07:11:00.000-08:00

Nem nagyon találtam leírást arról, hogy a Symfony 1.4-ben és a Symfony régebbi változataiban hogyan lehet ajaxos validációt készíteni úgy, hogy ne kelljen változtatni az űrlapjainkon és csakis BaseFormDoctrine-ból származtatott űrlapokat használjuk.

Ez lenne a Symfony esemény és a feldolgozó metódus:

  public function executeUpdate(sfWebRequest $request)  
  {  
   $this->forward404Unless($request->isMethod(sfRequest::POST) || $request->isMethod(sfRequest::PUT));  
   $this->forward404Unless($family = Doctrine_Core::getTable('Family')->find(array($request->getParameter('id'))), sprintf('Object family does not exist (%s).', $request->getParameter('id')));  
   $this->form = new UpdateFamilyCollectionForm($family);  
   $this->processForm($request, $this->form);  
   return sfView::NONE;  
  }  

  /**
   * 
   * Process Form
   * @param sfWebRequest $request
   * @param sfForm $form
   * @author BlaBla :)
   */
  protected function processForm(sfWebRequest $request, sfForm $form)  
  {  
    $sJsonReturnString = "";  
    $this->setLayout(false);  
    $form->bind($request->getParameter($form->getName()), $request->getFiles($form->getName()));  
   if ( $form->isValid())   
   {  
    $family = $form->save();  
    $sJsonReturnString = json_encode(array( "msg"=>"ok" ));  
   }  
   else  
   {  
           $errors = $form->getErrorSchema()->getErrors();  
           $aErrors = array();  
             if (count($errors) > 0)  
             {  
          {  
               $i = 0;  
               foreach ($errors as $name => $error)  
               {  
                 $aErrors[ $name ] = $error->getMessage();  
               }  
          }       
           }  
           $sJsonReturnString = json_encode($aErrors);       
   }  
   echo $sJsonReturnString;  
  } //processForm

Az $errors = $form->getErrorSchema()->getErrors(); visszaadja a hibákat és ezeket írjuk ki a kliensnek.

A kliensen pedig valahogy így dolgozhatjuk fel a kapott értékeket (én most JQuery-t használtam):

 var dataString = jQuery('#updatefamilyForm').serialize();  
 var postUrl = jQuery('#updatefamilyForm').attr('action');  
 $.ajax({  
           type: "POST",  
           url: postUrl,  
           data: dataString,  
           success: function(response) {  
            var FormErrors = $.parseJSON(response);  
            jQuery.each(FormErrors, function(i, val) {  
                     alert(i+val);  
                });                         
           }  
      });

Az űrlapunkat a sablonban a klasszikus Symfony-s módon készítjük el, annyi különbséggel, hogy a form elem kap egy id-t:

 <form id="updatefamilyForm" action="<?php echo url_for('family/'.($form->getObject()->isNew() ? 'create' : 'update').(!$form->getObject()->isNew() ? '?id='.$form->getObject()->getId() : '')) ?>" method="post" <?php $form->isMultipart() and print 'enctype="multipart/form-data" ' ?>>

Ezt a problémát sokféleképpen meg lehetne oldani, ez csak egy módszer a sok közül.

Hibakezelés 5.3-as PHP-ban névtelen függvénnyel

2012-01-17T04:25:00.000-08:00

A hibakezelést sokféleképpen meg lehet valósítani PHP-ban, nem minősítem egyik módszert sem, kivéve ha nem használunk kivételkezelést, mert az szerintem helytelen. :)
A PHP legújabb lehetőségeit kihasználva készíthetünk egy ilyen megoldást, névtelen függvénnyel:

 <?php  
 $filename = "data.txt";  
 $newfilename = "newfile.txt";  
 set_error_handler(  
   function($error, $message = '', $file = '', $line = 0) use ($filename, $newfilename) {  
     throw new RuntimeException( sprintf(  
       'Error opening file "%s" (in %s@%d): %s - %s not created',  
       $filename, $file, $line, $message, $newfilename  
     ), $error);  
   },  
   E_WARNING  
 );  
 copy ( $filename,   
           $newfilename  
           );  
 restore_error_handler();  
 ?>

Ez végül is nem egy nagy újítás, de érdekes. Az ötlet egyébként Matthew Weier O'Phinney-tól származik, érdemes elolvasni a blogbejegyzését:

http://mwop.net/blog/on-error-handling-and-closures

ebben vannak további példák és a hozzászólásokban is akad néhány érdekes ötlet.

Szabadon letölthető fejlesztői kézikönyv jelent meg a Windows Phone programozásáról

2012-01-16T17:11:00.000-08:00

Szabadon letölthető fejlesztői kézikönyvet adott ki devPortal.hu a Windows Phone programozásáról, a könyv PDF formában letölthető a következő címről:

https://devportal.hu/wp7/konyv

A könyv színvonalasan összeállított és nagyon fontos, hasznos témákat érint, mint például az adatkötések, WP7 vezérlők, erőforrások kezelése, animációk, XAML - és még nagyon sok egyéb. :)

Ha valakit érdekel a WP7 fejlesztés, akkor ennek a könyvnek szerintem örülni fog!

LyraCMS and LyraAdminBundle

2011-12-25T15:11:00.000-08:00

http://www.lyra-cms.com/blog/2011/12/status-lyra-cms-development.html

https://github.com/mgiagnoni/LyraAdminBundle

Windows Mobile: hozzáférés a címlistához

2011-11-25T04:32:00.000-08:00

Vettem egy új telefont és elkezdtem tesztelgetni. Ezekkel a bejezésekkel ("Windows Mobile" kezdetűek) csak dokumentálom magamnak a példakódjaimat, azért, hogy 2 hónap múlva ne kelljen újra átnyálaznom az API-t...

A kódok a Visual Studio Express-el készültek, ez Visual Basic-ben.

Szóval, a címlistához így lehet hozzáférni:

 Imports Microsoft.Phone.UserData  
   
   
 Partial Public Class MainPage  
   Inherits PhoneApplicationPage  
   
   ' Constructor  
   Public Sub New()  
     InitializeComponent()  
   End Sub  
   
   
   Private Sub Button1_Click(sender As System.Object, e As System.Windows.RoutedEventArgs) Handles Button1.Click  
     ApplicationTitle.Text = "Test Application"  
     Dim cons As Contacts = New Contacts()  
     AddHandler cons.SearchCompleted, AddressOf Contacts_SearchCompleted  
     cons.SearchAsync(String.Empty, FilterKind.DisplayName, "James Bond")  
   End Sub  
   
   
   Private Sub Contacts_SearchCompleted(sender As Object, e As ContactsSearchEventArgs)  
     MessageBox.Show(e.Results.Count().ToString())  
   End Sub  
 End Class

Windows Mobile: fejlesztői környezet

2011-11-23T06:11:00.000-08:00

A fejlesztői környezet létrehozása eléggé egyszerű lett (régebben külön kellett mindent feltelepíteni) elegendő letölteni az SDK-t (jelenleg a 7.1 az ajánlott). Innen töltheted le:

http://create.msdn.com/en-us/home/getting_started

Ez a következő szoftvereket tartalmazza:

Microsoft Visual Studio 2010 Express for Windows Phone
Windows Phone Emulator
Windows Phone SDK 7.1 Assemblies
Silverlight 4 SDK and DRT
Windows Phone SDK 7.1 Extensions for XNA Game Studio 4.0
Microsoft Expression Blend SDK for Windows Phone 7
Microsoft Expression Blend SDK for Windows Phone OS 7.1
WCF Data Services Client for Window Phone
Microsoft Advertising SDK for Windows Phone

Szerintem ez kezdésnek bőven elegendő... :) A Microsoft Visual Studio 2010 Express támogatja a Visual Basic-et és a C#-t, mindenki döntse el melyiket szereti. Nagyon sok sablont is kapunk az SDK-val együtt, ezeket érdemes kipróbálgatni, ha az időm engedi, akkor majd írok a saját próbálkozásaimról.

Symmfony2 AdmigeneratorGeneratorBundle

2011-10-24T06:47:00.000-07:00

Úgy látszik másoknak is elegük lett a Sonata Admin Bundle-ból és ezért elindítottak egy teljesen új admin generátor fejlesztését, a projekt még kezdeti stádiumban van, de biztató. Ezen a címen érhető el:

http://symfony2admingenerator.org/

Egyelőre még nem volt időm komolyabban letesztelni, de a hét végéig valószínűleg szakítok rá időt, ha valakit érdekel akkor próbálja ki! :)

C és C++ fordító Windows alá, MinGW, wxWidgets

2011-10-16T07:08:00.000-07:00

Sokféle C fordítót kipróbáltam, végül a MingW lett az amit használok. (A MinGW egy GNU C fordító - ha valaki nem ismerné) Ez csak egy rövid leírás a telepítésről.

1. le kell tölteni a mingGW-t, én ezt ajánlom: http://sourceforge.net/projects/mingw/

majd telepíteni kell (a jelenlegi telepítője nem túl bonyolult, régebben volt rosszabb is). Ha kész a telepítés, akkor a Windows PATH változó értékei közé fel kell venni a MinGW elérési útjait is, nálam ezek a következők:

 H:\MinGW\bin\;H:\MinGW\lib\;H:\MinGW\include;

2. Telepíteni kell a mingw32-make-t, pl. innen:

http://sourceforge.net/projects/mingw/files/MinGW/make/mingw32-make-3.80-3/mingw32-make-3.80.0-3.exe/download

Telepítésnél ajánlatos jól megadni a minGW elérési útját, a későbbi problémák elkerülése végett :) Ha telepítetted, akkor a minGW /bin könyvtárában fogod megtaláni mingw32-make.exe néven, én ezt átneveztem make.exe-re. Ezen a néven ugyanis valami fura oknál fogva minden könnyebben megtalálta, aminek szüksége volt rá...nem is értem, hogy miért... :)

4. telepíteni kell a gdb-t, pl. innen:

http://sourceforge.net/projects/mingw/files/MinGW/BaseSystem/GDB/Current%20Release_%20gdb-5.2.1/gdb-5.2.1-1.exe/download

Erre ugyanaz vonatkozik mint ami a make-ra, átnevezni nem kell.

5. ha eddig készen vagy, akkor egy "Hello World!" programot már tudsz fordítani :) (Nem tudom, hogy ez miért lett egy külön pont...)

6. én nem szeretem az Eclipse-t, de mégis használom, mert a kakik (khm, ilyet nem illik leírni!) közt a király :) Szóval letöltöd az Eclipse C-hez készült klónját:

http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers-includes-incubating-components/indigosr1

Én az Eclipse-t a MinGW-n belül, egy alkönyvtárba telepítettem és a munkakönyvtárát is itt hoztam létre, mert PHP-hoz is van egy Eclipse a gépemben és jobb a békesség.

7. így már minden adott a fejlesztéshez, de ha még Windows alá is szeretnél (vagy szinte bármilyen OS alá) készíteni ablakos alkalmazásokat, akkor telepítened kell a wxWidgets-et, ezt így lehet:

Letöltés: http://www.wxwidgets.org/downloads/

Ezt szintén a minGW könyvtárán belülre telepítettem, majd a Windows PATH értékei közé felvettem ezt: H:\MinGW\wxWidgets-2.9.2\include\wx\

Ezek után le kell fordítani a következő paranccsal:

 make -f makefile.gcc BUILD=release SHARED=0 UNICODE=1 USE_ODBC=1

Ezt én a H:\MinGW\wxWidgets-2.9.2\build\msw\ könyvtáron belül futtattam, nálad ez nyilván más lesz, de a lényeg, hogy itt van az egész wxWidgets makefile-ja, ezt kell lefordítani, ez el fog tartani egy ideig (nélam kb. 30 percig futott), ha elkészült, akkor a /lib könyvtár alatt létrejönnek a szükséges könyvtárak és fájlok - egészen pontosan a lib/gcc_lib alatt.

Ha ez készen van, akkor érdemes ellátogatni a /samples könyvtárba és ott lefordítani a példákat, a következő parancs jó lesz kezdésnek:

 make -f makefile.gcc BUILD=release SHARED=0 UNICODE=1 USE_ODBC=1

Tátva fog maradni a szánk, hogy milyen "csoda" dolgokra képes, cserébe azért majd nézzük meg a létrejött bináris fájlok méretét is ;--)

70 éves korában elhunyt Dennis Ritchie

2011-10-14T04:40:00.000-07:00

70 éves korában elhunyt Dennis Ritchie, ő találta ki a C programozási nyelvet és ő készítette el az első változatát, melyben azután Ken Thompson-al közösen újraírták a Unix operációs rendszert.

Symfony2 Security Audit

2011-10-07T14:43:00.000-07:00

Csak egy link:

http://symfony.com/blog/symfony2-security-audit

Drupal 7.8 - barátságos URL (Clean URLs) beállítása WampServer, Windows 7 környezetben

2011-09-17T05:11:00.000-07:00

A Drupal 7.8-ban nagyon egyszerűen lehet konfigurálni a "barátságos" URL-eket, de nálam alapbeállításokkal, Windows 7 és WampServer alatt nem működtek a rövid URL-ek, ezt a Drupal egy teljesen semmitmondó üzenettel hozta - illetve a gond éppen az volt, hogy nem hozta a tudtomra...egyszerűen csak nem működött és kész. :) Na mindegy, a lényeg, hogy ha ez a probléma, akkor a következőképpen lehet megoldani:

1. a C:\wamp\bin\apache\Apache2.2.17\conf\extra\httpd-vhosts.conf fájlba (értelemszerűen ez ott lesz ahová telepítetted) fel kell venni a Drupalnak egy új "virtual hostot":

 <VirtualHost *:80>  
      DocumentRoot "C:\wamp\www\drupal-7.8"  
      ServerName drupal_test  
      <Directory "C:\wamp\www\drupal-7.8">  
             Options None  
             AllowOverride All  
             Order deny,allow  
             Allow from all  
      </Directory>  
 </VirtualHost>

2. A C:\Windows\System32\drivers\etc\hosts fájlba fel kell venni egy sort:

 127.0.0.1    drupal_test

3. újra kell indítani a webszervert és máris megjelenik az áhított checkbox a "Clean URLs" menüben (persze a mod_rewrite Apache modulnak engedélyezve kell lennie, de gondolom ez nyilvánvaló. Példa egy tartalom URL-re, a fenti beállítások alapján: http://drupal_test/blablblabla-01

U.i.:
Egyébként, ha mindezek nincsenek beállítva, akkor a felhasználók mentésénél, ha szeretnél beállítani egy új szerepkört (Role), akkor a Drupal rossz URL-re fog irányítani, hibát kapsz, illetve egy nagy semmit, de a háttérben minden adat elmentődik. Ha a fentieket beállítod, akkor ez a hiba is "megjavul".

Linkgyűjtemény: XSS elleni védekezés (Protecting against XSS )

2011-09-13T05:12:00.000-07:00

Összegyűjtöttem a témáról néhány hasznos linket

Ami még hasznos lehet

Suhosin

http://www.hardened-php.net/suhosin/index.html

Htmlpurifier

http://htmlpurifier.org/

PHP Data Filtering

http://www.php.net/manual/en/book.filter.php

Python, Django, MySQL, PostgreSQL fejlesztői környezet Windows alatt

2011-09-07T06:43:00.000-07:00

Többféle megoldást próbáltam, nagyon sokáig külön-külön töltögettem le a szoftvereket, telepítgettem őket, majd következett az olykor "hajhullató" konfiguráció és finomhangolás. Ezt többször is végigcsináltam, ezek után próbálkoztam például a Wamp mellé beállítani a Python-t és a Django-t, ami sikerült is, de a MySQL használatba vétele mindig döcögős volt, különösen akkor ha a 2.7-es Python 64 bites verziójával próbálkoztam - amire nem a Django miatt volt szükségem, hiszen az a régebbi Pythonok alatt is működik, hanem csak úgy... :)

Nemrég találtam a BitNami DjangoStack nevű "minden az egyben" alkalmazást, mely a MySQL és az sqlite3 mellett, nagy örömömre felrakja a PostgeSQL-t is :). Dokumentáció itt: http://bitnami.org/files/stacks/djangostack/1.3-1/djangostack.pdf.
Most sajnos nincs időm bővebben írni róla, de amint lesz megpróbálok összehozni valamilyen értelmes leírást.

Symfony2 összképem - egyelőre :)

2011-08-29T02:35:00.000-07:00

Tegnap délután kicsit elgondolkodtam a Symfony2-ről és mivel ma Bank Holiday van és ma sem dolgozok, ezért túl sok időm maradt a gondolkodásra. :-) ?

Tegnap több Symfony2 bundle-t kipróbáltam, írtam is egy bejegyzést a SonataAdmin-ról, de ezen kívül megnéztem még a symfony2bundles.org-on található bundlek közül néhányat és a FOSUserBundle-t is teszteltem, erről is írtam nemrég.

Őszintén szólva hiányérzetem van a Symfony2-vel kapcsolatban. Maga az alaprendszer nagyon erős, szerintem jelenleg ez a legjobb PHP 5.3-as keretrendszer azok közül amiket én ismerek, de tény, hogy jelenleg a Symfony2-höz nincs olyan admin felületek készítésére alkalmas eszköz, amit én bátran mernék használni a projektjeimhez, a SonataAdmin sajnos a jelen állapotában és fejlesztési stílusában használhatatlan, mert triviális hibák maradnak benne (tegnap délután például befrissítettem a legújabb verzióra, azóta nem működik...és már nincs is kedvem keresgélni, hogy mi a kínja, mert épp eleget szívtam vele a "dokumentációja" miatt.) és csapnivaló a leírása, a Symfony beépített admin generátora pedig kicsit több a nullánál, űrlapok és alaplisták generálására jó - mivel más nincs. :) Ugyanígy nincs egy komolyan vehető beléptető, felhasználó kezelő rendszere bár a FOSUSerBundle jól használható, de néhány dolog hiányzik belőle (profil például).
De folytathatnám a sort, a legtöbb bundle kipróbálása után hiányérzetem volt - alapvető dolgok nem voltak megoldva bennük, dokumentáció szinte soha nincs, ellenben hibák és teljesítmény beli hiányosságok bőven akadtak...

Szóval, a Symfony2 nagyszerű lett. Csakhát...ez nem biztos, hogy elegendő, legalábbis nekem, szerintem lassítani és hátrálni kellene a fejlesztőknek és átgondolni, hogy a jelenlegi keretrendszer összességében mennyire használható, és elkészíteni egy valódi admin generátort, felhasználó-kezelő rendszert, egy média bundlet stb. - mert a jelenlegiek nem megfelelőek. Szerintem.

Azt hiszem, hogy mostanában újra többet fogok Djangozni, ma éjjel kicsit dolgoztam vele és felüdülés volt... :)

SonataAdminBundle - telepítés

2011-08-28T08:36:00.000-07:00

A SonataAdminBundle adminisztrációs felületek készítésére való bundle.

A SonataAdminBundle alapelvei számomra először nem voltak egyértelműek, eltértek a Symfony beépített, de egyelőre még nagyon egyszerű admin generátorától (mely hasonló a Symfony 1.x verziókban lévő admin generátorhoz - elgondolásában), a SonataAdmin egyelőre nem annyira kényelmes mint a beépített generátor - cserébe viszont többet tud annál, de manuálisan kell létrehozni az osztályokat, ez nem annyira bonyolult.

A blogbejegyzéshez két adatbázis táblát használtam, ugyanazokat melyeket az előző blogbejegyzésekben is, a létrehozásukról és az ORM model generálásáról minden leírást és adatot megtalálsz itt:

http://nyukapiszka.blogspot.com/2011/08/symfony-2-telepites-bundle-keszites.html

A SonataAdminBundle elgondolása az, hogy egy központi menüben gyűjtheted össze az admin felületeket (Dashboard), engem kicsit emlékeztetett a Django admin felületeire, de a Django kiforrottabb és gyorsabb is.

Öt lépésben a SonataAdmin használatáról

0. :) telepítened kell a SonataAdminBUndle-t.

1. a bundlen belül, ahol használni szeretnéd SonataAdmin-t, létre kell hoznod egy "Admin" nevű könyvtárat, ebbe a könyvtárba kerülnek majd az admin felületekkel kapcsolatos osztályok, melyek gyakorlatilag egy konfigurációt írnak le, mely alapján a listázás, a szerkesztő űrlap és a szűrési felület össze fog állni.

2. létre kell hoznod az admin kontrollereket, melyekben ha kell a későbbiekben bele tudsz nyúlni az admin felület működésébe.

3. az /app/config.yml-ben definiálnod kell a Sonata számára a szükséges szervizeket és a dashboard számára a kilistázandó admin felületeket - ez a legutolsó lépés sajnos sehol nincs megemlítve a hivatalos dokumentációban, ami szerintem nem túl szerencsés.

4. ürítened kell a cache-t, ami nem fontos, de nagyobb változások után szükség lehet rá.

És most részletesebben.

Telepítés

A telepítés annyiból áll, hogy le kell tölteni néhány bundlet, melyek kellenek a SoanataAdmin működéséhez, ezek a következők:
KnpMenuBundle
SonatajQueryBundle
SonataBluePrintBundle
SonataUserBundle és a FOSUserBundle - mindkettővel együtt tud működni az admin, én az utóbbit javaslom, a leírásomat erről itt olvashatod: http://nyukapiszka.blogspot.com/2011/08/symfony2-fosuserbundle.html ha ez fel van telepítve, akkor is fel kell telepíteni SonataUserBUndle-t, de az AppKernel.php-ban így kell engedélyezni:

 new Sonata\UserBundle\SonataUserBundle('FOSUserBundle'),

és így azonnal tudsz akár authentikálni is.

Én pontosan a leírásuk alapján telepítettem őket, egyszerűen a letöltésük után bemásoltam mindet az ajánlott könyvtárba. Itt olvashatsz egy másik telepítési útmutatót:

https://github.com/sonata-project/SonataAdminBundle/blob/master/Resources/doc/reference/installation.rst

Részlet az AppKernel.php-ból:

 new Sonata\jQueryBundle\SonatajQueryBundle(),  
 new Sonata\BluePrintBundle\SonataBluePrintBundle(),  
 new Sonata\AdminBundle\SonataAdminBundle(),  
 new Sonata\UserBundle\SonataUserBundle('FOSUserBundle'),  
 new Knp\Bundle\MenuBundle\KnpMenuBundle(),  
 new FOS\UserBundle\FOSUserBundle(),

Admin osztályok készítése

Ez sem túl bonyolult, tavasszal amikor először teszteltem a SonataAdmin-t még nem lehetett használni, tele volt hibákkal, most viszont egy dolgot kivéve mindent be tudtam állítani amit szerettem volna. (Azt, hogy JQuery UI-val működjön a felhasználói felület nem tudtam beállítani, sehol nem találtam leírást róla.)

Tehát először a Tesztceg\TesztBundle\Controller könyvtárba létre kell hozni az adminhoz tartozó kontrollereket:

CustomerAdminController.php

 <?php  
 namespace TesztCeg\TesztBundle\Controller;  
 use Sonata\AdminBundle\Controller\CRUDController as Controller;  
 class CustomerAdminController extends Controller  
 {  
 }

CustomerPaymentAdminController.php

 <?php  
 namespace TesztCeg\TesztBundle\Controller;  
 use Sonata\AdminBundle\Controller\CRUDController as Controller;  
 class CustomerPaymentAdminController extends Controller  
 {  
 }

Ha ez készen van, akkor ugyanitt létre kell hozni egy Admin nevű könyvtárat, amelybe az admin osztályok kerülnek:

CustomerAdmin.php:

 <?php  
 namespace TesztCeg\TesztBundle\Admin;  
 use Sonata\AdminBundle\Admin\Admin;  
 use Sonata\AdminBundle\Form\FormMapper;  
 use Sonata\AdminBundle\Datagrid\DatagridMapper;  
 use Sonata\AdminBundle\Datagrid\ListMapper;  
 use Sonata\AdminBundle\Show\ShowMapper;  
 class CustomerAdmin extends Admin  
 {  
   public function configureShowFields(ShowMapper $showMapper)  
   {  
     $showMapper  
       ->add('id')  
       ->add('customerName')  
     ;  
   }  
   public function configureFormFields(FormMapper $formMapper)  
   {  
     $formMapper  
       ->with('Customer')  
         ->add('customerName')  
       ->end()  
     ;  
   }  
   public function configureListFields(ListMapper $listMapper)  
   {  
     $listMapper  
       ->addIdentifier('id')  
       ->add('customerName')  
     ;  
   }  
   public function configureDatagridFilters(DatagridMapper $datagridMapper)  
   {  
     $datagridMapper  
       ->add('id')  
       ->add('customerName');  
   }  
 }

CustomerPaymentAdmin.php

 <?php  
 namespace TesztCeg\TesztBundle\Admin;  
 use Sonata\AdminBundle\Admin\Admin;  
 use Sonata\AdminBundle\Form\FormMapper;  
 use Sonata\AdminBundle\Datagrid\DatagridMapper;  
 use Sonata\AdminBundle\Datagrid\ListMapper;  
 use Sonata\AdminBundle\Show\ShowMapper;  
 class CustomerPaymentAdmin extends Admin  
 {  
      protected $maxPerPage = 10;  
   public function configureShowFields(ShowMapper $showMapper)  
   {  
     $showMapper  
       ->add('id')  
       ->add('amount')  
       ->add('payDate', null, array('type' => 'date'))  
       ->add('customer')  
     ;  
   }  
   public function configureFormFields(FormMapper $formMapper)  
   {  
     $formMapper  
       ->with('CustomerPayment')  
       ->add('amount')  
       ->add('payDate')  
       ->add('customer')  
       ->end()  
     ;  
   }  
   public function configureListFields(ListMapper $listMapper)  
   {  
     $listMapper  
       ->addIdentifier('id')  
       ->add('amount')  
       ->add('payDate')  
       ->add('customer')  
     ;  
   }  
   public function configureDatagridFilters(DatagridMapper $datagridMapper)  
   {  
     $datagridMapper  
       ->add('id')  
       ->add('amount')  
       ->add('pay_date')  
       ->add('customer');  
   }  
 }

Ezzel gyakorlatilag készen is vagyunk, még három apró lépés van hátra. Először fel kell venni a SonataAdmin routingjait, ebből csak kettő van, ezek átirányítják a routingolást a SonataAdmin bundle-ra, tehát a routing.yml fájlunkba ezt a két routingot kell felvenni:

 admin:  
   resource: '@SonataAdminBundle/Resources/config/routing/sonata_admin.xml'  
   prefix: /admin  
 _sonata_admin:  
   resource: .  
   type: sonata_admin  
   prefix: /admin

Ezek után a config.yml-ben regisztrálnunk kell az admin szervizeket:

 services:  
   tesztCeg.tesztbundle.admin.customer:  
    class: TesztCeg\TesztBundle\Admin\CustomerAdmin  
    tags:  
     - { name: sonata.admin, manager_type: orm, group: Customer, label: Customers }  
    arguments: [null, TesztCeg\TesztBundle\Entity\Customer, TesztCegTesztBundle:CustomerAdmin]  
   tesztCeg.tesztbundle.admin.customerpayment:  
    class: TesztCeg\TesztBundle\Admin\CustomerPaymentAdmin  
    tags:  
     - { name: sonata.admin, manager_type: orm, group: CustomerPayment, label: CutomersPayment }  
    arguments: [null, TesztCeg\TesztBundle\Entity\CustomerPayment, TesztCegTesztBundle:CustomerPaymentAdmin]

Ugyanide, a config.yml-be fel kell vinni azokat a szervizeket, amelyeket az admin Dashboard meg fog jeleníteni:

 sonata_admin:  
   dashboard_groups:  
     Customers:  
       label: Customers  
       items: [tesztceg.tesztbundle.admin.customer]    
     CustomerPayments:  
       label: Customer Payments  
       items: [tesztceg.tesztbundle.admin.customerpayment]

Ha mindez megvan, akkor már csak egy dolog van hátra, (ami kettő :)) - ki kell adni két Symfony parancsot:

Windowson:

 php app/console assets:install web

Linuxon:

  php app/console assets:install web --symlink

majd pedig frissíteni kell a cache-t:

 php app/console cache:clear

Ha mindezt végigcsináljuk, akkor elvileg működnie kellene az admin felületnek, a következő linken:

 http://localhost/Symfony/web/app_dev.php/admin/dashboard

Csatolok néhány képet az admin felületekről, remélem a leírás alapján másoknak is sikerül beállítani!

A SonataAdmin Dashboard-ja:

Lista lapozóval:

És egy egyszerű szerkesztő ablak:

Amint azt fentebb is írtam, a JQuery UI-t nem sikerült beállítanom - egyelőre :)

Viszont továbbra is azt gondolom, hogy nem biztos, hogy a SonataAdminBundle a jó választás, ugyanis teljesen követhetetlen a fejlesztése, mivel a dokumentációja nincs rendszeresen frissítve, nagyon sok dolog elavult benne, ami még a kisebbik gond... A nagyobb probléma az, hogy egészen egyszerűen nincs hozzá rendes, részletes leírás (ez régi, elavult, ez úgy van összecsapva és csak a legelemibb dolgok vannak benne, de azok is hiányosak...), ezért minden egyes funkciót nehéz megkeresni, mintha szándékosan nem akarnák a készítői, hogy használja valaki... Kár érte.

Symfony2 - FOSUserBundle a sfDoctrineGuardPlugin helyett

2011-08-23T06:24:00.000-07:00

A FOSUserBundle egy Symfony2-höz készült felhasználó kezelő, biztonsági bundle, mely kiválthatja az sfDoctrineGuardPlugin-t (vagy az sfGuardPlugin-t).

A FOSUserBundle telepítése viszonylag egyszerű, ha pontosan követed a telepítési útmutatót:

https://github.com/FriendsOfSymfony/FOSUserBundle/blob/master/Resources/doc/index.md

akkor működnie kell, legalábbis nekem elsőre működött :) ami nem éppen átlagos jelenség...

A telepítés végén ne felejtsd el az adatbázist frissíteni:

 php app/console doctrine:schema:update --force

Ezek után én a regisztrációs űrlapon keresztül hoztam létre egy felhasználót, de használhatók a parancssori utasítások is:

 php app/console fos:user:create testuser test@example.com p@ssword

A többi parancs leírását itt találod:

https://github.com/FriendsOfSymfony/FOSUserBundle/blob/master/Resources/doc/command_line_tools.md

A FOSUserBundle alap telepítés után eléggé fapados jelenségnek tűnt, de a forráskódját nézegetve az a benyomásom alakult ki, hogy nagyon szépen meg lett tervezve és szinte minden kibővíthető, kiterjeszthető benne.

Elég ha megnézzük, hogy milyen konfig beállításai vannak:

https://github.com/FriendsOfSymfony/FOSUserBundle/blob/master/Resources/doc/configuration_reference.md

Alap esetben nem csak Doctrine ORM-el, hanem CouchDB és MongoDB-vel is működik.

Én a telepítéséhez először létrehoztam egy új bundlet, ebben egy Entity könyvtárat, amelyben csináltam egy saját User osztályt, mely a FOSUserBundle BaseUser osztályából származik, ez a lépés nagyon fontos, de ezt írja is a legfelül belinkelt telepítési útmutató. Az én egyszerű User osztályom így néz ki:

 <?php  
 // src/Tesztceg/TesztUserBundle/Entity/User.php  
 namespace Tesztceg\TesztUserBundle\Entity;  
 use FOS\UserBundle\Entity\User as BaseUser;  
 use Doctrine\ORM\Mapping as ORM;  
 /**  
  * @ORM\Entity  
  * @ORM\Table(name="fos_user")  
  */  
 class User extends BaseUser  
 {  
   /**  
    * @ORM\Id  
    * @ORM\Column(type="integer")  
    * @ORM\GeneratedValue(strategy="AUTO")  
    */  
   protected $id;  
   public function __construct()  
   {  
     parent::__construct();  
     
   }  
 }

Egy Id mezőnek kötelezően lennie kell definiálva és persze a BaseUser-ből kell származnia.

Az adatok migrálásása sfGuard-ból: http://qpleple.com/migrate-from-sfguard-to-fosuserbundle/

Symfony2 - felhasználókezelés, biztonság (authentication, authorization)

2011-08-21T06:54:00.000-07:00

A Symfony2 technikailag másképpen közelíti meg a felhasználókezelést mint az elődei (lásd lentebb, hogy miért), ezen belül az authentikáció és authorizáció nagyon világosan elválik egymástól - itt álljunk is meg egy kicsit, hogy mit is jelent ez a két fogalom.

Az authorizáció engedélyezést jelent (Symfony-ban: URL-hoz való hozzáférést, objektumokhoz, metódusokhoz való hozzáférést, hozzáférés-vezérlési tábla (Access Control List - ACL) kezelést foglalja össze), melyet az authentikáció (Symfony-ban: belépési űrlap kezelést, HTTP authentikációt, HTTP digestet, X.509 certifikációt és/vagy tetszőleges authentikációs eljárás kidolgozását jelenti) előz meg.
Ezeknek a fogalmaknak természetesen semmi közük a Symfony2-höz, ezek minden beléptető rendszerben megtalálhatóak, kisebb-nagyobb mértékben felfedezhetjük ezeket a folyamatokat/fogalmakat még a legegyszerűbb rendszereken belül is, itt a hangsúly inkább azon van, hogy a Symfony2-vel kapunk egy átgondolt és szépen kivitelezett megvalósítást (pl. ACL), vagy a authentikációs providerek, melyekről érdemes lenne bővebben is írni..)

A Symfony2 felhasználó-kezelése annyiban különbözik a régebbi Symfony verzióktól, hogy elsősorban letisztultabb lett és nagyon világosan meg lettek különböztetve a konkrét lépések a biztonsággal kapcsolatos alrendszerekben (ez a régebbi Symfony verziókban is így volt, de nem nem volt ennyire letisztult) - másodsorban pedig elmondható, hogy mindez a Symfony2-vel párhuzamosan fejlesztett security component-nek köszönhető, mely teljesen független a Symfony2-től és bármely PHP-s projekthez használható, ezt a Symfony beépítve tartalmazza és itt találjuk: \vendor\symfony\src\Symfony\Component\Security.

Nézzünk egy egyszerű példát a HTTP authentikációra. A múltkori példámból indulok ki, az ott használt Tesztceg TesztBundle-jét fogom piszkálni.

A Bundle tartalmaz két, az admin generátorral készített listát, melyek közül a továbbiakban én a CustomerList-et fogom használni.

Tehát, ez az URL-em:

 http://localhost/Symfony/web/app_dev.php/customer/

Erre szeretnék egy HTTP autentikációt, ennek megvalósításához elég az app/config/security.yml-t egy kicsit átalakítnunk:

 security:  
   firewalls:  
     secured_area:  
       pattern:  ^/  
       anonymous: ~  
       http_basic:  
         realm: "Secured Area"  
   access_control:  
     - { path: ^/customer, roles: ROLE_ADMIN }  
   providers:  
     in_memory:  
       users:  
         admin: { password: banan, roles: 'ROLE_ADMIN' }  
   encoders:  
     Symfony\Component\Security\Core\User\User: plaintext

Az users részben tetszőleges számú felhasználót adhatunk meg, ez nagyon egyszerű, hatékony módszer, de általában inkább a saját beléptető űrlapot szoktuk használni.

Tehát, először készítek egy TestSecurity nevű bundlet, a TesztCeg névtéren belül, ehhez a generátort használtam.

 php app/console generate:bundle

Oké, ne így, hanem paraméterezzük fel...nálam, Windows alatt így néz ki a Security bundle generálása:

php app/console generate:bundle --namespace=Tesztceg/TesztSecurityBundle  --bundle-name=TesztSecurityBundle --no-interaction --structure=yes --dir C:\wamp\www\Symfony\src

Ez a parancs beregisztrálta a kernel.php-ba és a routingok közé és felvette az új bundlet.

Ha egy login űrlapot szeretnénk, akkor Symfony2 alatt szinte zavaróan sok lehetőségünk áll rendelkezésünkre, én most a legegyszerűbbet választottam, először is nézzük a security.yml fájlt, ami az /app/config könyvtárban található.

 security:  
   encoders:  
     Symfony\Component\Security\Core\User\User: plaintext  
   role_hierarchy:  
     ROLE_ADMIN:    ROLE_USER  
     ROLE_SUPER_ADMIN: [ROLE_USER, ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH]  
   providers:  
     in_memory:  
       users:  
         user: { password: userpass, roles: [ 'ROLE_USER' ] }  
         admin: { password: adminpass, roles: [ 'ROLE_ADMIN' ] }  
   firewalls:        
     in_memory:  
       pattern:  /.*  
       anonymous: true  
       logout: true  
       form_login:  
         login_path: /login  
         failure_path: /login_failure  
   access_control:  
      - { path: /customer/.*, role: ROLE_USER }   
      - { path: /.*, role: IS_AUTHENTICATED_ANONYMOUSLY }

Látható, hogy a bejelentkezéshez nem használtam adatbázist - illetve a felhasználók tárolására nem használtam, hanem egyszerűen csak a security.yml-ben felsoroltam a felhasználóimat, ide természetesen bármilyen adatbázis entitást fel tudtam volna venni adatszolgáltatónak (provider), a szolgáltató szerintem nem jó fogalom, én inkább adatfolyamnak nevezném, de ízlések és pofonok. (talnán mégiscsak a szolgáltató a jobb :))

Például így:

 security:  
   providers:  
     main:  
       entity: { class: Tesztceg\SecurityBundle\Entity\User, property: username }

A security.yml következő fontos része a firewalls, mely gyakorlatilag az authentikációt végzi, itt beállíthatjuk, hogy melyik oszály, melyik metódusa vezérelje a beléptetést, hová kerüljön (ha kell ilyen) a felhasználó ha nem sikerült belépnie, meghatározhatjuk, hogy legyen-e logout és még nagyon sok egyéb dolgot is beállíthatunk, ezeket ajánlom elolvasásra:

http://symfony.com/doc/2.0/reference/configuration/security.html

http://symfony.com/doc/2.0/cookbook/security/form_login.html

http://symfony.com/doc/2.0/cookbook/security/force_https.html

A következő rész az access_control, ez gyakorlatilag az authorizáció, itt például beállíthatjuk, hogy melyik URL-ek milyen láthatósággal rendelkezzenek, a példában a customer URL-t lezártam és beléptetéshez kötöttem, így az admin felületek ellenőrzése nagyon egyszerűvé válik és egy helyről beállítható minden.

A kontrollerem a következő volt:

 <?php  
 namespace Tesztceg\TesztSecurityBundle\Controller;  
 use Symfony\Bundle\FrameworkBundle\Controller\Controller;  
 use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;  
 use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;  
 use Symfony\Component\Security\Core\SecurityContext;  
 class DefaultController extends Controller  
 {  
   /**  
    * @Route("/hello/{name}")  
    * @Template()  
    */  
   public function indexAction($name)  
   {  
     return array('name' => $name);  
   }  
    /**  
    * @Route("/login")  
    * @Template()  
    */  
      public function loginAction()  
   {  
     $request = $this->getRequest();  
     $session = $request->getSession();  
     if ($request->attributes->has(SecurityContext::AUTHENTICATION_ERROR)) {  
       $error = $request->attributes->get(SecurityContext::AUTHENTICATION_ERROR);  
     } else {  
       $error = $session->get(SecurityContext::AUTHENTICATION_ERROR);  
     }  
     return $this->render('TesztSecurityBundle:Default:login.html.twig', array(  
       'last_username' => $session->get(SecurityContext::LAST_USERNAME),  
       'error'     => $error,  
     ));  
   }  
    /**  
    * @Route("/login_failure")  
    * @Template()  
    */  
      public function loginFailureAction()  
   {  
     $request = $this->getRequest();  
     $session = $request->getSession();  
           return $this->render('TesztSecurityBundle:Default:index.html.twig', array(  
                'name' => $session->get(SecurityContext::LAST_USERNAME),  
           ));  
   }    
    /**  
    * @Route("/logout")  
    * @Template()  
    */  
      public function logoutAction()  
   {  
     $request = $this->getRequest();  
     $session = $request->getSession();  
           $session->clear();  
   }    
 }

A logout :) nagyon primitívre sikeredett, de példának szerintem megfelel. A legalapvetőbb dolgok ezek voltak, ennyivel már össze lehet állítani egy egyszerű beléptetést.

Phraw keretrendszer

2011-08-20T23:51:00.000-07:00

A múltkoriban írtam egy teljesen szubjektív blogbejegyzést a kicsi, pehelysúlyú PHP keretrendszerekről és sok visszajelzést kaptam, először a Silex-el kapcsolatban, majd a Phraw-al kapcsolatban is.

A Phraw alap verziója, mely csak a keretrendszert és egy egyszerű példát tartalmaz számomra továbbra sem indult el, a leírása sem volt világos - végigcsináltam a step-by-step súgót, de a végén nem történt semmi, valószínűleg az index.php nem került a megfelelő helyre (ugyanis nem derült ki a leírásból, hogy hová kellene bemásolnom) és telepítenem kellett volna a Smarty-t is, ezért erről továbbra is ugyanaz a véleményem ami az eredeti cikkben volt, de...

...emiatt nem írtam volna újra, az ok, amiért írtam a Phraw-ról az az, hogy letölthető a hivatalos oldalról egy ORM-el és sablonkezelővel is megtámogatott változat (Phraw + Smarty + Idiorm + Paris) és ez tetszett.
Ezt a disztribúciót múltkor nem teszteltem, mert észre sem vettem, hogy létezik és ugyaninnen letölthető még két másik változat is - az egyik a Smarty-t, a másik a RainTPL-t tartalmazza.

Az Idirom és a Paris beépítése nagyon jó ötlet volt, ezekkel együtt a Phraw egy tényleg jól használható, mini keretrendszer, mely valóban gyorsan és kis erőforrás igénnyel működik.

Íme egy kontroller:

 <?php  
 /* Put here your views. */  
 # Load the databse models  
 require_once('./resources/models.php');  
 /**  
  * View sample.  
  *  
  * @param object $phraw Phraw instance  
  * @param object $smarty Smarty instance  
  */  
 function home($phraw, $smarty) {  
   # Quering the database via the ORM  
   $users = ORM::for_table('user')->find_many();  
   # Quering the database via the models  
   $tizio = Model::factory('User')->where('name', 'Tizio')->find_one();  
   $tizio_profile = $tizio->profile()->find_one();  
   $smarty->assign(array(  
     'version' => $phraw->version,  
     'users' => $users,  
     'tizio' => $tizio,  
     'tizio_profile' => $tizio_profile,  
   ));  
   $smarty->display('dynamicpages/home.html');  
 }  
 ?>

Tehát a Phraw-nak létezik gyorsan telepíthető és működésre bírható változata, lehetséges, hogy ennek kellene lennie a fő verziónak... :)Ha valakit mélyebben is érdekel, akkor tesztelgesse.

LAMPSecurityToolkit - hasznos eszköz a LAMP eszközeink teszteléséhez

2011-08-14T18:20:00.000-07:00

A LAMPSecurityToolkit egy nagyon friss fejlesztésű eszköz, szerintem óránként változik rajta valami, ezért egyelőre csak a létéről szerettem volna írni, mert nagyon tetszett az alapötlete és a kivitelezése is.

Telepítés

Le kell tölteni és bemásolni egy könyvtárba :) Ennyi.

Amit tud és amit nem - egyelőre

A "LAMPSecurityToolkit" elnevezés szerintem kicsit önkorlátozó, főleg ha ilyen lelkesen fejlesztik tovább, ugyanis előfordulhat, hogy a Windows specifikus beállításokat is fel kell majd ismernie és az ugye már WAMP :) Szerintem a PHPSecurityToolkit elnevezés ezért szerencsésebb lett volna, de ez részletkérdés.

A LAMPSecurityToolkit logikusan épül fel, a kezelőfelületén be lehet állítani, hogy milyen tesztek fussanak le - erről szerintem nem érdemes ennél többet írni, mert ha valaki elindítja, akkor azonnal nyilvánvalóvá válik minden beállítási lehetőség.

Ami nekem leginkább hiányzott, hogy nincs pontosan vezetve, hogy melyik PHP függvények vannak ellenőrizve - viszont minden teszthez van leírás, de az nem egy valódi log, hanem inkább csak egy támpont.

Nem tudtam például eldönteni, hogy a bináris fájlok indítására szolgáló ellenőrzés nézi-e a PHP-s dl() függvényt is - nyilván nem, mert egyrészt nem arra szolgál, hiszen ez csak a PHP bővítményeinek dinamikus betöltésére jó és a dokumentációban fel is vannak sorolva, hogy melyik függvényeket ellenőrzi a fent említett teszt, de lehetne valamilyen jelzés, hogy éppen mit ellenőriz, vagy egy nagyon részletes log fájl, amiben tételesen le van írva minden egyes teszt, minden egyes függvény hívási kísérlete és annak eredménye: PHP-s hibajelzéssel, saját megjegyzéssel együtt.

Ami még hiányzott az a CURL ellenőrzése, a proc_open() és proc_close() ellenőrzése, a show_source() ellenőrzése, a symlink() ellenőrzése (ez pl. Windows alatt nincs).

Érdemes kipróbálni, sokat segíthet egy ilyen eszköz lefuttatása és sem erőfeszítésbe, sem időbe nem kerül.

Webfejlesztőknek szóló, egyszerűsített HTML5 specifikáció

2011-08-12T23:08:00.000-07:00

Webfejlesztőknek szóló, egyszerűsített HTML5 specifikációt adott ki a W3C, amely az eredeti specifikációra épül, de átláthatóbbá tették azt, érdemes átolvasni, itt található:

http://www.w3.org/TR/2011/WD-html5-author-20110809/

Talán ez segíti a HTML5 megértését azok számára is, akik nem szeretnek specifikációkat olvasgatni :)

Sphinx telepítése Windows 7 alá

2011-08-12T04:32:00.000-07:00

A Sphinx egy nyílt forráskódú keresőszerver, nagyon jól együttműködik a MySQL-el és a PostgreSQL-el, a megadott feltételek alapján képes leindexelni a tartalmakat, természetesen van saját API-ja, mellyel akár PHP-ból, Java-ból vagy Ruby-ból is könnyen lehet programozni.

Leggyakrabban Linux alatt szokták használni, de én Windows 7 alatt próbáltam beüzemelni, de elsőre hibaüzenettel indult:

 Installing service...  
 FATAL: OpenSCManager() failed: code=5, error=Access is denied.

A megoldás annyi, hogy indítasz egy parancssort rendeszergazdaként (elég ha az Asztalon készítesz egy prancsikont a cmd.exe-re, majd arra kattintasz jobb egérgombbal és a menüben a "Run as administrator"-al indítod".
Ezek után, ha ebből az admin parancssorból indítod, akkor elvileg minden rendben lesz; én a következő parancssal indítottam:

 C:\Windows\system32>H:\Sphinx\bin\searchd --install --config H:\SPHINX\sphinx.co  
 nf --servicename SphinxSearch

És ennyi :)

Node.js - alkalmazás indítása Windows alatt (execute child process)

2011-08-10T04:27:00.000-07:00

Múlt héten írtam a Windows-os node.js-ről, azóta javították azt a hibát amibe akkor én is "belefutottam" és a fórumok alapján sokan mások is, a node.js changelog szerint a 2011.08.01, Version 0.5.3-ba belekerült a Windows: improvements, child_process támogatás. Ezt véletlenül vettem észre és gondoltam kipróbálom, és valóban tökéletesen működik, tehát ha például a DIR parancsot szeretném futtatni, akkor most már lefut Windows alatt a következő kód:

 var util  = require('util'),  
   exec = require('child_process').exec,  
   child;  
 child = exec('dir *.*',   
  function (error, stdout, stderr) {  
   console.log('stdout: ' + stdout);  
   console.log('stderr: ' + stderr);  
   if (error !== null) {  
    console.log('exec error: ' + error);  
   }  
 });

Ha pedig egy ablakos alkalmazást, pl. a notepadot (:)) szeretném indítani, akkor így:

 ar util  = require('util'),  
 spawn = require('child_process').spawn,  
 ls  = spawn('notepad.exe', ['bigyo.txt']);

ebben látható, hogy paramétert is egyszerű átadni.

Ezek a változások a 0.5.3-as (unstable) node.js-ben találhatóak meg, ez azért jó, mert így most a node.js tökéletesnek tűnik arra, hogy Windows alatt is bármire használni lehessen, pl. én mindenféle karbantartó szkripteket tervezek benne készíteni.

Silex és Twig telepítése

2011-08-09T06:11:00.000-07:00

Tegnap este még keresgéltem, megnéztem három különféle keretrendszert, de egyik sem tetszett, úgy tűnik, hogy a Silex az ami teljesíti azokat a követelményeket amiket pehelysúlyúnak lehet nevezni - kicsi, gyors és egyszerű telepíteni (kivéve, ha nem rontod el elsőre, mint én...).

A telepítés

Letöltöd a phar fájlt: http://silex-project.org/get/silex.phar

Bemásolod egy könyvtárba, létrehozol egy index.php, kezdetnek mondjuk így:

 require_once __DIR__.'/silex.phar';  
 $app = new Silex\Application();  
 $app->get('/hello/{name}', function ($name) use ($app) {  
   return 'Hello '.$app->escape($name);  
 });  
 $app->run();

Majd csinálni kell egy .htaccess fájlt:

 <IfModule mod_rewrite.c>  
   Options -MultiViews  
   RewriteEngine On  
   #RewriteBase /path/to/app  
   RewriteCond %{REQUEST_FILENAME} !-f  
   RewriteRule ^(.*)$ index.php [QSA,L]  
 </IfModule>

És működik - ami pedig a lényeg: iszonyú gyors és nincs benne semmi felesleges sallang.

Persze, nem túlságosan nehéz telepíteni alá bővítményeket (létrehozva ezzel a "sallangokat" :), én például felraktam a Twig sablonkezelőt, mert kíváncsi voltam arra, hogy mennyire egyszerű beállítani.

Twig telepítése

1. csinálsz egy vendor nevű könyvtárat
2. ezen belül a twig könyvtárba belemásolod a twig-et, a twig-extensions könyvtárba pedig a twig bővítményeit (a legegyszerűbb ha a Symfony2 vendor könyvtárából átmásolod ide őket, pont úgy ahogyan ott vannak)
3. az index.php-ban bekonfigurálod:

 <?php  
 require_once __DIR__.'/silex.phar';  
 $app = new Silex\Application();  
 $app->register(new Silex\Extension\TwigExtension(), array(  
   'twig.path'    => __DIR__.'/views',  
   'twig.class_path' => __DIR__.'/vendor/twig/lib',  
 ));  
 $app->get('/hello/{name}', function ($name) use ($app) {  
   return $app['twig']->render('hello.twig', array(  
     'name' => $name,  
   ));  
 });  
 $app->run();

Ezek után már csak egy "views" nevű könyvtárat kell csinálni, amibe a jelen példához egy hello.twig fájlt kell létrehozni, melynek a tartalma a Twig sablonkezelő nyelvéhez alkalmazkodva a következő lesz:

 Hello {{ name }}!

És ennyi, így is nagyon gyors, de Twig nélkül alig lassabb a natúr PHP-nál.

PHP pehelysúlyú keretrendszerek - körkép

2011-08-08T03:20:00.000-07:00

Tegnap utánanéztem annak, hogy milyen pehelysúlyú PHP keretrendszerek vannak és ezek mennyire használhatóak.

Mikor beírtam a keresőbe, hogy "micro php framework", nagyon sokfélét találtam, de később kiderült, hogy korai volt ez az öröm.

Először az alábbi keretrendszereket teszteltem:

limondade.php

microMVC

Slim

GluePHP

Phraw

...és ezek közül egyik sem működött. :-) Komolyan nem...annyira nem, hogy vagy el sem indultak, vagy a hozzájuk mellékelt demók ciki hibaüzeneteket dobtak; vagy - és ez volt a legnagyobb sokk számomra: belenéztem a forráskódjaikba - ezt nem kellett volna... (nem mindegyikre érvényes ez a megállapítás, de néhányra igen) mellékesen pedig se használható dokumentációt, se értelmes leírást, se semmit nem találtam hozzájuk (mindegyikhez egy-két oldalas leírás volt, amiben azt ecsetelték mennyire jó, gyors és egyszerű az adott keretrendszer), de sajnos ez nem bizonyult igaznak.

A fentiek közül a limonade.php volt az egyetlen amelyik hajlandó volt elindulni, de bár ne tette volna...a mellékelt példaprogramok ugyanis hibákat dobáltak, különféle notice-k formájában, majd mikor ezeket javítottam, akkor ilyeneket:

 ( ! ) Parse error: syntax error, unexpected $end in C:\wamp\www\limonade\examples\example01\index.php on line 125

a dokumentációkban szinte semmi.
Hozzáteszem, hogy ha egyenként 1-2 órát rájuk szánok biztosan kicsiszolhattam volna belőlük valami élet-félét, de pont olyan keretrendszert kerestem, amelyet ha bemásolok egy könyvtárba, megnézek 2-3 példaprogramot, akkor azután tudom használni - tehát igazi pehelysúlyút kerestem.

Nem tudom mi az oka ennek a sok hibának.

Talán a mennyiség egyre inkább a minőség rovására megy, azért még keresgélek és majd megírom ha találtam említésre méltó PHP Micro Frameworkot.

...délután folytattam a tesztelést/keresgélést és újabb keretrendszereket találtam. Az első amit megnéztem a tekuna. Az eredmény meglepetést okozott, ugyanis a tekuna működött! Sőt írok is róla kicsit.

Tekuna

Hivatalos oldal: http://code.google.com/p/tekuna/
Dokumentációs sajnos nincs hozzá, de egy könyvtárba bemásolva azonnal működött. Minimum 5.3-as PHP kell neki(nem tudom miért, mert névtereket nem láttam benne).
A Tekunában az tetszett leginkább, hogy a többnyelvűség a rendszer szerves részét képezi, a könyvtárstruktúrája átlátható, a fragments könyvtárban kaptak például helyet a nyelvesített sablonfájolok - egyetlen hibája, hogy szerintem már nem fejlesztik... De legalább működött :).

A következő keretrendszer amit ki szerettem volna próbálni a PHP Fat-Free Framework volt, de nem indult el, illetve "Error 101 (net::ERR_CONNECTION_RESET): The connection was reset." hibát okozott... Szóval, a sorsa a törlés lett.

És itt abba is hagytam, bevallom, hogy elegem lett, őszintén szólva azt hittem, hogy ennél azért jobb a helyzet, tömören ennyi a véleményem, nem akarok belemenni mélyebben, legyen elegendő ennyi... Ha valaki tud valami jó, működő és kicsi keretrendszert, akkor írjon!

Helyreigazítás:

A Silex-et sikerült működésre bírnom, a gond az volt, hogy én a teljes forráskódját töltöttem le és nem a .phar-os változatot teszteltem, és azzal valóban gond nélkül működik és nem is akármilyen sebességet produkál...

Szicsunak egy képrenyőfotó:

És köszi, hogy szóltál!