Welcome to CakePHP v1.3.10 Console

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

App : app

Path: /home/roland/workspace/weightapplication/app

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

Interactive Bake Shell

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

[D]atabase Configuration

[M]odel

[V]iew

[C]ontroller

[P]roject

[F]ixture

[T]est case

[Q]uit

What would you like to Bake? (D/M/V/C/P/F/T/Q) 

>

Hier kannst du auswählen was du backen willst.
Wir wollen zuerst unsere Modelle backen, also geben wir M ein.
Die nächste Frage lautet ob wir unsere Modelle anhand der Definitionen der Default-Database-Connection oder der Test-Connection erstellen wollen.

> M       

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

Bake Model

Path: /home/roland/workspace/weightapplication/app/models/

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

Use Database Config: (default/test) 

[default] >

Hier kannst du return drücken, da wir die default-Konfiguration nehmen wollen.
Als nächstes werden die Tabellen, die derzeitig in der Datenbank definiert sind, angezeigt:

[default] > 

Possible Models based on your current database:

1. User

2. Weight

Enter a number from the list above,

type in the name of another model, or 'q' to exit  

[q] >

Jetzt lassen wir die Modelle erstellen. Du gibst hierfür die 1 und 2 ein.
Fangen wir also mit 1 an:

[q] > 1   

Would you like to supply validation criteria 

for the fields in your model? (y/n) 

[y] >

Die Modell-Attribute können mit Standard-Validierungen überprüft werden.
Wir wollen das der Name und die E-Mail Adresse korrekt eingegeben werden.
Also sagen wir ja (return)
Das erste Feld ist die id.
Hier werden folgende Optionen angeboten:

[y] > 

Field: id

Type: integer

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

Please select one of the following validation options:

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

1 - alphanumeric

2 - between

3 - blank

4 - boolean

5 - cc

6 - comparison

7 - custom

8 - date

9 - decimal

10 - email

11 - equalto

12 - extension

13 - inlist

14 - ip

15 - maxlength

16 - minlength

17 - money

18 - multiple

19 - notempty

20 - numeric

21 - phone

22 - postal

23 - range

24 - ssn

25 - time

26 - url

27 - userdefined

28 - uuid

29 - Do not do any validation on this field.

... or enter in a valid regex validation string.

[29] >

Mit 29 (also return) geben wir an, dass wir keine besondere Überprüfung für dieses Feld durchführen wollen.

Als nächstes wird das Feld name angezeigt.

[29] > 

Field: name

Type: string

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

Please select one of the following validation options:

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

1 - alphanumeric

2 - between

3 - blank

4 - boolean

5 - cc

6 - comparison

7 - custom

8 - date

9 - decimal

10 - email

11 - equalto

12 - extension

13 - inlist

14 - ip

15 - maxlength

16 - minlength

17 - money

18 - multiple

19 - notempty

20 - numeric

21 - phone

22 - postal

23 - range

24 - ssn

25 - time

26 - url

27 - userdefined

28 - uuid

29 - Do not do any validation on this field.

... or enter in a valid regex validation string.

[19] >

Die Cake Console ist ziemlich clever und schlägt und notempty vor. Also machen wir das so.
Als nächstes fragt Die Cake Console uns ob wir weitere Überprüfungen durchführen wollen. Hier können wir vorerst mit Return (also nein) weitergehen.

[n] > 

Field: email

Type: string

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

Please select one of the following validation options:

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

1 - alphanumeric

2 - between

3 - blank

4 - boolean

5 - cc

6 - comparison

7 - custom

8 - date

9 - decimal

10 - email

11 - equalto

12 - extension

13 - inlist

14 - ip

15 - maxlength

16 - minlength

17 - money

18 - multiple

19 - notempty

20 - numeric

21 - phone

22 - postal

23 - range

24 - ssn

25 - time

26 - url

27 - userdefined

28 - uuid

29 - Do not do any validation on this field.

... or enter in a valid regex validation string.

[10] >

Das nächste Feld ist die E-Mail Adresse. Hier erkennt Cake Console dass wir eine valide E-Mail Adresse eingeben wollen (also irgendwas mit BLA@BLUB.LULL).
Wir akzeptieren die 10.
Die Frage, ob wir noch weitere Validierungen angeben wollen, beantworten wir diesmal mit y.
Jetzt geben wir noch isUnique als Validierungsregel an. Damit wird erreicht, dass jede E-Mail Adresse im System einmalig ist.

[10] > isUnique

Would you like to add another validation rule? (y/n) 

[n] >

Jetzt können wir wieder return drücken.

Das letzte Feld, mit zu überprüfenden Eigenschaften, ist das Passwort.
Hier können wir z.B. eine Minimallänge vorgeben.

[19] > 16

Would you like to add another validation rule? (y/n) 

[n] >

Die Beschreibung lassen wir optional.

[n] > 

Field: description

Type: text

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

Please select one of the following validation options:

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

1 - alphanumeric

2 - between

3 - blank

4 - boolean

5 - cc

6 - comparison

7 - custom

8 - date

9 - decimal

10 - email

11 - equalto

12 - extension

13 - inlist

14 - ip

15 - maxlength

16 - minlength

17 - money

18 - multiple

19 - notempty

20 - numeric

21 - phone

22 - postal

23 - range

24 - ssn

25 - time

26 - url

27 - userdefined

28 - uuid

29 - Do not do any validation on this field.

... or enter in a valid regex validation string.

[29] >

Als nächstes werden wir gefragt ob wir Verknüpfungen zu anderen Modellen haben wollen.
Hier sagen wir ja, denn wir wollen unsere Personen mit vielen Gewichtsangaben versehen.

[29] > 

Would you like to define model associations

(hasMany, hasOne, belongsTo, etc.)? (y/n) 

[y] >

Wenn du return drückst wird die weights Tabelle angezeigt. Diese beinhaltet eine user_id und kann daher eine Relation zu unserer users-Tabelle haben.

[y] > 

One moment while the associations are detected.

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

Please confirm the following associations:

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

User hasMany Weight? (y/n) 

[y] >

Wir sagen bei dieser Frage ja (return)

[y] > 

Would you like to define some additional model associations? (y/n) 

[n] >

Hier bleiben wir bei nein.
Als letztes wird uns angezeigt was wir da so zusammenkonfiguriert haben:

[n] > 

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

The following Model will be created:

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

Name:       User

DB Table:   `users`

Validation: Array

(

    [name] => Array

        (

            [notempty] => notempty

        )

    [email] => Array

        (

            [email] => email

            [isUnique] => isUnique

        )

    [password] => Array

        (

            [minlength] => minlength

        )

)

Associations:

	User hasMany Weight

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

Look okay? (y/n) 

[y] >

Das sieht gut aus! Also sagen wir ja.

[y] > 

Baking model class for User...

Creating file /home/roland/workspace/weightapplication/app/models/user.php

Wrote `/home/roland/workspace/weightapplication/app/models/user.php`

SimpleTest is not installed. Do you want to bake unit test files anyway? (y/n) 

[y] >

Wie du sehen kannst, wird das Modell user.php in das Verzeichnis /app/models/users.php geschrieben.
Die Frage ob wir die Unit-Tests für unser Modell erstellen wollen, können wir mit ja beantworten. Dann können wir später mit SimpleTest alles durchtesten.

Jetzt wird alles fertiggestellt und wir kommen wieder zur Startseite.

[y] > 

You can download SimpleTest from http://simpletest.org

Baking test fixture for User...

Creating file /home/roland/workspace/weightapplication/app/tests/fixtures/user_fixture.php

Wrote `/home/roland/workspace/weightapplication/app/tests/fixtures/user_fixture.php`

Bake is detecting possible fixtures..

Creating file /home/roland/workspace/weightapplication/app/tests/cases/models/user.test.php

Wrote `/home/roland/workspace/weightapplication/app/tests/cases/models/user.test.php`

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

Interactive Bake Shell

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

[D]atabase Configuration

[M]odel

[V]iew

[C]ontroller

[P]roject

[F]ixture

[T]est case

[Q]uit

What would you like to Bake? (D/M/V/C/P/F/T/Q) 

>

Hier brechen wir mit Q ab und schauen uns zuerst unser Modell an.
Gehe zur Validierung des Passworts und ändere die Validierung so ab, dass wir eine Minimallänge von sechs Zeichen vorsehen:

		'password' => array(

			'minlength' => array(

				'rule' => array('minlength', 6),

				//'message' => 'Your custom message here',

				//'allowEmpty' => false,

				//'required' => false,

				//'last' => false, // Stop validation after this rule

				//'on' => 'create', // Limit validation to 'create' or              'update' operations

			),

Alle anderen vorgefertigten Definitionen lassen wir vorerst einfach mal so stehen.
Das Modell ist jetzt erst einmal ausreichend konfiguriert.

Ähnliche Beiträge

# This SQL-commands create the tables for weightapplication.
drop database weightapplication;
create database weightapplication;
use weightapplication;
create table users (  id          int(11) not null auto_increment primary key \
                    , name        varchar(255) not null \
                    , email       varchar(255) not null \
                    , password    varchar(32) not null \
                    , description text null \
                   );
create table weights (  id          int(11) not null auto_increment primary key \
                      , user_id     int(11) not null
                      , weight      float not null \
                      , created     timestamp NOT NULL DEFAULT now() \
                     );

Dieses Script habe ich unter dem Namen create_database.sql im Verzeichnis /app/config abgelegt.
Jetzt wechsle in das Verzeichnis /app/config und führe den Befehl mysql -uroot -p < create_database.sh aus. Du wirst nach dem Passwort gefragt, dass du für deinen MySQL-Server benötigst.
Das Script löscht eine zuvor angelegte Datenbank, legt die weightapplication Datenbank an und erstellt die Tabellen für Personen (users) und die Gewichtsangaben.

Ähnliche Beiträge

Mit Synaptic, dem Paketmanager von Ubuntu, ist die Installation kinderleicht.

PHP Installation

Ich habe hier einen Screenshot meiner installierten PHP-Komponenten gemacht.

Wähle bitte php-5 und php5-mysql aus. Die restlichen Pakete müssten dann mit angezogen werden.

MySQL Installation

Wenn du mysql-server auswählst, wird der Rest entsprechend mit angezogen.
Bei der Installation wirst du nach einem root-Passwort gefragt. Dies ist dein Root-Passwort für den DB-Server. Wähle eins und merke es dir. In der Demoinstallation werden wir zuerst den User root und sein Passwort verwenden. Wenn du das später ändern willst, ist das ein Artikel für sich

Apache2 Installation

Auch das ist kinderleicht.
Hier meine installierten Pakete:

Wenn du das Paket apache2 auswählst, sollte eigentlich alles von alleine laufen.

Nach der Installation dieser Pakete können wir uns wieder um die eigentliche Applikationsentwicklung kümmern.
Juchhu! Drei Komponenten sind beschrieben. Das geht doch voran gelle?

Ähnliche Beiträge

• Ubuntu-Entwicklungsrechner
  Darauf entwickle ich die Gewichtsapplikation.
• www.baldenhofer.eu/blog
  (Rat mal selber ) Wie du kommst nicht drauf? Hier dokumentiere ich die Gewichtsapplikation mit Hilfe von Blog-Artikeln
• Apache Webserver
  Dieser Webserver beheimatet die Sourcen unserer Applikation.
• Eclipe PHP Entwicklungsumgebung
  Habe ich schon beschrieben. Hiermit versuche ich die Monstarapplikation umzusetzen
• Enterprise Architect
  Mit diesem Werkzeug zeichne ich die lustigen Diagramme. Bisher habe ich die Anwendungsfälle, Akteure und die Komponentenübersicht aufgezeichnet. Vielleicht darf ich später noch ein paar Aktivitätendiagramme oder so zeichnen. Im Moment, glaube ich, müsste das so reichen um diese Applikation sinnvoll beschreiben zu können. Die Klassen werde ich noch aufzeichnen, damit wir sehen wie alles zusammenhängt. Das Tool brauchst du nicht selbst installieren. Die Doku findest du ja hier im Blog.
• MySQL Datenbank Server
  Beinhaltet unsere Datenbank für die Gewichtsapplikation.
• PHP Interpreter
  Wir bauen eine PHP Applikation (liegt vielleicht daran, dass CakePHP ein PHP Framework ist ) Deshalb muss auf unserem Rechner ein PHP Interpreter für Apache konfiguriert werden.
• Webbrowser
  Auf der Entwicklermaschine muss ein Webbrowser verfügbar sein, damit wir unsere lokale Webapplikation überhaupt verwenden können. Darauf gehe ich nicht näher ein. Falls du tatsächlich keinen (aktuellen) Webbrowser auf deiner Maschine hast, installiere einfach einen und fertig.
• /etc/hosts
  In der Entwicklungsumgebung haben wir (normalerweise) keinen eigenen Domain Name Server. Wir werden unsere Rechner-IP verwenden um auf unsere Lokale Webserver-Umgebung die weightapplication routen zu können.Damit erreichen wir, dass wir mit unserem lokal auf der Entwicklungsumgebung installierten Webbrowser unsere Webapplikation verwenden können.
• /etc/apache2/sites-available
  Hier werden wir unsere weightapplication eintragen damit diese vom Webserver überhaupt gefunden werden kann.
• /etc/apache2/sites-enabled
  Bei Ubuntu / Debian kann hier festgelegt werden, welche Webapplikationen überhaupt angezeigt werden.
• WORKSPACE/weightapplication
  Beinhaltet die meisten Dateien die zu unserer Webapplikation gehören. Die Dateien, die nicht in diesem Ordner liegen, sind Konfigurationsdateien für den jeweiligen Server.
• Application-Configuration
  Hier sammele ich alle Dateien, die für den Betrieb einer CakePHP-Webapplikation konfiguriert werden müssen. Bisher habe ich die /app/config/core.php beschrieben.
• /app/config/database.php
  Hier werden die Datenbank-Zugangsdaten für unsere Applikation konfiguriert. Wie das geht erläutere ich noch in einem eigenen Artikel.
• /app/tmp
  Hier finden sich alle temporären Dateien. Ich werde noch ein wenig ausführlicher darauf eingehen.
• /app/models
  CakePHP verwendet in erster Linie das Model View Controller (MVC) Pattern. Die Modelle (wie z.B. Person und Weight) werden wir hier ablegen.
• /app/controllers
  Hier werden wir die Controller unserer Gewichtsapplikation ablegen.
• /app/views
  Und damit wir auch was sehen können, werden wir hier alle Ansichten programmieren.
• CakePHP
  Habe ich schon im Artikel Entwicklungsumgebungs-Setup für die Gewichsapplikation CakePHP Grundinstallation beschrieben wie wir das herunterladen und verwenden können.

So, jetzt weiß ich wenigstens was ich noch alles zu dokumentieren habe und ihr könnt euch hoffentlich ein besseres Bild davon machen, was es alles braucht um eine Webapplikation in Betrieb zu nehmen.
In nächster Zeit werde ich diese Komponentenübersicht immer wieder zeigen und die Komponente, die in dem jeweiligen Artikel beschrieben wird, entsprechend rot markieren.
Damit werden die Artikel zwar etwas länger aber du kannst schnell erkennen wo ich gerade herumfummle.

Ähnliche Beiträge

Das geschah nur beim Firefox 4 und 5.

Lösung

Im Event-Handler hatten wir ursprünglich folgende Zeile eingetragen:

e.dataTransfer.setData("Text", "js_draggedItem: "); + this.innerHTML)

Wenn du den “Text” CamelCase mässig schreibst, dann kommt die Warnung.

Wenn du dies umstellst auf:

e.dataTransfer.setData("TEXT", "js_draggedItem: "); + this.innerHTML)

dann wird keine Warnung mehr geschrieben.

Mit CamelCase (Text) versucht der Firefox ein Redirect auf den dahinterliegenden Text zu machen.

Das ist irgendwie doof aber er macht es halt

setData(FORMAT, DATA) darf also keine Groß-Kleinschreibung beinhalten.

Ähnliche Beiträge

configure::write(‘debug’, DEBUG_LEVEL)

Hier kannst du einstellen, wie viele Debug-Meldungen du sehen willst.
Während der Entwicklung ist es sinnvoll diesen Debu-Level so hoch wie möglich einzustellen.
Denn du willst ja sehen, wenn irgendwo eine Variable nicht gesetzt ist oder eine Warnung generiert wird.
Der Debug-Level 2 ist für die Entwicklung gut geeignet. Er zeigt dir SQL-Zugriffe, Notice-Meldungen, Warnungen und natürlich Errors.
Wenn du dein Layout gestalten willst, empfiehlt sich dieser Level jedoch nicht. Du solltest ihn dann auf 0 oder 1 heruntersetzen. Dann bleiben die SQL-Zugriffe verborgen.
Da wir zuerst „nur“ programmieren werden, ist für uns der Debug-Level 2 für die Entwicklungsumgebung die passende Wahl.

/**
 * CakePHP Debug Level:
 *
 * Production Mode:
 * 	0: No error messages, errors, or warnings shown. Flash messages redirect.
 *
 * Development Mode:
 * 	1: Errors and warnings shown, model caches refreshed, flash messages halted.
 * 	2: As in 1, but also with full debug messages and SQL output.
 *
 * In production mode, flash messages redirect after a time interval.
 * In development mode, you need to click the flash message to continue.
 */
    Configure::write('debug', 2);

Meistens möchte ich den Development-Code ohne Anpassung in die Produktion wuchten.
Deshalb modifiziere ich das Definieren des Log-Levels ein wenig:

if(     empty($_SERVER['SERVER_ADDR'])
    || (strpos($_SERVER['SERVER_ADDR'], '192.168.') === 0)
    || (strpos($_SERVER['SERVER_ADDR'], '127.0.') === 0)
   ){
    Configure::write('debug', 2);
}else{
    Configure::write('debug', 0);
}

Jetzt wird jedesmal wenn ich mit einem lokalen Server arbeite der Entwicklungs-Debug-Level gesetzt. Ansonsten der Produktionsdebuglevel. Wenn du deinen Debuglevel auf diese Weise einstellen willst, musst du natürlich deine eigene IP-Adresse auslesen.
Die findest du in der $_SERVER Variable. Mit print_r($_SERVER); kannst du dir die Variablen ausgeben lassen.

Log-Level für tmp/*.log Dateien

CakePHP schreibt die Debug-Informationen auch in Log-Dateien, wenn du dies zulässt. Ich bin froh, dass damit auch während des Betriebs auf Fehler reagiert werden kann. Falls du mal eine hochfrequentierte Monsterapplikation erstellt hast, solltest du darüber nachdenken ob du dir den Luxus von sauberen Fehlermeldungen leisten kannst. Unsere Gewichts-Applikation wird wohl kaum ein neues Facebook und deshalb glaube ich, können wir die Debug-Meldungen auch in der Produktion mitlaufen lassen.
Du siehst hier zwei Einträge (Configrue::write(‘log’ , LEVEL) und configure::write(‘log’, true)
Die Standardkonfiguration (log, true) reicht uns vorerst aus. Du kannst gerne mit den Logleveln herumspielen und sehen was CakePHP alles schreibt. Die Log-Dateien findest du unter /app/tmp/logs.

/**
 * CakePHP Log Level:
 *
 * In case of Production Mode CakePHP gives you the possibility to continue logging errors.
 *
 * The following parameters can be used:
 *  Boolean: Set true/false to activate/deactivate logging
 *    Configure::write('log', true);
 *
 *  Integer: Use built-in PHP constants to set the error level (see error_reporting)
 *    Configure::write('log', E_ERROR | E_WARNING);
 *    Configure::write('log', E_ALL ^ E_NOTICE);
 */
	Configure::write('log', true);

Weiter unten findest du in der config.php noch folgenden Eintrag:

/**
 * Defines the default error type when using the log() function. Used for
 * differentiating error logging and debugging. Currently PHP supports LOG_DEBUG.
 */
	define('LOG_ERROR', 2);

Hier wird festgelegt welche Log-Levels ausgegeben werden sollen. Mit 2 wird festgelegt, dass Notice, Warning und Error geschrieben wird. Ich würde das so stehen lassen.

Encoding lassen wir auf utf8 stehen (App.encoding)

Admin Routing

Wir wollen, dass unsere Administratoren eine andere Oberfläche und andere Funktionen erhalten wie Besucher. Deshalb schalten wir das Admin-Routing frei.

/**
 * Uncomment the define below to use CakePHP prefix routes.
 *
 * The value of the define determines the names of the routes
 * and their associated controller actions:
 *
 * Set to an array of prefixes you want to use in your application. Use for
 * admin or other prefixed routes.
 *
 * 	Routing.prefixes = array('admin', 'manager');
 *
 * Enables:
 *	`admin_index()` and `/admin/controller/index`
 *	`manager_index()` and `/manager/controller/index`
 *
 * [Note Routing.admin is deprecated in 1.3.  Use Routing.prefixes instead]
 */
Configure::write('Routing.prefixes', array('admin'));

Du kannst auch mehrere Routings eintragen, wie beispielsweise admin für Administratoren und manager für Management. Wir belassen es bei admin.

Session Handling (Session.save)

Mit den Sessions werden wir viel zu tun haben wenn wie CakePHP Applikationen bauen. Die Sessions erlauben es uns, Anwender einloggen zu lassen und wenn sie zu lange inaktiv sind wieder auszuloggen.

/**
 * The preferred session handling method. Valid values:
 *
 * 'php'	 		Uses settings defined in your php.ini.
 * 'cake'		Saves session files in CakePHP's /tmp directory.
 * 'database'	Uses CakePHP's database sessions.
 *
 * To define a custom session handler, save it at /app/config/.php.
 * Set the value of 'Session.save' to  to utilize it in CakePHP.
 *
 * To use database sessions, run the app/config/schema/sessions.php schema using
 * the cake shell command: cake schema create Sessions
 *
 */
	Configure::write('Session.save', 'php');

Ich lasse dies meist auf dem Standard stehen. Wenn du nicht ewig rumsuchen willst, kannst du auch auf ‘cake’ stellen. Dann kannst du die Session-Daten im /app/tmp auslesen.
Die Datenbank-Session ist auch cool, denn dann werden die Sessions nicht in Dateien sondern in der Datenbank abgelegt. Dazu benötigst du jedoch noch ein entsprechendes Schema in der Datenbank. Für die erste CakePHP-Anwendung finde ich das etwas übertrieben. Also nehmen wir den Standard, mit ‘php’.
Die weitere Konfigurationen (‘Session.model’, ‘Session.table’ und ‘Session.database’) verwenden wir vorerst nicht, da wir ja keine Datenbank-Sessions verwenden. Also lassen wir die auskommentiert stehen.
Die Sessions müssen zwischen dem Server und dem Client ausgetauscht werden. Das wird über Cookies erfolgen. Der Name des Cookies sollte nur alpanumerische Zeichen beinhalten. Im Standardfall steht hier CAKEPHP. Wir können ja mal unseren Cookie umbenennen und WEIGHTAPPLICATION verwenden? Dann finden wir ihn auch einfacher im Browser-Cookie Cache. Wenn du das nicht willst, ist es nicht wichtig. CAKEPHP tut genausogut. Außer wenn du mehrere CakePHP Applikationen verwendest. Dann kann der Browser (oder du selber beim Debuggen) ein wenig durcheinander kommen

/**
 * The name of CakePHP's session cookie.
 *
 * Note the guidelines for Session names states: "The session name references
 * the session id in cookies and URLs. It should contain only alphanumeric
 * characters."
 * @link http://php.net/session_name
 */
    // Wir wollen einen eigenen Cookie
    // Configure::write('Session.cookie', 'CAKEPHP');
    Configure::write('Session.cookie', 'WEIGHTAPPLICATION');

Mit Session.timeout kannst du festlegen, wie lange ein Anwender sich nicht mehr am Server melden kann bevor die Session abläuft. Wenn du oft Timeouts hast, z.B. weil du große Texte schreiben lässt, dann solltest du hier höher gehen.
Um ein bisschen Gewicht einzugeben sollten zwei Minuten jedoch ausreichend sein. Wenn die Person zu langsam ist um in zwei Minuten drei Zahlen einzutippen sollte sie zuerst Sport treiben und dann erst die Applikation verwenden

/**
 * Session time out time (in seconds).
 * Actual value depends on 'Security.level' setting.
 */
	Configure::write('Session.timeout', '120');

Session.start und Session.checkAgent lassen wir stehen wie sie sind. Wir wollen, dass die Sessions automatisch starten und wir verwenden aktuelle Browser.

Security Level einstellen

Die folgenden zwei Einträge kümmern sich um die Sicherheitseinstellung.

/**
 * The level of CakePHP security. The session timeout time defined
 * in 'Session.timeout' is multiplied according to the settings here.
 * Valid values:
 *
 * 'high'   Session timeout in 'Session.timeout' x 10
 * 'medium' Session timeout in 'Session.timeout' x 100
 * 'low'    Session timeout in 'Session.timeout' x 300
 *
 * CakePHP session IDs are also regenerated between requests if
 * 'Security.level' is set to 'high'.
 */
	Configure::write('Security.level', 'medium');

/**
 * A random string used in security hashing methods.
 */
	Configure::write('Security.salt', 'DYhG93b0qyJfIxJulchenubAlIWwvniR2G0FgaC9mi');

/**
 * A random numeric string (digits only) used to encrypt/decrypt strings.
 */
	Configure::write('Security.cipherSeed', '768593096432442496749683645');

Security.level auf medium ist ausreichend. Den Security.salt und Security.cipherSeed veränderst du bitte. Dieser wird für die Generierung von Passwörtern und anderen hashing-Methoden eingesetzt. Damit wird es für die bösen Angreifer etwas schwerer unsere Daten auszulesen.
Ich habe die beiden hier direkt schon mal verändert. Aber bitte nehme eigenen Werte.

Caching-Probleme für .js, .css und images umgehen

Manchmal funktioniert eine Webapplikation nicht richtig, da die Browser und Proxies die .js, .css und images zwischenspeichern. Das ist bei statischen Seiten vernünftig, da damit weniger Daten ausgetauscht werden müssen.
Wir sind vorerst vorsichtig und wollen dass sichergestellt wird dass Änderungen ankommen.
Deshalb schalten wir Asset.timestamp auf force.

/**
 * Apply timestamps with the last modified time to static assets (js, css, images).
 * Will append a querystring parameter containing the time the file was modified. This is
 * useful for invalidating browser caches.
 *
 * Set to `true` to apply timestamps, when debug = 0, or set to 'force' to always enable
 * timestamping.
 */
    Configure::write('Asset.timestamp', 'force');

Die Komprimiererei Asset.filter.css und Asset.filter.js lassen wir im Moment ausgeschalten. Falls du Performanceprobleme bei unserer Gewichtsapplikation zu spüren bekommst, dann kannst du hiermit etwas spielen.

Access Control Lists (ACL) werden wir für die erste Applikation auch nicht verwenden. ACL ist cool, verrenkt dir jedoch am Anfang ein wenig das Gehirn. Wir haben das in miradlokit aktiviert, aber da machen wir auch ein wenig mehr als in der Gewichtsapplikation notwendig ist.

Zeitzone einstellen

Ich schalte hier die Europa/Berlin Zeit frei. UTC sollte auch passen…

/**
 * If you are on PHP 5.3 uncomment this line and correct your server timezone
 * to fix the date & time related errors.
 */
//date_default_timezone_set('UTC');
date_default_timezone_set('Europe/Berlin')

Die restlichen Einträge lassen wir so stehen wie sie definiert sind. Dort wird definiert wie die Caching-Verhalten von CakePHP sein sollen. Uns reicht hier das Standardverhalten locker aus.

Ähnliche Beiträge

Ich möchte eine CakePHP-Applikation erstellen, also müssen wir in unser weightapplication Projekt die hierfür notwendigen Quellen einspielen.

Mein PHP-Projekt wurde in /home/roland/workspace/weightapplication angelegt.

Als nächstes musst du CakePHP von cake.org herunterladen. Verwende bitte die Stable-Version. Ich habe hier die Version 1.3.10 heruntergeladen (war gerade die aktuelle Stable-Version).

Das CakePHP Archiv beinhaltet die folgende Struktur:

BILD cakephpstruktur

CakePHP liefert einen Basisordner (z.B. /cakephp-cakephp-b0abad1/) und darin die Verzeichnisse

/app

/cake

/plugins

/vendors

Entpacke dieses zip und kopiere den Inhalt des Basisordners (also /app, /cake usw.) in das weightapplication Projekt. Bei mir werden die Dateien also nach /home/roland/workspace/weightapplication geschrieben.

Wenn du die Dateien kopiert hast, gehe in die Eclipse Perspektive PHP und wähle die PHP Explorer Sicht aus. Mit F5 kannst du die Ansicht aktualisieren.

Im PHP Explorer sollte folgende Dateien und Verzeichnisse erscheinen, kann natürlich je nach CakePHP-Version ein klein wenig variieren.

BILD weightapplication

Damit haben wir das CakePHP-Framework zur Verfügung.

Als nächstes werden wir uns um die Konfiguration kümmern.

Ähnliche Beiträge

Eclipse Grundinstallation
Ich habe Eclipse for PHP Developers heruntergeladen und installiert. Dieses Bundle ist nicht das neue Indigo Eclipse. Wenn ihr das haben wollt, dann müsst ihr PHP als Plugin hinzufügen.
Das von mir verwendete Bundle ist für PHP Entwickler zugeschnitten und kann leicht installiert werden.

Eclipse About

Wenn ihr die PHP-Erweiterungen nicht über das Bundle in eure bestehende Eclipse Umgebung einbinden wollt, müsst ihr mindestens WTP (Eclipse Webtools Platform) und die PHP Erweiterungen herunterladen und installieren. Das kann eventuell zu Problemen (Abhängigkeiten zwischen Paketen) führen. Ich empfehle daher, einfach das Bundle zu verwenden. Eventuell könnt ihr ja alles in einer virtuellen Maschine betreiben, dann versaut ihr nicht eure Standardkonfiguration.

Wechseln in die PHP-Perspektive

Nachdem Eclipse soweit installiert ist, könnt ihr in die Perspektive für PHP Entwicklung wechseln:

Wenn du in diese Perspektive gewechselt hast, sollte die Oberfläche ähnlich wie in dem hier abgebildeten Screenshot aussehen.

Auf der linken Seite befinden sich diverse Tabs mit denen die PHP-Dateien, und deren Struktur, unterschiedlich betrachtet werden können.

• Der PHP Explorer stellt die PHP-Dateien und die PHP-Projektstruktur dar..

• Die Type-Hierachie verwende ich in diesem Kontext vorerst nicht.

• Outline zeigt dir die Struktur einer Klasse an und bietet eine schnelle Möglichkeit auf die darin befindlichen Attribute und Methoden zugreifen zu können. Beispielsweise habe ich hier eine Klasse geöffnet und du kannst die Struktur der Klasse gut erkennen.

• In Navigation werden nicht nur die PHP-Dateien sondern auch versteckte Dateien wie .htaccess usw. dargestellt. Wenn du also eine Datei im PHP Explorer nicht sehen  kannst, dann verwende den Navigation Tab.

Kurz zur Erinnerung

Eclipse ist ein Framework dass unzählige Programmiersprachen und Editoren bereitstellt. Eine Perspektive erlaubt es, die Ansichten entsprechend zu konfigurieren, dass z.B. die *.php Dateien sinnvoll angezeigt werden.
In der PHP-Ansicht werden also die Werkzeuge dargestellt, die ihr für die PHP Entwicklung benötigt. Dagegen werden in der Subversion-Ansicht nur die Werkzeuge dargestellt, die für die Verwaltung von Subversion benötigt werden und bei der Java-Ansicht entsprechend die Java-bezogenen Werkzeuge.
So kann mit einem grundsätzlich identischen Vorgehen auf unterschiedliche Bedürfnisse eingegangen werden.

Neue Projekt (weightapplication) anlegen

Wir sind im PHP Explorer und können mit der rechten Maustaste das Kontextmenü neues Projekt auswählen. (New->PHP Project)

Über File->New->PHP Project kommst du dort auch hin.

Der Name des neuen Projekts soll weightapplication lauten. Ich verzichte hier auf Unterstriche oder Bindestriche (also nicht weight_application) da dies unter Umständen zu Konfigurationsschwierigkeiten in anderen Bereichen (Apache usw.) führen kann. Natürlich kannst du auch einen anderen Namen nehmen, für dieses Beispielprojekt sollte das jedoch so ausreichen.
Du kannst sehen, dass ich in meinem /home/roland Verzeichnis einen Unterordner workspace habe. Hier liegen all meine Eclipse Projekte drin. Falls du eine andere Struktur vorsiehst, kannst du das entsprechend ändern.

Jetzt haben wir eine Entwicklungsumgebung und ein neues, leeres PHP-Projekt in dem wir unsere Gewichtsapplikation einschreiben können.

Ähnliche Beiträge

Wir sollten für unsere statistischen Auswertungen noch die Grösse der Person aufnehmen.
Das soll vom Registrierten Anwender selbst durchführbar sein.

Das Projekt hat noch nicht richtig begonnen und schon fange ich mit Änderungen an

Naja, das ist im Projektbusiness ja so üblich gelle?

Also hier also die ergänzten Anwendungsfälle:

Erweiterte Personenanwendungsfälle

Der neue Anwendungsfall lautet Details zu Person verändern. Hier kann ein Registrierter Anwender die Grössenangabe eingeben.

Details zu Person verändern

Akteur

Registrierter Anwender

Vorbedingung

Der Registrierte Anwender ist angemeldet.

Ablauf

• Der User wählt den Link Details zu Person verändern aus.
• Seine persönlichen Daten werden angezeigt.
• Er kann das Feld Grösse in cm ausfüllen
• Weiter kann er den Namen ändern
• Nach dem Ändern drückt er speichern
• Das System überprüft ob die Felder korrekt befüllt sind und speichert die Daten ab.

Nachbedingung

Die Daten sind gespeichert worden.

So, das sollte fürs Erste reichen.

Als nächstes gehen wir her und generieren die dazugehörige Applikation.

Ähnliche Beiträge

Anwendungsfälle Gewicht

Ein registrierter Benutzer soll seine Gewichtsinformationen eingeben, ändern und die Auswertungen durchführen können.

Gewichtsangaben auflisten

Akteur

Registrierter Anwender

Vorbedingung

Der Registrierte Anwender ist angemeldet.

Ablauf

• Der Registrierte Anwender wählt den Link Meine Gewichtsangaben aus.
• Es werden alle bisher eingegebenen Gewichtsangaben aufgelistet.

Nachbedingung

Die Gewichtsangaben sind angezeigt worden.

Gewicht eingeben

Akteur

Registrierter Anwender

Vorbedingung

Der Registrierte Anwender ist angemeldet.

Ablauf

• Der Registrierte Anwender wählt den Link Gewicht eingeben aus.
• Er gibt den Tag und das Gewicht ein
• Er drückt speichern
• Das System kontrolliert, ob bereits an diesem Tag ein Gewicht eingegeben wurde. (Mehrmals wiegen ergibt irgendwie keinen Sinn…
• Falls alles korrekt eingegeben wurde, wird das Gewicht zur Person gespeichert.

Nachbedingung

Das Gewicht wurde angelegt.

Gewicht ändern

Akteur

Registrierter Anwender

Vorbedingung

Der Registrierte Anwender ist angemeldet.

Ablauf

• Der Registrierte Anwender listet seine Gewichtseinträge auf und wählt ein Gewichtseintrag aus.
• Er kannden Tag und das Gewicht ändern
• Er drückt speichern
• Das System kontrolliert, ob bereits an diesem Tag ein anderes Gewicht eingegeben wurde. (Mehrmals wiegen ergibt irgendwie keinen Sinn…
• Falls alles korrekt eingegeben wurde, wird das Gewicht zur Person gespeichert.

Nachbedingung

Das Gewicht wurde geändert.

Auswertung fahren

Akteur

Registrierter Anwender

Vorbedingung

Der Registrierte Anwender ist angemeldet.

Ablauf

• Der Registrierte Anwender wählt den Link Auswertung aus.
• Das System lädt alle zu dieser Person hinterlegten Gewichtsangaben und generiert eine Übersicht über den Verlauf des Gewichts.
• Weiter wird anhand der Stammdaten der Person aufgelistet ob der BMI soweit ok ist, oder wo sich die Person befindet.
• Weiter wird angezeigt wie der allgemeine Trend (also ich werde runder, ich nehme ab, ich bleibe auf meinem Gewicht) angezeigt.

Nachbedingung

Die Auswertung wurde angezeigt.

Ähnliche Beiträge

Jetzt möchte ich die zu erstellenden Anwendungsfälle etwas genauer beschreiben, damit wir auch wissen was wir alles umsetzen müssen. Zuerst möchte ich mich mit den Personen verwalten Prozess relevanten Anwendungsfällen beschäftigen.

Hier sehe ich mindestens die folgenden Anwendungsfälle:

Anwendungsfälle Person verwalten

Die meisten Anwendungsfälle werden vom Administrator ausgeführt.

Person anlegen

Akteur

Administrator

Vorbedingung

Der Administrator ist angemeldet und der neue Anwender hat ihm die Informationen E-Mail und Name mitgeteilt.

Ablauf

• Der Administrator wählt den Link Person hinzufügen aus.
• Er gibt den Namen und die E-Mail Adresse, sowie das Passwort für diese Person ein
• Er drückt speichern
• Das System kontrolliert, ob bereits eine Person mit der gleichen E-Mail Adresse vorhanden ist.
• Weiter wird kontrolliert ob eine gültige E-Mail Adresse, ein Name und ein Passwort eingegeben wurde. Im Fehlerfall wird dies dem Administrator gemeldet
• Falls alles korrekt eingegeben wurde, wird die Person gespeichert.

Nachbedingung

Die Person wurde angelegt und kann sich nun als Registrierter Anwender anmelden.

Person ändern

Akteur

Administrator

Vorbedingung

Der Administrator ist angemeldet.

Ablauf

• Der Administrator wählt den Link Personen auflisten aus.
• Alle verfügbaren Personen werden tabellarisch angezeigt.
• Der Administrator wählt bei einer Person den Link editieren aus.
• Das System lädt die aktuellen Daten der Person und zeigt diese an.
• Er ändert den Namen, die E-Mail Adresse oder das Passwort für diese Person
• Er drückt speichern
• Das System kontrolliert, ob bereits eine weitere Person mit der gleichen E-Mail Adresse vorhanden ist.
• Weiter wird kontrolliert ob eine gültige E-Mail Adresse, ein Name und ein Passwort eingegeben wurde. Im Fehlerfall wird dies dem Administrator gemeldet
• Falls alles korrekt eingegeben wurde, wird die Person gespeichert.

Nachbedingung

Die Person wurde geändert und kann sich nun weiterhin als Registrierter Anwender anmelden.

Person löschen

Akteur

Administrator

Vorbedingung

Der Administrator ist angemeldet.

Ablauf

• Der Administrator wählt den Link Personen auflisten aus.
• Alle verfügbaren Personen werden tabellarisch angezeigt.
• Der Administrator wählt bei einer Person den Link löschen aus.
• Er wird nochmals gefragt, ob er die Person wirklich löschen will.
• Er bestätigt die Löschung
• Das System löscht die Person und alle der Person zugeordneten Daten.

Nachbedingung

Die Person wurde gelöscht und alle Daten sind aus dem System zu dieser Person entfernt worden.

Alle Personen anzeigen

Akteur

Administrator, Registrierter Anwender

Vorbedingung

Der Administrator oder der Registrierte Anwender, ist angemeldet.

Ablauf

• Der User wählt den Link Personen auflisten aus.
• Alle verfügbaren Personen werden tabellarisch angezeigt.
• Ist der Anwender ein Administrator werden die Links ansehen, ändern und löschen angezeigt
• Ist der Anwender ein Registrierter Anwender werden der Link ansehen angezeigt.

Nachbedingung

Alle bekannten Personen werden aufgelistet.

Details zu Person anzeigen

Akteur

Administrator, Registrierter Anwender

Vorbedingung

Der Administrator oder der Registrierte Anwender, ist angemeldet.

Ablauf

• Der User wählt den Link ansehen aus.
• Zu der ausgewählten Person werden alle Details (Gewichtsangaben und Personendaten) angezeigt.

Nachbedingung

Die Details wurden angezeigt.

Diese Anwendungsfälle sollten vorerst genügen um unsere Personen zu verwalten. Als nächstes müssen wir noch Gewichte eingeben können und dann haben wir alles soweit beschrieben.

Ähnliche Beiträge

In diesem Artikel werde ich die beiden Akteure vorstellen, die in der Gewichtsapplikation zum Einsatz kommen werden.

Akteure der Gewichtsapplikation

Bisher sehe ich für diese kleine Anwendung die Akteure Administrator und Registrierter Anwender vor.

Akteure

Der Administrator sorgt dafür, dass neue Registrierte Anwender im System zugelassen werden und dass nicht mehr benötigte Anwender entfernt werden.
In der ersten Ausbaustufe wird keine Registrierung oder spezielle Userverwaltung vorgesehen. Das machen wir dann mit miradlokit, denn dort müssen wir nicht alles nochmal von vorne definieren.

Der Registrierte Anwender ist eine Person, die sich am System anmelden kann und ihre eigenen Daten verändern kann. Er / Sie kann also Gewichtsangaben für eine bestimmte Person eingeben.

Damit ein Anwender zum Registrierten Anwender mutiert, muss er vom Administrator angemeldet werden.
Beispiel:

Ich will mein Gewicht mit der Applikation verwalten.
Dazu schreibe ich den Administrator an und teile ihm folgende Infos mit:

• Name
• email Adresse (zum Einloggen)

Der Administrator legt für mich einen Zugang an und vergibt mir ein Passwort. Dieses Passwort kann ich in der ersten Ausbaustufe noch nicht ändern. Auch das machen wir dann mit miradlokit…

Mir ist klar, dass dies nicht besonders benutzerfreundlich ist. Aber um überhaupt mal anfangen zu können reicht das schon aus. Ihr könnt ja gerne die Applikation um eine Registrierung und um Passwortverwaltung ergänzen. Zum CakePHP-Grundzüge zu verstehen reicht das erst mal völlig aus.

Das war es schon. Diese beiden Akteuere werden in unserer Applikation die entsprechenden Aktivitäten ausführen.

Ähnliche Beiträge

Vor ein paar Tagen hat Tim mich gefragt, ob ich die dort beschriebenen Schritte für Anfänger genauer erklären kann. Das werde ich jetzt in ein paar Artikeln durchführen.

Vorab möchte ich jedoch vorausschicken, dass die Dokumentation von CakePHP, respektive das Kochbuch, perfekt dokumentiert ist und diese Artikel hier nur ergänzen können. Nach Abschluss dieser Miniserie werde ich die Applikation nochmals mit miradlokit (unser CakePHP-basiertes Applikationsframework) nochmals aufgreifen. Dann werde ich auf Berechtigungen, Zugriffseinschränkungen, Navigationen usw. eingehen.

Vision

Wie beim letzten Mal brauchen wir eine Aufgabe die wir mit unserem Projekt umsetzen wollen.
Das mit den Gewichtsangaben ist ja schon ganz nett. Deshalb greife ich das nochmals auf.

Folgende groben Prozesse sehe ich für unser Projekt vor:

Vision

Wir werden mehrere Personen anlegen können, zu denen wir die einzelnen Gewichtsangaben pro Zeitraum hinzufügen wollen.
Also beispielsweise wiegt Alfred am 16.07.2011 83,5kg. Dann am 20.07.2011 wiegt er 82,0kg. Und am 27.12.2011 wiegt er 87kg. Diese Messwerte hat er in das System eingegeben. Der arme Kerl hat wohl zu viel Weihnachten gefeiert, dann muss er wohl wieder etwas mehr Bewegung in seinen Alltag einfliessen lassen

Gut, wenn die Gewichtsangaben eingegeben worden sind, wollen wir uns den Gewichtsverlauf in tabelarischer und in grafischer Form ansehen können.

Wir haben also grob drei Geschäftsprozesse die wir umsetzen wollen:

• Person verwalten
  Hierunter fallen die Anwendungsfälle Person anlegen, ändern, ansehen und löschen.
• Gewicht eingeben
  Zu einer ausgewählten Person kann die Gewichtsangabe festgelegt werden. Über eine Datumsauswahl kann der Tag ausgewählt werden und dann können die Gewichtsangaben entsprechend verewigt werden. Die einzelnen Einträge können nachträglich geändert oder gelöscht werden. Wenn eine Person gelöscht wird, dann sollen auch all die dazu angegebenen Gewichtsangaben gelöscht werden.
• Gewicht Verlauf ansehen
  Die Daten zu einer Person können in tabelarischer und grafischer Form angegeben werden. Wir werden also eine “normale” HTML-Ausgabe und eine gezeichnete Kurve, die die Werte des Gewichts beinhaltet, ausgeben.

Diese Vision packe ich nicht in etwas mehr als einer Stunde. Diesmal werde ich deshalb auf die einzelnen Schritte in einzelnen Artikeln eingehen und mir etwas mehr Zeit gönnen.

Ähnliche Beiträge