Ep2 Developers Community - Alle forums

tekstuele formule omzetten naar een echte formule

Thu, 02 Sep 2010 08:58:09 +0000

Hoi hoi,

Mijn tweede post en meteen een vraag.

In mijn programma moet ik formules testen met waardes die gebruikers intoetsen. Zowel de formules als de waardes liggen niet vast, dus worden op regels ingevoerd. Hele simpele formule:

"1+2/2*3"

Dit is dus een string, hoe vorm ik dat om zodat het een waarde oplevert.

groetjes,

Marco

Hoi

Thu, 02 Sep 2010 08:49:42 +0000

Hoi,

Mijn naam is Marco de Boer en ben generiek programmeur, dat wil zeggen; ik kan in bijna alle mainstream talen werken, maar ben nergens een echte specialist in.
Op dit moment aan het werk in Velsen Noord als Java/J2EE en C# programmeur.

Begonnen, zoals velen, op de Commodore 64 in basic, overgestapt op de Apple Macintosh en Turbo Pascal (1.0 toen nog). Daarna Atari ST (C en basic, pascal) en Amiga ©

Apple is nog steeds mijn platform(mijn eerste Apple trouwens ook) maar heb geen voorkeur voor een programmeertaal.

variabel aantal POST velden serializen

Tue, 31 Aug 2010 15:30:05 +0000

Hey, een website waar ik aan werk ontvangt ingevulde contactformulieren met elk verschillende POST-velden. Omdat de velden vaak verschillen kan ik niet voor elk veld een tabelkolom maken. Bijv:

Citaat:[formulier1]
Naam: Piet
Leeftijd: 23
Mening: Ik ben tevreden etc blaat

[formulier2]
Type: qwerty Tshirt
Kleur: groen
Maat: XS
Aantal: 2

De methode die ik eerst in geachten had is om alle POST waarden als HTML in een TEXTkolom op te slaan, en deze weer te geven wanneer gevraagd. Dit is wel sneller, maar zeker niet flexibel. Bovendien gaat de waarde van de data verloren omdat het wordt samengevoegd tot één tekstveld in de tabel.

Vandaar dat ik van plan ben om de POST variabelen te serializen, zodat er meer gedaan kan worden met de variabele POSTwaarden. De admin kan dan aangeven allleen de emailadressen op te vragen, of alleen het naamveld+adresveld, etc.

Ik heb hierbij een aantal vragen. Is serializing niet een heel intensieve opdracht voor de server? Als een admin 3 velden van een formulier met normaal 10 velden opvraagt, en er zijn 300 dbase entries, kost dat niet teveel resources om alle opgevraagde records ook nog eens te unserializen?

En bovendien, welke velden zou ik serializen? Ik zit te denken tussen een splitsing tussen vaste velden (worden altijd gebruikt) en variabele velden (zijn form specifiek), bijvoorbeeld:

Citaat:itemid, referer, subject, time, formfields_serialized
1, "http://bla.nl", "onderwerp hier", tijd, {naam:piet,leeftijd:23,mening:bla}

Wat vinden jullie? Is serializing goed te gebruiken? En is de splitsing tussen vaste en variabele velden een goeie verdeling?

Ledensysteem Zonder SQL en Mysql

Sat, 28 Aug 2010 20:54:15 +0000

Hallo..

Ik heb een ledensysteem gemaakt. alleen nu wil ik als ik ingelogt ben de leden laten zien in het menu.
+ dat ik een pagina kan beveligen zodat je na het inloggen pas de pagina kan zien.

Ik heb gewerkt met
$gebruikersnaam array()
$gebruikersnaam[1] = 'admin';

Graag kunnen jullie mijn helpen hieronder code

PHP-code:

session_start();
error_reporting(E_ALL);
//Je gebruikersnamen
$gebruikersnaam = array();
$gebruikersnaam[1] = "Admin";
$gebruikersnaam[2] = "xxxx";
$gebruikersnaam[3] = "xxxx";
$gebruikersnaam[4] = "xxxx";
$gebruikersnaam[5] = "xxxx";

//Je wachtwoorden
$wachtwoord = array();
$wachtwoord[1] = "Hierhetwachtwoord";
$wachtwoord[2] = "xxxxx";
$wachtwoord[3] = "xxxxx";
$wachtwoord[4] = "xxxx";
$wachtwoord[5] = "xxxx";


//Wijzig hier verder niets als je er geen verstand van hebt
if( !isset($_GET["actie"])) {
 $_GET["actie"] = "";
} 
if( !isset($_SESSION["Admin"])) {
 $_SESSION["Admin"] = "";
}
function inArrayPlusKey($value,$array){
    if(in_array($value,$array)){
        for($i=0; $i<count($array); $i++){
            if($array[$i] == $value){
                return $i;
            }
        }
    }
    else{
        return false;
    }
}
function check_online() {
 if($_SESSION["Admin"] != "") {
  return 1;
 }
 else {
  return 0;
 }
}

//Html + Codes
echo ' ';
echo ' ';
echo 'Xonex - Website Op Maat ';
echo ' ';
echo ' ';
echo ''; 
echo '';


// Kijk of er ingelogd moet worden
if(isset($_POST["login"])){
    if($_POST["wachtwoord"] == $wachtwoord[inArrayPlusKey($_POST["gebruikersnaam"],$gebruikersnaam)]){ // Kijk of gebruikersnaam met wachtwoord overeen komen
        $_SESSION["Admin"] = $_POST["gebruikersnaam"]; //zet de sessie klaar
        echo 'U Wordt Ingelogt..';
        echo '
';
        echo 'Ga verder';
    }
    else{
        echo 'U Heeft Waarschijnlijk Een Verkeer Wachtwoord Ingevoert Of Een Verkeerde Gebruikersnaam';
    }
}
else{
         //als je wel bent ingelogd
  if(check_online() == 1) {
    
    //Wijzig dit om te zien wat er moet verschijnen wat alleen de gebruikers mogen zien als ze zijn ingelogd.
    
  echo ''; 
    echo '  ';
    echo '    Leden
Profiel
Bestelling
Factuur
';    
    echo '  ';
    echo '';
    echo '';
    echo '  ';
    echo '    Uitloggen';    
    echo '  ';
    echo '';
    if($_GET["actie"] == "Uitloggen") {
     session_destroy();
     echo '
Je bent uitgelogd, Klik hier om terug te gaan
';
    }
    }
    else {
    //Anders een leuk inlog ding
    echo '';
    echo ' ';
    echo '  ';
    echo '    Gebruikersnaam';
    echo '    ';
    echo '  ';
    echo '  ';
    echo '    Wachtwoord';
    echo '    ';
    echo '  ';
    echo '  ';
    echo '     ';
    echo '    ';
    echo '  ';
    echo ' ';
    echo '';
    }
}

?>

Externe harde schijf

Sat, 28 Aug 2010 18:22:36 +0000

Hey allemaal,

Ik ben nu op zoek naar een nieuwe externe harde schijf, eentje zonder externe voeding. Uiteindelijk is mn keuze gevallen op de LaCie Rikiki of LaCie Starck gevallen. Eerstgenoemde is wel echt een stukje kleiner en lichter, maar bij de tweede heb je geen problemen met vergeten van usb-kabel ed, is ook wel erg makkelijk.
Waar zouden jullie voor gaan? Ik ben momenteel in dilemma en weet niet echt wat ik moet kiezen... Andere schijf kan natuurlijk ook nog, maar zou niet weten welke dan, had deze alleen nog over gehouden.
Hopelijk kunnen jullie me met mn dilemma helpen.

Hard Disk formatteren

Sat, 28 Aug 2010 10:06:28 +0000

Ik probeerde gisteren mijn harddisk (KIOSK 1TB) te formatteren, maar helaas is dit niet gelukt.
Zo heb ik geprobeerd het te formatteren: rechtermuisknop->formatteren
Dit zijn de settings die ik gebruikte:
Capaciteit:
-931 GB
Bestandssysteem:
-NTFS
Clustergrootte:
-Standaard toegewezen grootte
Volumenaam:
-KIOSK 1TB
snelformatteren: niet aangevinkt
compressie inschakelen: niet aangevinkt

Alles verliep vlot, maar na een uurtje of 4 krijg ik de error:
"kan het formatteren niet beïndigen".
Nu heb ik dus een harddisk die niks kan. Weet iemand hoe ik hem nu wel juist kan formatteren?

Nokia N900 meerdere agenda's synchroniseren

Fri, 27 Aug 2010 19:20:40 +0000

Hey allemaal,

Ik heb dus de Nokia N900, waarbij ik nu al prima 1 kalender gesynchroniseerd heb met mn exchange server. Prima allemaal, maar nu heb ik nog een tweede agenda die ik ook wil synchroniseren. Heb net al wat gezocht, maar ik kon nog niks vinden wat me echt goed genoeg op weg helpt, behalve dan dat het standaard gezien niet mogelijk is...
Iemand ideetje?

Anjo

Jquery > verschillende elementen binnen een LI benaderen

Thu, 26 Aug 2010 13:48:23 +0000

Hey iedereen, ik heb de volgende opstelling:

Code:







Veld 1: 


Veld 2: 


Veld 3: 










Veld 1: 


Veld 2: 


Veld 3:

Elk LI-element bevat dus een form met daarin 3 tekstvelden en een submit-button. Nu wil ik dat ik een handler kan toevoegen die voor elke button geldt, maar waarbij elke button wel zijn 'eigen' text-elementen gebruikt bij het $.POST functie:

Code:

$(document).ready(function() {

    $('.verzenden').live("click",function (event) {

        $.post("/?page=ajax_setvraag", { 

                                     'vraag1': .verzenden.PARENT_LI_ID.veld1.val()

                                     'vraag2': .verzenden.PARENT_LI_ID.veld2.val()

                                     'vraag3': .verzenden.PARENT_LI_ID.veld3.val()

                            },

            function(data){

                alert('test' + data);

            });    

    });

});

Ik had het al eerder 'opgelost' door elk text-element als id "vraag1_1234" etc mee te geven, maar omdat het een ajax/php combinatie is loop ik nu tegen de problemen aan, en wil ik beide talen beter van elkaar scheiden.

Hoop dat ik mn vraag een beetje duidelijk heb uit kunnen leggen

mysql: MATCH AGAINST niet betrouwbaar?

Wed, 25 Aug 2010 14:42:43 +0000

Hoi,

zoals sommigen van jullie al gelezen hadden in mijn vorige topic ben ik dus geen database expert en stuit nu op het volgende.

Ik heb weer de tabel articles_items en deze bevat een FULLTEXT INDEX op het veld `tags`. Nu worden die tags altijd met kommas of spaties van elkaar gescheiden opgeslagen (maakt niks uit, toch?)

Als ik bijv in het veld tags het volgende invul:

bloed geur schaafwond

en zoek op schaafwond word er niks gevonden maar zoek ik op bloed dan vind die het artikel wel...
Zelfde geld exact voor bijv. het veld author_name die ook een FULLTEXT INDEX heeft, voorste letters/woord werk(t)(en) perfect maar laatste deel van de auteur naam zoeken ho maar.

Even een concreet voorbeeld waar het probleem mee ontdekt is dat de auteur naam was R van de Most en als er dan op Most word gezocht krijg ik 0 results op de volgende query:

Code:

SELECT

    `y`.`id` AS y_id,

    `y`.`id_articles_categories` AS y_id_articles_categories,

    `y`.`id_security_boxes` AS y_id_security_boxes,

    `y`.`title` AS y_title,

    `y`.`author_name` AS y_author_name,

    `y`.`publish_date` AS y_publish_date,

    `y`.`tags` AS y_tags,

    `y`.`readCount` AS y_readCount,

    `y`.`id_articles_types` AS y_id_articles_types,

    `y`.`active` AS y_active,

    `y`.`declined` AS y_declined,

    `y`.`content` AS y_content,

    `y`.`date_creation` AS y_date_creation,

    `y`.`date_last_edit` AS y_date_last_edit,

    `a`.`id_security_boxes` AS a_id_security_boxes,

    `a`.`id_users_accounts` AS a_id_users_accounts,

    `a`.`id_security_groups` AS a_id_security_groups,

    `a`.`create` AS a_create,

    `a`.`read` AS a_read,

    `a`.`update` AS a_update,

    `a`.`delete` AS a_delete,

    `a`.`admin` AS a_admin,

    `z`.`id` AS z_id,

    `z`.`id_security_boxes` AS z_id_security_boxes,

    `z`.`id_security_control` AS z_id_security_control,

    `z`.`username` AS z_username,

    `z`.`password` AS z_password,

    `z`.`email` AS z_email,

    `z`.`activated` AS z_activated,

    `z`.`deleted` AS z_deleted,

    `z`.`signup_date` AS z_signup_date,

    `z`.`last_active` AS z_last_active,

    `z`.`last_location` AS z_last_location,

    `d`.`id` AS d_id,

    `d`.`id_security_boxes` AS d_id_security_boxes,

    `d`.`title` AS d_title,

    `d`.`article_class` AS d_article_class,

    `d`.`form_class` AS d_form_class,

    `b`.`name` AS b_name,

    `b`.`id` AS b_id,

    `b`.`lft` AS b_lft,

    `b`.`rgt` AS b_rgt,

    `b`.`id_security_boxes` AS b_id_security_boxes,

    `b`.`rgt` AS b_rgt,

    `b`.`lft` AS b_lft,

    `b`.`id` AS b_id,

    `c`.`id_security_boxes` AS c_id_security_boxes,

    `c`.`id_users_accounts` AS c_id_users_accounts,

    `c`.`id_security_groups` AS c_id_security_groups,

    `c`.`create` AS c_create,

    `c`.`read` AS c_read,

    `c`.`update` AS c_update,

    `c`.`delete` AS c_delete,

    `c`.`admin` AS c_admin

FROM

    articles_items y 

            INNER JOIN

            (

              SELECT

                `acl`.`id_security_boxes` AS `id_security_boxes`,

                `acl`.`id_users_accounts` AS `id_users_accounts`,

                `acl`.`id_security_groups` AS `id_security_groups`,

                MAX(`acl`.`create`) AS `create`,

                  MAX(`acl`.`read`) AS `read`,

                MAX(`acl`.`update`) AS `update`,

                  MAX(`acl`.`delete`) AS `delete`,

                MAX(`acl`.`admin`) AS `admin`

              FROM

                  `security_acl` AS `acl`

              WHERE

                `acl`.`id_users_accounts` = 2 OR `acl`.`id_security_groups` IN (9,4,3,1)

              GROUP BY  `acl`.`id_security_boxes`

            ) AS `a` 

INNER JOIN

    users_accounts z

ON

    z.id = y.id_users_accounts 

INNER JOIN

    articles_types d

ON

    d.id = y.id_articles_types 

INNER JOIN

    articles_categories b

ON

    b.id = y.id_articles_categories 

            INNER JOIN

            (

              SELECT

                `acl`.`id_security_boxes` AS `id_security_boxes`,

                `acl`.`id_users_accounts` AS `id_users_accounts`,

                `acl`.`id_security_groups` AS `id_security_groups`,

                MAX(`acl`.`create`) AS `create`,

                  MAX(`acl`.`read`) AS `read`,

                MAX(`acl`.`update`) AS `update`,

                  MAX(`acl`.`delete`) AS `delete`,

                MAX(`acl`.`admin`) AS `admin`

              FROM

                  `security_acl` AS `acl`

              WHERE

                `acl`.`id_users_accounts` = 2 OR `acl`.`id_security_groups` IN (9,4,3,1)

              GROUP BY  `acl`.`id_security_boxes`

            ) AS `c`

WHERE

     (

                MATCH(y.author_name) AGAINST ('*most*' IN BOOLEAN MODE)

AND

y.active = 1

AND

y.declined = 0)

    AND

`a`.`id_security_boxes` = `y`.`id_security_boxes`

AND

    `a`.`read` IN (20,30) 

AND

    z.deleted = 0

AND

    z.activated = 1

    AND

`c`.`id_security_boxes` = `b`.`id_security_boxes`

LIMIT

    0,20

Maar als ik bijv Piet Weerbericht invul als auteur en dan Weerbericht zoek dan vind die het weer wel..

Zouden die R van de Most stopwoorden zijn en dat die daarom niets vind of...?

Voel me een beetje stom dat ik wel zulke queries kan schrijven maar dat ik de achterliggende werking van MySql niet eens ken, zou dit soort vragen die ik stel graag zelf willen beantwoorden maar kom er met google niet echt uit, heeft iemand van jullie nog artikelen die betrekking hebben op dit onderwerp?

Dank alvast!

[PS3]MAG

Wed, 25 Aug 2010 07:37:02 +0000

Zitten hier mensen op EP2 die MAG: Massive Action Game op de PS3 spelen?
Wat vinden jullie van het spel en welk lvl zijn jullie?

Selecteren uit meerdere tabellen

Mon, 23 Aug 2010 19:13:23 +0000

Hallo iedereen,

Op dit moment heb ik 2 tabellen. Zie hieronder:

tijden
id | starttijd | eindtijd

reservaties
id | tijd_id | datum

Nu kan er bij reservaties een rij inzitten met bv. id 1, tijd_id 2 en datum 25-08-10.

Ik zou graag hebben dat als iemand de tijden voor 20-08-10 ophaalt, dat de rij van tijden met id 2 dan niet zal worden opgehaald aangezien die tijd 'gereserveerd' is dan.

Hopelijk kan iemand mij helpen hiermee? Alvast erg bedankt!

mysql: sloom met ORDER BY

Mon, 23 Aug 2010 15:38:55 +0000

Hoi,

ik heb een probleem wat ik niet kan oplossen ivm mysql.

Onderstaande query krijg ik niet snel tenzij ik de ORDER BY op de publish_date weghaal.

Query:

Code:

SELECT

    `s`.`id` AS s_id,

    `s`.`id_articles_categories` AS s_id_articles_categories,

    `s`.`id_security_boxes` AS s_id_security_boxes,

    `s`.`title` AS s_title,

    `s`.`author_name` AS s_author_name,

    `s`.`publish_date` AS s_publish_date,

    `s`.`tags` AS s_tags,

    `s`.`readCount` AS s_readCount,

    `s`.`id_articles_types` AS s_id_articles_types,

    `s`.`active` AS s_active,

    `s`.`declined` AS s_declined,

    `s`.`content` AS s_content,

    `s`.`date_creation` AS s_date_creation,

    `s`.`date_last_edit` AS s_date_last_edit,

    `u`.`id_security_boxes` AS u_id_security_boxes,

    `u`.`id_users_accounts` AS u_id_users_accounts,

    `u`.`id_security_groups` AS u_id_security_groups,

    `u`.`create` AS u_create,

    `u`.`read` AS u_read,

    `u`.`update` AS u_update,

    `u`.`delete` AS u_delete,

    `u`.`admin` AS u_admin,

    `t`.`id` AS t_id,

    `t`.`id_security_boxes` AS t_id_security_boxes,

    `t`.`id_security_control` AS t_id_security_control,

    `t`.`username` AS t_username,

    `t`.`password` AS t_password,

    `t`.`email` AS t_email,

    `t`.`activated` AS t_activated,

    `t`.`deleted` AS t_deleted,

    `t`.`signup_date` AS t_signup_date,

    `t`.`last_active` AS t_last_active,

    `t`.`last_location` AS t_last_location,

    `x`.`id` AS x_id,

    `x`.`id_security_boxes` AS x_id_security_boxes,

    `x`.`title` AS x_title,

    `x`.`article_class` AS x_article_class,

    `x`.`form_class` AS x_form_class,

    `y`.`id_security_boxes` AS y_id_security_boxes,

    `y`.`id_users_accounts` AS y_id_users_accounts,

    `y`.`id_security_groups` AS y_id_security_groups,

    `y`.`create` AS y_create,

    `y`.`read` AS y_read,

    `y`.`update` AS y_update,

    `y`.`delete` AS y_delete,

    `y`.`admin` AS y_admin

FROM

    articles_items s

            INNER JOIN

            (

              SELECT

                `acl`.`id_security_boxes` AS `id_security_boxes`,

                `acl`.`id_users_accounts` AS `id_users_accounts`,

                `acl`.`id_security_groups` AS `id_security_groups`,

                MAX(`acl`.`create`) AS `create`,

                  MAX(`acl`.`read`) AS `read`,

                MAX(`acl`.`update`) AS `update`,

                  MAX(`acl`.`delete`) AS `delete`,

                MAX(`acl`.`admin`) AS `admin`

              FROM

                  `security_acl` AS `acl`

              WHERE

                `acl`.`id_users_accounts` = 2 OR `acl`.`id_security_groups` IN (9,4,3,1)

              GROUP BY  `acl`.`id_security_boxes`

            ) AS `u`

INNER JOIN

    users_accounts t

ON

    t.id = s.id_users_accounts

INNER JOIN

    articles_types x

ON

    x.id = s.id_articles_types 

            INNER JOIN

            (

              SELECT

                `acl`.`id_security_boxes` AS `id_security_boxes`,

                `acl`.`id_users_accounts` AS `id_users_accounts`,

                `acl`.`id_security_groups` AS `id_security_groups`,

                MAX(`acl`.`create`) AS `create`,

                  MAX(`acl`.`read`) AS `read`,

                MAX(`acl`.`update`) AS `update`,

                  MAX(`acl`.`delete`) AS `delete`,

                MAX(`acl`.`admin`) AS `admin`

              FROM

                  `security_acl` AS `acl`

              WHERE

                `acl`.`id_users_accounts` = 2 OR `acl`.`id_security_groups` IN (9,4,3,1)

              GROUP BY  `acl`.`id_security_boxes`

            ) AS `y`

WHERE

    s.active = 1

AND

    s.declined = 0

    AND

`u`.`id_security_boxes` = `s`.`id_security_boxes`

AND

    t.deleted = 0

AND

    t.activated = 1

    AND

`y`.`id_security_boxes` = `x`.`id_security_boxes`

ORDER BY

  s.publish_date DESC

LIMIT

    0,10

Nu doet de query er 1.8229 seconden over, als ik de order by weghaal doet hij er 0.0384 seconden over, behoorlijk verschil dacht ik zo, bijna 1.5 seconde...

Als ik een EXPLAIN ervoor zet krijg ik het volgende resultaat. (Zie bijlage).

Op een of andere manier gebruikt hij niet steeds een index wat je wel wil natuurlijk..
Hieronder is de structuur van mijn tabellen te zien die gebruikt worden.

Code:

-- 

-- Tabel structuur voor tabel `articles_items`

-- 

CREATE TABLE `articles_items` (

  `id` int(10) NOT NULL auto_increment,

  `id_comments_containers` int(10) NOT NULL default '0',

  `id_security_boxes` int(10) NOT NULL default '0',

  `id_articles_categories` int(10) NOT NULL default '0',

  `title` varchar(255) character set latin1 collate latin1_general_ci NOT NULL,

  `author_name` varchar(255) character set latin1 collate latin1_general_ci NOT NULL,

  `publish_date` date NOT NULL default '0000-00-00',

  `date_creation` datetime NOT NULL default '0000-00-00 00:00:00',

  `date_last_edit` datetime NOT NULL default '0000-00-00 00:00:00',

  `id_users_accounts` int(10) NOT NULL default '0',

  `tags` varchar(255) character set latin1 collate latin1_general_ci NOT NULL,

  `readCount` int(10) NOT NULL default '0',

  `active` tinyint(1) NOT NULL default '0',

  `declined` tinyint(1) NOT NULL default '0',

  `id_articles_types` int(10) unsigned NOT NULL default '1',

  `content` text NOT NULL,

  PRIMARY KEY  (`id`),

  KEY `security` (`id_security_boxes`),

  KEY `comments` (`id_comments_containers`),

  KEY `category` (`id_articles_categories`),

  KEY `article_type` (`id_articles_types`),

  KEY `active` (`active`),

  KEY `declined` (`declined`),

  KEY `sorting` (`publish_date`)

) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=504 ;

-- --------------------------------------------------------

-- 

-- Tabel structuur voor tabel `articles_types`

-- 

CREATE TABLE `articles_types` (

  `id` int(11) NOT NULL auto_increment,

  `id_security_boxes` int(10) unsigned NOT NULL default '0',

  `title` varchar(45) NOT NULL default '',

  `article_class` varchar(255) NOT NULL default '',

  `form_class` varchar(255) NOT NULL default '',

  PRIMARY KEY  (`id`)

) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=6 ;

-- --------------------------------------------------------

-- 

-- Tabel structuur voor tabel `security_acl`

-- 

CREATE TABLE `security_acl` (

  `id` int(10) unsigned NOT NULL auto_increment,

  `id_security_groups` int(10) unsigned default NULL,

  `id_users_accounts` int(10) unsigned default NULL,

  `id_security_boxes` int(10) unsigned NOT NULL default '0',

  `create` int(10) unsigned NOT NULL default '0',

  `read` int(10) unsigned NOT NULL default '0',

  `update` int(10) unsigned NOT NULL default '0',

  `delete` int(10) unsigned NOT NULL default '0',

  `admin` int(10) unsigned NOT NULL default '0',

  PRIMARY KEY  (`id`),

  KEY `Groups` (`id_security_groups`),

  KEY `Accounts` (`id_users_accounts`),

  KEY `SecurityBoxes` (`id_security_boxes`),

  KEY `crud` (`read`,`delete`,`update`,`create`,`admin`)

) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=12282 ;

-- --------------------------------------------------------

-- 

-- Tabel structuur voor tabel `users_accounts`

-- 

CREATE TABLE `users_accounts` (

  `id` int(11) NOT NULL auto_increment,

  `id_security_boxes` int(11) NOT NULL default '0',

  `id_security_control` int(11) NOT NULL default '0',

  `username` varchar(45) character set latin1 NOT NULL default '',

  `email` varchar(255) character set latin1 NOT NULL default '',

  `activated` tinyint(1) default '0',

  `deleted` tinyint(1) default '0',

  `creationCompleted` tinyint(1) unsigned NOT NULL default '0',

  `password` blob NOT NULL,

  `signup_date` datetime NOT NULL default '0000-00-00 00:00:00',

  `system_account` tinyint(1) NOT NULL default '0',

  `last_active` datetime NOT NULL default '0000-00-00 00:00:00',

  `last_location` blob NOT NULL,

  PRIMARY KEY  (`id`),

  KEY `Security` (`id_security_boxes`,`id_security_control`),

  KEY `activated_deleted` (`activated`,`deleted`)

) ENGINE=MyISAM  DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC AUTO_INCREMENT=77 ;

Ben geen database expert, wil er graag over leren en heb ook de volgende artikels gelezen.

http://dev.mysql.com/doc/refman/5.0/en/o...ation.html
http://www.phphulp.nl/php/tutorial/overi...rken/1416/

Maar ben of iets over het hoofd gezien of ik heb het nog niet helemaal goed begrepen, wellicht iemand anders hier wel.

Ben benieuwd wat de oplossing nou word..

Alvast super bedankt!

Computer kapot

Mon, 23 Aug 2010 09:08:57 +0000

Hallo allemaal,

Afgelopen zaterdag zetten ik mijn vaste pc aan en er gebeurde niets.
Op het moederbord brande gewoon het standaard lampje.
Na het indrukken van de powerknop ging het lampje onder de knop niet drukken.
Vorige keer was dit probleem de videokaart. Deze heb ik eruit gehaald.
Dit heeft niets geholpen.

Iemand enige idee wat er aan de hand kan zijn?
Mijn hardware kennis is de afgelopen jaren ontzettend achteruit gegaan.

Ik zou verwachten dat het moederbord niet het probleem zal zijn aangezien het lampje nog brand (zegt natuurlijk ook niet veel).
Geheugen verwacht ik ook niet. Als het geheugen kapot is moet die toch nog gewoon booten?
Aan de harde schijf ligt het ook niet. Stroom heb ik hier afgehaald.

Alvast bedankt voor de suggesties

Micro payment

Sun, 22 Aug 2010 18:37:17 +0000

Hallo,

Ik weet niet of dit de juiste plaats is om deze vraag te stellen, dus bijvoorbaat sorry als het niet zo is.

Ben een idee aan het uitwerken waarin mensen op mijn website punten kunnen verdienen door bepaalde acties uit te voeren. Ze kunnen meer punten verdienen door te bellen/sms-en naar een bepaald nummer. Uiteindelijk kunnen ze korting, voucher, cadeau-bon of iets dergelijks krijgen van mij.

Mijn vraag is:
Ik heb net zitten zoeken naar micro-payment websites, maar ik word er niet wijzer van. Bij het ene land hanteren ze 2.00 euro per sms en bij de andere hanteren ze 1.50 euro per sms. Dat vind ik dus oneerlijk tegenover mijn bezoekers, want ze krijgen uiteindelijk hetzelfde aantal punten.

Is er iemand die ooit met micro-payments heeft gewerkt? Of iemand die me naar een goede provider kan wijzen? Waar moet ik op letten? En moet ik van tevoren al een KVK nummer hebben of gelden er hier andere regels voor?

Bijvoorbaat dank.

Verwijderen dubbele sound device

Sat, 21 Aug 2010 15:34:39 +0000

Hoi,

Ik heb problemen met mijn sound device, de oplossing zou zijn om 1 van de 2 de verwijderen. (uitschakelen van 1 van de 2 helpt niet). Echter heb ik geen flauw idee hoe.

Als ik naar mijn hardware ga kan ik maar 1 device vinden en als in via mn configuratie scherm -> geluid staat kan ik er geen verwijderen. Als ik de details bekijk van het Stuurprogramma wordt er verwezen naar de dezelfde besturingsfiles

Details sound device1:

Citaat:Description: Speakers (High Definition Audio Device)
Default Sound Playback: Yes
Default Voice Playback: Yes
Hardware ID: HDAUDIO\FUNC_01&VEN_10EC&DEV_0662&SUBSYS_10438290&REV_1001
Manufacturer ID: 1
Product ID: 65535
Type: WDM
Driver Name: HdAudio.sys
Driver Version: 6.01.7100.0000 (English)
Driver Attributes: Final Retail
WHQL Logo'd: Yes
Date and Size: 4/22/2009 04:50:11, 304128 bytes
Other Files:
Driver Provider: Microsoft
HW Accel Level: Basic
Cap Flags: 0xF1F
Min/Max Sample Rate: 100, 200000
Static/Strm HW Mix Bufs: 1, 0
Static/Strm HW 3D Bufs: 0, 0
HW Memory: 0
Voice Management: No
EAX™ 2.0 Listen/Src: No, No
I3DL2™ Listen/Src: No, No
Sensaura™ ZoomFX™: No

Details sound device 2

Citaat:Description: Digital Audio (S/PDIF) (High Definition Audio Device)
Default Sound Playback: No
Default Voice Playback: No
Hardware ID: HDAUDIO\FUNC_01&VEN_10EC&DEV_0662&SUBSYS_10438290&REV_1001
Manufacturer ID: 1
Product ID: 65535
Type: WDM
Driver Name: HdAudio.sys
Driver Version: 6.01.7100.0000 (English)
Driver Attributes: Final Retail
WHQL Logo'd: Yes
Date and Size: 4/22/2009 04:50:11, 304128 bytes
Other Files:
Driver Provider: Microsoft
HW Accel Level: Basic
Cap Flags: 0xF1F
Min/Max Sample Rate: 100, 200000
Static/Strm HW Mix Bufs: 1, 0
Static/Strm HW 3D Bufs: 0, 0
HW Memory: 0
Voice Management: No
EAX™ 2.0 Listen/Src: No, No
I3DL2™ Listen/Src: No, No
Sensaura™ ZoomFX™: No

Als iemand suggesties heeft om de S/PDIF varaint te verwijderen......

mvg Reijnemans

OOP Components structuur maken

Wed, 18 Aug 2010 12:45:10 +0000

Hoi,

het is een tijdje geleden dat ik actief was hier maar ik wil graag weer eens een beetje kennis delen.
Na deze tutorial zul je een goed inzicht hebben hoe je een stevig template systeem van componenten in elkaar kan zetten.

Index:

Intro
Mappen structuur
Constants
Interfaces defineren
Autoloader
Template class
Component class
Data class voor news
News component schrijven
Template invullen
Testen!
Eind
Extra

Intro

Eindelijk, nu word het leuk.
Wat ik jullie ga leren heb ik ook weer geleerd van iemand anders en heb me eigen creativiteit er daarna op losgelaten en nu wil ik dit graag delen.
De bedoeling is dat alles OOP word, nu zul je denken, ja php, oop? Klopt, php ondersteund inderdaad veel minder dan bijv. C# dat doet qua OOP maar we gaan het toch doen.
Als je bekent bent met Flex dan is de term Component niet heel erg nieuw meer voor je maar hoe passen we dit dan toe in php?
Voordat we daar aankomen moeten we een kleine basis hebben en dat is de Template class.
Deze class die zal templates kunnen inladen en variablen kunnen toekennen en naar de output buffer kunnen schrijven.
De output buffer is eigenlijk een duur woord voor alles wat naar de bezoeker ze browser word gestuurd.

Mijn voorbeeld zal ervoor zorgen dat je een News component gaat hebben, daarna kan je er zelf op los gaan en uitbreiden en je eigen componenten gaan bouwen.

Het is wel belangrijk om de denkwijze te hebben:

Een component is een visueel object. Deze heeft geen logica maar alleen weergave logica. Hij kan bijv. bepalen of een link voor bewerken getoond word of niet maar hij zal nooit een database query bevatten.
Daarvoor hebben we namelijk een data object daarom zal ik nu alvast verklappen dat we een class maken: NewsItem (data) en een class NewsMessage (component)
Hoe dit dan in zijn werk gaat zal je verderop zien.
De reden dat ik dit zo doe is omdat je dan een NewsItem object (puur data) ook aan andere visuele objecten (components) kan geven, zo hou je alle lagen (data -> component -> template) netjes gescheiden

Nog 1 ding om te weten, alle benamingen zullen in het engels zijn, uitleg en commentaar in het nederlands.
Commentaar in het nederlands omdat ik dit op een NL community post uiteraard :-)

Toch nog 1 laatste ding, eigenlijk zal deze in dezelfde stijl gaan als me vorige tutorial (Ajax auto completer in JavaScript forum: http://ep2.nl/thread-2600.html )
Ik post soms lappen code en geef hele beknopte uitleg maar dat is omdat er heel erg veel commentaar in de code zelf staat.
Mocht er iets toch niet helemaal duidelijk zijn dan kan dat uiteraard nog uitgelegd worden.
Mappen structuur

Het lijkt me handig om mappen structuur alvast klaar te hebben en dan gaan we straks iedere map stukje bij beetje invullen en zo word de puzzel compleet.
Ik zal ook een aantal mappen defineren die we niet gebruiken maar dit is ter voorbeeld hoe het eruit zou kunnen zien als je vanuit dit ontwerp verder zou willen ontwikkelen.
Deze markeer ik met een asterik (*).

classes
- AutoLoader.php
- Component.php
- Template.php
components
- PlainText.php
interfaces
- IComponent
- IPersistent
- ISingleton
- ITemplate
- IEventDispatcher *
modules
- forms * (OOP forms komen nog in een ander hoofdstuk, hoor het graag als jullie willen dat ik dit ook schrijf :-))
  - classes
    [list]
  - Form.php
  - FormElement.php
- components
  - InputBox.php
  - Label.php
- interfaces
  - IFormElement.php
news
- classes
  - NewsItem.php
- components
  - NewsMessage.php
- forms
  - NewsCategoryForm.php
themes
- default
  - news
  - show.phtml
index.php

Nu dit is aangemaakt kunnen we verder.
Vul in alle bestanden nog maar even niets in, gewoon leeg bestand aanmaken, vullen we later in.

Constants

Voordat we beginnen moet je wel beseffen dat dit systeem heel goed toepasbaar is in een groot systeem.
Nu heb ik niet genoeg inkt om dat systeem te gaan omschrijven dus bepaalde systeem variablen die je uit een class als SystemEnvironments of iets dergelijks haalt doen we nu even simpelweg in constants defineren.

De index.php is 0,0 OOP omdat het puur is om te testen, je kan zelf later invullen hoe je alles gaat toepassen namelijk.

index.php:

PHP-code:

define('THEME', 'default');    // mogelijkheden: default | christmas
define('THEMES_FOLDER', '/themes');
define('ROOT_PATH', 'C:/xampp/htdocs/tutorials/components'); 

De constants beschreven:

- THEME
De systeemnaam van het thema, deze representeerd in ons geval ook meteen de folder naam waar de templates staan.
- THEMES_FOLDER
Dit is waar alle themas gedefineerd staan
- ROOT_PATH
Dit is het basis pad naar onze map met bestanden, deze word gebruikt bij het includen van files (Autoloader + Template classen)

Straks word index.php nog verder ingevuld.

Interfaces defineren

Interfaces zijn een van de krachtigste objecten in php vind ik zelf persoonlijk.

Voor de mensen die het princiepe van interfaces al wel begrijpen kunnen onderstaand blok skippen, de rest die het nog niet begrijpt gewoon lekker blijven lezen.

Citaat:Een interface is eigenlijk de manier waarop iets bestuurd kan worden.
Neem bijv. een tv afstandsbediening, iedereen weet dat elke afstandsbedieding altijd de volgende knoppen heeft:

- Aan
- Uit
- Volume harder
- Volume zachter
- Programma verder
- Programma terug

Alsof je nou een sony of een samsung afstandsbedieing hebt, ze hebben allemaal dezelfde functionaliteit maar hoe de sony afstandsbediening het volume signaal verstuurd naar de televisie kan compleet anders dan dat de samsung afstandsbediening dit doet.

Klein voorbeeldje in code:

PHP-code:

interface IRemoteControl { function turnOn(); function turnOff(); // en de rest van de functies nog: increaseVolume() decreaseVolume() etc etc } class SonyRemote implements IRemoteControl // hiermee vertel ik dat ik alle functionaliteit heb van een IRemoteControl { // nu ik mij voordoe als een remote control moet ik ook die functionaliteit bieden dus ben ik verplicht om de publieke methodes van de interface te implementeren: public function turnOn() { // doe iets om tv aan te zetten } public function turnOff() { // doe iets om tv uit te zetten } } class SamsungRemote implements IRemoteControll { public function turnOn() { // hier kan ik iets doen hoe ik mijn samsung tv aan zet } public function turnOff() { // en hier iets om die tv weer uit te zetten } } // Denk bijv aan de Sims hoe zoiets gebouwd zou kunnen zijn (net uit me duim gezogen hoor) // Het gaat er hier om dat er bij de method giveRemoteControll() geen class SamsungRemote of SonyRemote word gevraagd maar gewoon // "een (lees als 'UN')" controller die de functionaliteit van 'UN' afstandsbedieing ondersteund. (IRemoteControll) class TurnTelevisionOnAction implements IPersonAction // heeft method: execute() { private $controller; public function giveRemoteControll(IRemoteControll $controll) { $this->controller = $controll; } public function execute() { $this->controller->turnOn(); } } class Person { public function addActionToQueue(IPersonAction $action) // dit kan IEDERE actie zijn, in ons geval hebben we nog maar 1 actie: TurnTelevisionOnAction { $this->actionQueue->append($action); } }

Zo, dit kan maar zo een tutorial apart zijn volgens mij.
Anyway, dit zijn dus interfaces. Vragen zijn welkom hoor.

interfaces/IComponent.php

PHP-code:

/**
 * Interface voor alle componenten, ieder component ondersteunt minimaal deze functionaliteiten zoals hieronder beschreven:
 *
 * - render
 * - styleName
 * - fullStylename (inheritence meegenomen)
 */
interface IComponent
{
    /**
     * Word gebruikt om component om te zetten naar html
     *
     * @return string
     */
    function render();

    /**
     * Identity of the component
     *
     * @return string
     */
    function identity();

    /**
     * Geeft de stylename terug van deze component, deze kan ook gezet worden door deze method. De stylename bepaalt uiteindelijk welke template ingeladen word.
     *
     * @param string $value
     * @return string
     */
    function styleName($value=null);

    /**
     * Alleen een getter van de volledige stylename, hier worden ook alle classen meegenomen die parents zijn van deze class
     *
     * @return string
     */
    function fullStylename();
} 

interfaces/IPersistent.php

PHP-code:

/**
 * Interface voor classen die persistent moeten zijn, persistent wil zeggen dat ze opgeslagen kunnen worden en verwijderd
 * Deze interface word dus door zeer veel classen geimplementeerd :-)
 *
 */
interface IPersistent
{
    function save();
    function delete();
} 

interfaces/ISingleton.php

PHP-code:


interface ISingleton
{
    /**
     * Geeft instance van het corresponderende object terug
     *
     * @return ISingleton
     */
    static function getInstance();
} 

interfaces/ITemplate.php

PHP-code:

/**
 * Interface voor templates.
 * Templates princiepe: word vanuit gegaan van bestanden die ingeladen worden, 
gebufferd worden en hun inhoud word in render() teruggegeven, deze inhoud is 
dan geparsed (de parser is geen smarty of iets dergelijks maar in dit geval gewoon php zelf).
 */
// @todo: method toevoegen voor het verwijderen van een variable
interface ITemplate
{
    /**
     * Method word gebruikt om de template naam op te geven en opgehaald te worden indien ingestelt
     *
     * @param string $value
     * @return string
     */
    function templateName($value=null);

    /**
     * Method word gebruikt om de template te renderen, deze geeft een string terug
     *
     * @return string
     */
    function render();

    /**
     * Geeft true terug in het geval dat de template bestaat of niet
     *
     * @return boolean
     */
    function exists();

    /**
     * Geeft path terug of NULL indien niet bestaat
     *
     * @return string
     */
    function path();

    /**
     * Voor het toekennen van variablen aan de template
     *
     * @param string $key
     * @param object $value
     *
     * @return void
     */
    function assign($key, $value);

    /**
     * Voor het controleren of een variable bestaat of niet
     *
     * @param string $key
     * @return boolean
     */
    function contains($key);
} 

Dit zijn alle interfaces die we tot nu toe nodig zullen hebben.
Als de EventDispatcher gemaakt word zal hier hoogstwaarschijnlijk de IEventDispatcher.php bijkomen.
Bedenk wel even dat alle interfaces nu bij elkaar staan.
Een interface die component/template gericht is hoort natuurlijk niet in dezelfde map te staan als een interface zoals IPersistent
Dit is nu wel even zo gedaan om het simpel te houden.

AutoLoader

Het is erg handig om een autoloader te hebben, dit scheelt je een heleboel werk + je kan alles makkelijk her-indelen ALS je het goed aanpakt.
Naar mijn idee is de aanpak die ik nu laat zien erg handig + performance erg goed.
Even voor alle duidelijkheid een autoloader is een method in een class of een functie die include() aanroept wanneer een class of interface niet gevonden is.
Je kunt met spl_autoload_register() defineren welke functie dit voor je moet oplossen. Dit mogen ook meerdere functies zijn.

Flow voorbeeld:

foo.php

PHP-code:

class Foo
implements IFoo
{
    public function foo()
    {
        echo 'foo';
    }
} 

IFoo.php

PHP-code:

interface IFoo
{
    function foo();
} 

index.php

PHP-code:


$foo = new Foo();
$foo->foo();
?>

De flow:

1. class Foo word aangemaakt
2. PHP: hee, deze class kan ik niet vinden, is er een autoloader?
3. Ja er is een autoloader, deze word aangeroepen en geeft als argument de class naam mee (in dit geval Foo, dit is een string)
4. De autoloader include het juiste bestand indien er een bestand is voor die class, de class bestaat
5. PHP: hmm, autoloader aangeroepen, bestaat de class nu wel in het geheugen?
6. Zoja: hee, we hebben een interface IFoo, ken ik deze?
7. Zoniet: autoloader nog een keer aanroepen maar nu met IFoo als classname
8. Autoloader: include('IFoo.php');
9. PHP: hmm, autoloader aangeroepen, bestaat de interface nu wel in het geheugen?
10. Ja, alles bestaat, Foo::__construct() word aangeroepen.

Het idee is dat je een array met class namen hebt en daaraan is een pad gekoppeld gerekend vanaf de const ROOT_PATH.
Nu word er expres geen file_exists() uitgevoerd in de autoloader ivm performance, je array met class paden MOET dus kloppen en anders triggered php een error.
Nu is het een array die hard gedefineerd word in de code, het zou heel gebruikelijk zijn dat dit soort informatie uit een cache bestand komt.

De autoloader class:

PHP-code:

class AutoLoader
implements ISingleton
{
    /**
     * De array met alle class paden erin
     *
     * @var array
     */
    private $classPaths;

    /**
     * Instantie van dit object
     *
     * @var AutoLoader
     */
    private static $instance;

    /**
     * Geeft instantie van de AutoLoader terug
     * Dit zorgt ervoor dat er altijd maar 1 instantie aanwezig is van dit object in het geheugen
     * Voor meer uitleg zie: http://en.wikipedia.org/wiki/Singleton_pattern
     *
     * @return AutoLoader
     */
    public static function getInstance()
    {
        if( self::$instance === null )
            self::$instance = new AutoLoader();

        return self::$instance;
    }

    /**
     * Constructor van AutoLoader, standaard waarden instellen van de class.
     *
     */
    protected function __construct()
    {
        $this->classPaths = array();
    }

    /**
     * Autoloader class. Deze checked of de class beschreven is in de "cache", zoniet, dan doet die niks en zal php een error gooien dat de class niet gevonden is.
     * Ik gebruik expres geen check met file_exists() omdat dat ten koste gaat van je performance. Kortom, je cache bestand moet kloppen.
     *
     * @param string $class
     * @return void
     */
    public static function load($objectName) // De reden dat het $objectName heet is omdat het een interface OF een class is die ingeladen word.
    {
        $instance = self::getInstance();

        if( isset($instance->classPaths[$objectName]) )
            require_once ROOT_PATH . $instance->classPaths[$objectName] . '/' . $objectName . '.php';
    }

    /**
     * Deze stelt de array met alle class/interface lokaties in.
     *
     * @param array $value
     * @return array
     */
    public function classPaths(array $value=null)
    {
        if( $value !== null )
            $this->classPaths = $value;

        return $this->classPaths;
    }
} 

De statische functie load() zal het opgevraagde object gaan inladen.
Nu moet PHP dat ook nog weten dus moeten we onze class gaan registreren.
Omdat deze class zelf de autoloader is moeten we dus 2 objecten includen voordat we de class kunnen registreren als autoloader.
Als je wakker bent weet je al welke 2 dat zijn.

Anyway, tijd om index.php uit te gaan breiden.

Met een paar tussenregels van het vorige blok het volgende toevoegen:

PHP-code:

// Deze zijn verplicht om de autoloader uberhaubt te kunnen laten werken.
include_once 'interfaces/ISingleton.php';
include_once 'classes/AutoLoader.php';

// configureer de autoloader
$autoLoader = AutoLoader::getInstance();

// De autoloader moet wel weten waar alle classen en interfaces staan
// Nu word dit hard met code aan de autoloader toegekend maar stel je eens een mechanisme voor dat automatisch een cache bestand uitleest
// waar dit allemaal in beschreven staat.
$autoLoader->classPaths(array(
    'Component'            => '/classes',
    'Template'            => '/classes',
    'IComponent'        => '/interfaces',
    'IPersistent'        => '/interfaces',
    'ITemplate'            => '/interfaces',

    'NewsItem'            => '/modules/news/classes',
    'NewsMessage'        => '/modules/news/components',
));

// registreer een auto loader, dit houd in als er een class/interface word aangeroepen dan kijkt de autoloader of die gevonden word
// zoniet dan word de method AutoLoader::load() aangeroepen met de classname/interfacename als parameter en kun je het corresponderende bestand includen
spl_autoload_register(array('AutoLoader', 'load')); 

Nu de autoloader eindelijk werkt kunnen we aan de slag gaan met onze uiteindelijke doel.
Tot aan hier was eigenlijk allemaal voorbereidend werk.

Template class

Dit is de basis class voor ALLE objecten die zichzelf als html kunnen presenteren, kortom: Component.
Je kunt het ook helemaal herschrijven zolang je maar de interface ITemplate implementeerd.
Op deze manier kan je bijv maken: SmartyTemplate of TemplatePowerTemplate of PHPTemplate.
Het zijn allemaal templates en ze kunnen allemaal hetzelfde alleen werken onder water net iets anders.

Nu zal ik alleen de PHPTemplate gaan doen want php is eigenlijk al een template parser dus waarom een template parser in een template parser schrijven, we willen toch snelle websites? Weggooien dus die smarty en al die andere meuk, dat is mijn mening.
Anyway, dit is de code voor de template class:

PHP-code:


class Template
implements ITemplate
{
    /**
     * Naam van de template, hiermee word het pad achterhaalt van het template bestand
     *
     * @var string
     */
    protected $templateName;

    /**
     * Array met alle geldige templates
     * Dit is eigenlijk te vergelijken met de techniek voor de autoloader alleen dan met templates
     * Daarbij komt nog kijken dat deze themas zijn gecategorieseerd zijn op basis van thema
     * in dit geval heb ik even 2 themas aangemaakt, default + christmas
     * Dit is nu weer hard-coded gedaan maar dit zou weer uit een cache file moeten komen.
     *
     *
     * Deze 2 variablen ($valid_templates + $theme) horen hier niet thuis maar is quik & dirty. Hoort in een ThemeManagerData achtige class thuis.
     * @var array
     */
    protected $valid_templates;

    /**
     * Systeem naam van het thema dat deze template moet gebruiken
     * Standaard is dit de global template die in de const is gedefineerd (dus SystemEnvironment achtig)
     * Maar stel nou dat je 1 template in kerst sfeer wil kan je dit dus als nog overriden indien je een method maakt om deze variable te wijzigen.
     *
     * @var string
     */
    protected $theme;

    /**
     * Array met alle variablen die in deze template gebruikt kunnen worden
     *
     * @var array
     */
    protected $vars;

    public function __construct($templateName=null)
    {
        // Template naam instellen
        $this->templateName($templateName);

        // Variablen standaard waardes geven
        $this->vars         = array();
        $this->theme         = THEME;

        // zie property definitie voor commentaar/uitleg
        $this->valid_templates = array(
            'default'    => array(
                'name'        => 'Standaard thema',
                'templates'    => array(
                    'NewsMessage'        => '/news/show.phtml'
                )
            ),

            'christmas'    => array(
                'name'        => 'Kerst thema',
                'templates'    => array()
            )
        );

    }

    /**
     * Geeft variable waarde terug
     * De .phtml bestanden die kunnen deze "magic" method benaderen, zie: http://php.net/manual/en/language.oop5.magic.php
     * Je moet het eigenlijk zo zien, op het moment dat je include() aanroept binnen in een class dan heeft dat bestand toegang tot alle methodes van die class
     *
     * @param string $key
     * @return object
     */
    public function __get($key)
    {
        if( $this->contains($key) )
            return $this->vars[$key];

        return null;
    }

    /**
     * Word gebruikt om waardes toe te kennen aan template
     *
     * @param string $key
     * @param object $value
     *
     * @return void
     */
    public function assign($key, $value)
    {
        $this->vars[$key] = $value;
    }

    /**
     * Controleert of opgegeven key bestaat in lijst met variablen voor deze template
     *
     * @param string $key
     * @return boolean
     */
    public function contains($key)
    {
        return isset($this->vars[$key]);
    }

    /**
     * Template naam setter/getter
     *
     * @param string $value
     * @return string
     */
    public function templateName($value=null)
    {
        if( $value !== null )
            $this->templateName = $value;

        return $this->templateName;
    }

    /**
     * Geeft complete path terug van de template. Indien de template niet bestaat dan word NULL teruggeven
     *
     * @return string
     */
    public function path()
    {
        if( !$this->exists() )
            return null;
        else
            return ROOT_PATH . THEMES_FOLDER . '/' . $this->theme . $this->valid_templates[$this->theme]['templates'][$this->templateName];
    }

    /**
     * Controleert of een template bestaat
     *
     * @return boolean
     */
    public function exists()
    {
        // nu word dit even quik & dirty gedaan maar misschien kan je zelf een class bedenken die dezelfde functionaliteit gaat bieden als wat hieronder gebeurt.
        // Hint: return ThemeManagerData::getInstance()->exists($this->templateName);
        if( !isset($this->valid_templates[$this->theme]) )
            return false; // thema bestaat niet eens

        if( !isset($this->valid_templates[$this->theme]['templates'][$this->templateName]) )
            return false;

        // alle checks gepasseerd, template bestaat
        return true;
    }

    /**
     * Rendered de template
     *
     * Geeft string versie van deze template terug.
     * Nu word er vanuit gegaan dat er PHP templates zijn.
     * Stel dat je ook smarty templates, templatepower templates etc wilt kunnen parsen google dan eens op het Adapter Pattern :-)
     *
     * @return string
     */
    public function render()
    {
        // @todo: hier kan nog include path opgeslagen worden. Pad van thema in het include path gezet worden, daarna als de template is ingeladen
        // kan het oude include path weer teruggezet worden.
        // op deze manier kan de template ook weer makkelijk andere templates inladen zonder moeilijk te doen met ../../messages/info.phtml maar gewoon: messages/info.phtml :-)

        // start bufferen
        ob_start();

        // include/render template
        include_once($this->path());

        // vang de buffer inhoud op
        $content = ob_get_contents();

        // veeg de buffer schoon
        ob_end_clean();

        // geef de geparsde template inhoud terug.
        return $content;
    }
} 

Nu de template class is gemaakt kunnen we de Component class gaan maken!
Stel je wil de Template class al even in actie zien kan je een template aanmaken en toevoegen aan de array met geldige templates en vervolgens iets in de zin van:

index.php, onder alle huidige code plaatsen.
note: is alleen voor testen en lezers die willen proberen. Gewoon weer weghalen als je klaar bent.

PHP-code:

$template = new Template('Homepage');
$template->assign('eenVariable', 'Een waarde...');
$template->assign('uitgerekend', (5*5));

echo $template->render(); 

Vervolgens maak je een homepage.phtml aan of hoe je het bestand ook noemt in je valid_templates array en kan je dit invullen:

homepage.phtml

PHP-code:

Hoi dit is gewoon html

php
echo 'En dit is een variable: ' . $this->eenVariable . 'En dit is uitgerekend: ' . $this->uitgerekend;
?>

Component

Deze class zal heel erg veel gebruikt worden voor bijv. het weergeven van nieuws items, forum topics, agenda item, form elementen etc etc etc
Het is een abstracte class, dit houd in dat deze functionaliteit bevat en nooit zelfstaand aangemaakt kan worden, deze type classen zullen 'altijd' ge-extend moeten worden.
De abstracte class wat in dit geval Component is kan de subclass ook verplichten methodes te implementeren.
De kracht van zoon class is dus dat deze functionaliteit bevat maar ook verplichtingen van een interface kan stellen.

De component class is eigenlijk te vergelijken met de Template class behalve dat deze een simpele logica heeft
Nog een bijzonderheid aan deze class is dat wanneer er geen template beschikbaar voor is dat deze een baseHtml() method heeft die
een minimale hoeveelheid html terug geeft waar ook niet rekening word gehouden met het gekozen thema.

Zie hier de Component class:

PHP-code:


abstract class Component
// @todo: extends EventDispatcher        // zoals je ziet, hier heb je de EventDispatcher, het zou erg mooi zijn als deze eenmaal ge-implementeerd is.
                                        // stel je eens voor dat je een UsernameInputBox hebt (extend InputBox -> FormElement -> Component) en een event dispatched: Event::CHANGE
                                        // Mogelijkheden zijn eindeloos..
implements IComponent
{
    /**
     * Variable die gebruikt word zodat we ALTIJD een uniek ID hebben voor de component
     *
     * @var int
     */
    private static $uniqueId;

    /**
     * Dit is het id van dit component, deze instantie. Bovenstaande uniqueId is per keer dat er een Component word aangemaakt met 1 verhoogd
     *
     * @var string
     */
    private $id;

    /**
     * Stijlnaam, deze wordt later gebruikt voor juiste template inladen
     *
     * @var string
     */
    private $styleName;

    public function __construct()
    {
        // uniek id toekennen aan onszelf + verhoog het uniqueId op globaal niveau met 1
        $this->id             = self::$uniqueId++;

        // stel onze STANDAARD stylename in, deze kan uiteraard nog veranderd worden
        $this->styleName     = get_class($this);
    }

    /**
     * Word gebruikt als mogelijkheid je component te omschrijven
     * Hier kan je bijv aan de front-end developer duidelijk maken welke variablen hij kan gebruiken in de component indien je een debug modus maakt voor components
     *
     * @return string
     */
    abstract protected function description();

    /**
     * Word aangeroepen net voordat er ge-RENDER-ed gaat worden zodat alle variablen klaar gezet kunnen worden en geen dubbele code krijgt of code die 2x aangeroepen word.
     *
     * @return void
     */
    abstract protected function preBuild();

    /**
     * Word aangeroepen indien er geen template voor deze component beschikbaar is.
     * In dat geval kan de component een simpel stuk html teruggeven waar hij minimaal is.
     * Is bijv. handig voor formulier elementen omdat je deze bijna nooit een echte template zal geven, baseHtml + css voldoet 99% van de tijd
     *
     * @return string
     */
    abstract protected function baseHtml();

    /**
     * Word aangeroepen indien er WEL een template beschikbaar is, hier krijg je de mogelijkheid om de variablen toe te kennen aan je template
     *
     * @param Template $template
     * @return void
     */
    abstract protected function prepareTemplate(Template $template);

    /**
     * Geeft de identiteit van deze component terug
     * Deze is altijd uniek, dit is bijv. handig voor een element aanroepen in javascript.
     *
     * @return string
     */
    public function identity()
    {
        return get_class(__CLASS__) . $this->id;
    }


    /**
     * Word gebruikt om component om te zetten naar html
     *
     * @return string
     */
    public function render()
    {
        /* @todo:     je kunt een check maken of we in component debug modus draaien
                     zoja dan geef je enkel de description() terug als waarde

        if( in_array($this->identity(), self::$debugComponents) )
            return '' . $this->description() . '

';
        */

        // Bereid alles voor
        $this->preBuild();

        // Probeer een template te laden voor dit component
        $template = new Template($this->styleName());

        if( !$template->exists() )        // er is geen template dus gebruik de basis html
            $html = $this->baseHtml();
        else
        {
            // Template bestaat, laat het component deze invullen.
            $this->prepareTemplate($template);

            // render template
            $html = $template->render();
        }

        // geef de ge-genereerde html terug
        return $html;
    }

    /**
     * Geeft de stylename terug van het component, deze kan ook gezet worden door deze method. De stylename bepaalt uiteindelijk welke template ingeladen word.
     *
     * @param string $value
     * @return string
     */
    public function styleName($value=null)
    {
        if( $value !== null )
            $this->styleName = $value;

        return $this->styleName;
    }

    /**
     * Alleen een getter van de volledige stylename, hier worden ook alle classen meegenomen die parents zijn van deze class
     * Deze kan je weer invullen als je bijv. een  hebt die een component is.
     *
     * Voorbeeld:
     * 
     * Uiteraard kan je de interfaces nog eruit filteren bij het invullen van de fullStyleName()
     *
     * @return string
     */
    public function fullStylename()
    {
        $string         = '';
        $parents         = class_parents($this);    // haal alle sub classen op

        foreach($parents AS $parent)
            $string = $parent . ' ' . $string;

        $string .= $this->ident;

        if($this->ident != $this->styleName)
            $string .= ' ' . $this->styleName;

        return $string;
    }
}

Dit was het Component, hier kunnen we (nog) niks mee want we hebben nog geen class die deze gebruikt.
Eerst de Data class voor nieuws maken, hier geef ik niet heel erg veel uitleg bij want deze is vrij basic.

Data class voor news

PHP-code:


/**
 * Class voor nieuws items
 * Deze class is de data-laag, deze heeft niets te maken hoe deze aan de bezoeker gepresenteerd word
 * Hij bevat enkel data en functionaliteit om opgeslagen te worden (IPersistent)
 *
 */
class NewsItem
implements IPersistent
{
    private $id;
    private $title;
    private $message;
    private $author;

    ## IPersistent ##
    public function save()
    {
        if( $this->id === null )
            $this->insert();
        else
            $this->update();
    }

    protected function insert()
    {
        // doe hier query om je nieuws item in de database te stoppen, of in xml.. of in tekst bestand whatever you would like
    }

    protected function update()
    {
        // doe hier je ding om het nieuws item te updaten
    }

    public function delete()
    {
        // doe hier je ding om het nieuws item te verwijderen :-)
    }
    ## END IPersistent ##



    ## GETTERS / SETTERS ##
    public function id($value=null)
    {
        if( $value !== null )
            $this->id = $value;

        return $this->id;
    }

    public function title($value=null)
    {
        if( $value !== null )
            $this->title = $value;

        return $this->title;
    }

    public function message($value=null)
    {
        if( $value !== null )
            $this->message = $value;

        return $this->message;
    }

    public function author($value=null) // nu is de $value een string, had eigenlijk een User object moeten zijn....
    {
        if( $value !== null )
            $this->author = $value;

        return $this->author;
    }
} 

Dit is duidelijk data. Hier word helemaal niks met display of output of wat dan ook gedaan.
Maar het juiste component zal de structuur van deze data snappen en kan deze dus gebruiken voor weergave genaamd NewsMessage.

News component schrijven

PHP-code:

class NewsMessage
extends Component
{
    /**
     * Het item dat getoond moet worden, dit is een class NewsItem.
     * De bedoeling hier van is dat je de laag data onderscheid van de laag met display.
     *
     * Kortom:
     *
     * NewsMessage         = Component: DisplayObject, visueel.
     * NewsItem         = Puur Data & Functionaliteit
     *
     * @var NewsItem
     */
    private $source;

    protected function baseHtml ()
    {
        return 'NewsMessage base html';
    }

    protected function description ()
    {
        return 'Beschrijving van NewsMessage component.
        Beschikbare variablen:

        - $this->id
        - $this->title
        - $this->message
        - $this->author
        ';
    }

    protected function preBuild ()
    {
        // niet nodig hier, bij deze component word het nieuws item van buiten af ingegeven.
        // word ingeladen bij het weergeven is dit de plek om het commentaar in te laden en intern in deze class op te slaan.
        // Hier kunnen kort gezegd uitzonderingen gemaakt worden en dingen inladen die standaard niet worden ondersteund door het data object
        // dan vervolgens bij prepareTemplate & baseHtml() zal die klaar staan om weergegeven worden.

        // of nog een ander voorbeeld, stel dat je enkel een id binnen krijgt van het nieuws item, dan kan je nu dus dat nieuws item ophalen
        // en het object invullen. nu heb ik het wel over een dirty scenario want dan hou je je niet meer aan de data/display laag gescheiden regel.
    }

    protected function prepareTemplate (Template $template)
    {
        // Vertel de template de waardes van onze bron (NewsItem)
        $template->assign('id', $this->source->id());
        $template->assign('title', $this->source->title());
        $template->assign('message', $this->source->message());    // ALS het nodig is doe je HIER de htmlentities() check
        $template->assign('author', $this->source->author());
    }

    /**
     * Stelt de source van de component in
     *
     * @param NewsItem $value
     * @return NewsItem
     */
    public function source(NewsItem $value=null)
    {
        if( $value !== null )
            $this->source = $value;

        return $this->source;
    }
} 

Dit is de component.
Zoals je ziet is het eigenlijk heel erg simpel om nu componenten erbij te maken.
Je maakt een nieuwe class, je extend Component class, je vult 4 functies in:

- baseHtml()
- description()
- preBuild()
- prepareTemplate()

En je hebt een volledig component.
Daarnaast kan je natuurlijk nog honderden functionaliteiten toevoegen.
Bedenk je eens dat je NewsMessage gaat extenden met een class in de zin van PagedNewsMessage bijv.
Zoon nieuwsbericht die ondersteund opeens pagina nummering... Is maar een voorbeeld.

Nu zijn we bijna klaar! Template invullen en test code in index.php en draaien!

Template invullen

Vul in de template het volgende in:

themes/default/news/show.phtml

PHP-code:

<table>
    <tr>
        <th colspan="2">php echo $this->title?>
    
        Auteur
        echo $this->author?>
    
        echo $this->message?>

Lijkt me zeer voor de hand liggend.
Het enigste weetje hiervan is dat je weet in welke context je zit met $this
3x raden, $this = de instantie van Template!
Dus als je $this->author aanroept dan roep je eigenlijk Template::__get() aan.
In de parameter van Template::__get() word dus author meegegeven.

Voila. Je hebt een componenten systeem.
Nu nog testen dus.

Testen!

Voeg de volgende code toe aan index.php:

index.php

PHP-code:

// Nu maak ik hier een test object aan, je moet je voorstellen dat deze normaal uiteraard ingeladen word vanuit de database of iets dergelijks.
// Een NewsItem is puur data
$item = new NewsItem();
$item->id(1);
$item->author('Chris');
$item->title('Het nieuws van de dag!');
$item->message('Het bericht');

// Dan maak ik nu de component aan, dit is het visuele object, deze snapt weer de data en weet hoe die het kan weergeven
$message = new NewsMessage();

// het visuele object weet hoe die het moet weergeven maar moet ook nog weten WAT die moet gaan weergeven dus stellen we nu de bron in
$message->source($item);

// en uiteindelijk als het component is ingevuld kan die gaan renderen
echo $message->render(); 

Je kunt nu gaan testen door alles in een webfolder te plaatsen op je (lokale) webserver en index.php aanroepen.

Einde

Dit is het einde van mijn artikel.
Het was een behoorlijke klus maar het is af en hoop iedereen hier veel van geleerd heeft.

Dingen die je nog zou kunnen gaan doen:

- EventDispatcher schrijven en de Component class die laten extenden
- Form module schrijven (Form components + Form logica etc etc)
- Nadat je de EventDispatcher hebt geschreven een ORM schrijven die aangesloten is op het template systeem en zo lijsten weergeven, bij elke next() van je db ORM word event gedispatched, Template gaat meteen parsen, zo heb je nooit dubbele loops bij weergeven van lijsten.

Check de attachment om het gehele artikel in zijn werking te zien.
Daarnaast zijn ook nog een aantal extra's verstopt in de attachment die ik wou gaan behandelen maar was toch erg veel schrijfwerk, voor een volgende keer en de gene die het lezen hebben alvast een voorproefje.

Vragen of opmerkingen? Gewoon doen!

Chris.

Extra

Om je vast een klein beetje op weg te helpen hoe de forms in elkaar zouden kunnen gaan zitten dan is hier een voorbeeld:

PHP-code:


class NewsItemForm
extends Form
{
    protected $title;
    protected $author;
    protected $message;
    protected $category;

    protected $item;

    protected function createChildren ()
    {

        // invoerveld voor titel aanmaken en toevoegen aan formulier
        $this->title = new InputBox();
        $this->title->name('title');
        $this->title->label(new Label('Titel'));
        $this->add($this->title);

        $this->author = new InputBox();
        $this->author->name('author');
        $this->author->label(new Label('Auteur'));
        $this->add($this->author);

        // NewsCategorySelector extends SelectBox :-)
        $this->category = new NewsCategorySelector();
        $this->category->label(new Label('Ouder categorie'));
        $this->add($this->category);

        $this->message = new TextEditor();
        $this->message->name('message');
        $this->message->label(new Label('Bericht'));
        $this->add($this->message);

        // je kunt je nu voorstellen, je voegt een InputBox toe.
        // Maar je kunt je ook zo voorstellen, ik voeg een IFormElement/IComponent toe, kortom je kunt ALLLESSS toevoegen aan je form
        // zolang het maar de interface IComponent implementeert. Dat is pas Power :-)
    }

    /**
     * Method word alleen aangeroepen als alle velden gevalideerd zijn dus hierin hoeft niks meer gechecked te worden :-)
     *
     * @return void
     */
    protected function handleForm ()
    {
        // indien dit formulier gebruikt word voor het aanmaken dan is $this->item null en word dat object dus ook aangemaakt
        // indien dit formulier gebruikt word voor het wijzigen dan is $this->item een NewsItem object ingesteld van buitenaf
        // In NewsItem::save() word iets gedaan in de zin van: if($this->id === null ) { $this->_insert(); } else { $this->update(); }
        if( $this->item === null )
            $this->item = new NewsItem();

        $this->item->title($this->title->value());
        $this->item->author($this->author->value());
        $this->item->category($this->category->value());        // value() returned een NewsCategory object.
        $this->item->message($this->message->value());

        // save item
        $this->item->save();
    }
} 

Dit is nu wel echt het einde, haha.

Have fun!

javascript hulp

Wed, 18 Aug 2010 09:51:24 +0000

Hoe moet je een script maken als bijv.

in pagina.html klik je op een plaatje met ismap usemap
dan kan je in pagina2.html komen,anders niet
Ik dacht dat je dit mat javascript moest doen, met cookies ofzo.

Gimp tutorials

Tue, 17 Aug 2010 17:30:45 +0000

Zijn er mensen die websites weten met goede en duidelijk gimp tutorials?
Het liefste in de richting van het webdesign.

Wat een vreselijk pittig programma is het. Ik probeer iets heel basics te doen maar zelfs dat lukt me nog niet

Andere banner boven het forum?

Tue, 17 Aug 2010 16:53:54 +0000

Je zult waarschijnlijk wel gezien hebben dat er een andere banner boven het forum staat!

Deze banner is van AdverteerDirect, de nieuwe advertentiepartner van Ep2! De member wabontrup pwnt die tent en z'n aanbod is harstikke interessant voor de middelgrote tot grote webmasters die advertenties voeren op hun website.

Check het zelf effe en als je een website hebt met 1000+ bezoekers per maand, meld je dan gelijk aan! Kost niets

(levert mij ook niets op trouwens, daar doe ik dit absoluut niet voor! Ik sta achter de dienstverlening en maak er gebruik van op Ep2, that's it!)

Check it out: http://www.adverteerdirect.nl/publisher

Zelf adverteren op middelgrote tot grote websites kan natuurlijk ook! Voor een vast bedrag per periode kun je helemaal zelf een advertentie plaatsen op een website naar keuze. Na betaling is je advertentie direct zichtbaar en uiteraard ondersteunen ze voor het afhandelen van de betaling iDeal

Peace!

wrong datatype in array

Tue, 17 Aug 2010 13:32:54 +0000

hallo mensen,

ik zit met een probleempje hier op m'n werk. Ik heb een stuk code van mn werkgever gehad met de vraag: los de foutmeldingen op.

Dit is de code die fout gaat:

http://ep2.pastebin.com/9ZTg1FLc

En de melding is

Code:

Warning: in_array() [function.in-array]: Wrong datatype for second argument in /home/inmru1/public_html/beheer_inmru/offerte_auto_matchen_cron.php on line 164 (12, in dit voorbeeld)

Warning: in_array() [function.in-array]: Wrong datatype for second argument in /home/inmru1/public_html/beheer_inmru/offerte_auto_matchen_cron.php on line 173 (21, in dit voorbeeld)

wat is er nou mis? Thanks alvast!