Problem z praktycznym zastosowaniem programowania obiektowego Opcje

[Jarod]

Dość dokładnie przerobiłem http://helion.pl/ksiazki/php5zp.htm, materiały na necie. Dużo też Was się pytałem na forum. Mam napisaną aplikacje strukturalnie. Chciałbym ją przepisać obiektowo i mam z tym problemy. Konkretnie z praktycznym zastosowaniem wiedzy teoretycznej..

Załóżmy, że mamy aplikację, która umożliwia logowanie. Jest też możliwy przydział uprawnień (tylko do odczytu lub do odczytu i zapisu) do konkretnego modułu aplikacji. Jedną z opcji aplikacji jest możliwośc wyświetlania spisu użytkowników aplikacji, z możliwością edycji danych, zmiany hasła, zmiany uprawnień, kasowania konta, itp.

Nie wiem jak się za to zabrać. Rozumiem, że pisząc aplikację obiektowo wszystko jest odwzorowane na obiekt. Czyli jeśli chciałbym wyświetlić listę użytkowników systemu, to pobieram wszystkich użytkowników z bazy, dla każdego tworzę obiekt i zapisuję do kolekcji a potem iterując ją wyświetlam na ekranie?

Jak się za to zabrać? Może macie jakieś praktyczne wskazówki? Będę wdzięczny.

Ten post edytował J4r0d 9.11.2006, 22:15:16

[envp]

Propozycja moja jest taka:
-Tworzysz sobie klase User, ktora zawiera takie pola jakie powinna miec.. dla przykladu pokaze jak ja tozrbilem:

[PHP] pobierz, plaintext 
<?php
class client
{
  private $_sCompany;
  private $_sStreet;
  private $_sCity;
  private $_sZipCode;
  private $_iNip;
  private $_sEmail;
  private $_sPassword;
  private $_sTelephone;
  private $_iId;
  private $_oMySQL;
  private $_bNotification;
 
  public function __construct($iClientId=null,$aClientData=null)
  {
	//if(!is_int($iClient))
	  //throw new CleintException('must be int');
	if($iClientId != null)
	{
	  $this->_iId = $iClientId;
	  require('_configure.php');
	  $this->_oMySQL = new DataBaseMySQL($aDBParams);
	  $this->_oMySQL->query("SELECT * from client where id='$iClientId'");
	  $aClientData = $this->_oMySQL->fetch();
	}
 
	$this->setCompany($aClientData['company']);
	$this->setStreet($aClientData['street']);
	$this->setCity($aClientData['city']);
	$this->setZipCode($aClientData['zip']);
	$this->setNip($aClientData['nip']);
	$this->setEmail($aClientData['email']);
	$this->setPassword($aClientData['password']);
	$this->setTelephone($aClientData['telephone']);
	$this->setNotification($aClientData['want_email']);
  }
 
  public function setCompany($sCompany)
  {
	$this->_sCompany = $sCompany;
  }
 
  public function setStreet($sStreet)
  {
   $this->_sStreet = $sStreet;
  }
 
  public function setCity($sCity)
  {
   $this->_sCity = $sCity;
  }
 
  public function setZipCode($sZip)
  {
	$this->_sZipCode = $sZip;
  }
 
  public function setNip($iNip)
  {
	$this->_iNip = $iNip;
  }
 
  public function setEmail($sEmail)
  {
	$this->_sEmail = $sEmail;
  }
 
  public function setPassword($sPassword)
  {
	$this->_sPassword = $sPassword;
  }
 
  public function setTelephone($sTelephone)
  {
	$this->_sTelephone = $sTelephone;
  }
 
  public function setNotification($bNotify)
  {
	$this->_bNotification = (int)(bool)(int)$bNotify;
  }
 
  public function getCompany()
  {
	return $this->_sCompany;
  }
 
  public function getStreet()
  {
	return $this->_sStreet;
  }
 
  public function getCity()
  {
	return $this->_sCity;
  }
 
  public function getZipCode()
  {
	return $this->_sZipCode;
  }
 
  public function getNip()
  {
	return $this->_iNip;
  }
 
  public function getEmail()
  {
	return $this->_sEmail;
  }
 
  public function getPassword()
  {
	return $this->_sPassword;
  }
 
  public function getTelephone()
  {
	return $this->_sTelephone;
  }
 
  public function getId()
  {
	return $this->_iId;
  }
 
  public function getNotification()
  {
	return $this->_bNotification;
  }
 
  public function getArrayed()
  {
 
   return array('email' => $this->_sEmail,
				'password' => $this->_sPassword,
				'company' => $this->_sCompany,
				'street' => $this->_sStreet,
				'city' => $this->_sCity,
				'zip' => $this->_sZipCode,
				'nip' => $this->_iNip,
				'telephone' => $this->_sTelephone,
				'want_email' => $this->_bNotification);
  }
 
  public function update()
  {
	$oMySQL = $this->_oMySQL;
	$oMySQL->update('client',$this->getArrayed(),"id='$this->_iId'");
  }
 
  public function delete()
  {
	$oMySQL = $this->_oMySQL;
	$oMySQL->query("DELETE from client where id='$this->_iId'");
  }
 
  public function getReports()
  {
 
   $oReportCollectioner = new ReportCollectioner();
   $oMySQL = $this->_oMySQL;
   $oMySQL->query("SELECT id from report where client_id='$this->_iId'");
   while($aRow = $oMySQL->fetch())
   {
	$oReportCollectioner->pushReport(new report($aRow['id']));
   }
 
   return $oReportCollectioner;
 
  }
 
  public function __toString()
  {
	return $this->_sCompany;
  }
 
  public function addSelf()
  {
	require('_configure.php');
 
	$this->_oMySQL = new DataBaseMySQL($aDBParams);
	$aClientData = $this->getArrayed();
	$aClientData['id'] = null;
 
	$this->_oMySQL->insert('client', $aClientData);
  }
 
 
}
?>
[PHP] pobierz, plaintext 

W klasie tej uzylem Liba do laczenia z baza, zywcem z Rapide...

dalej mamy Client Collectioner:

[PHP] pobierz, plaintext 
<?php
class ClientCollectioner implements Iterator
{
 
  private $_aClients;
  private $_bValidIterationPointer = true;
 
  public function __construct(){
  $this->_aClients = array();
  }
 
  public function rewind()
  {
	reset($this->_aClients);
	$this->_bValidIterationPointer = true;
  }
 
  public function current()
  {
	return current($this->_aClients);
  }
 
  public function key()
  {
	return key($this->_aClients);
  }
 
  public function next()
  {
	if(next($this->_aClients) === false)
	  $this->_bValidIterationPointer = false;
	else
	  $this->_bValidIterationPointer = true;
  }
 
  public function valid()
  {
	return $this->_bValidIterationPointer;
  }
 
  public function pushClient(client $oClient)
  {
	array_push($this->_aClients, $oClient);
	//sort($this->_aClients);
  }
 
  public function isFilled()
  {
	return count($this->_aClients) != 0 ? true : false;
  }
 
}
?>
[PHP] pobierz, plaintext 

i to wszystko, mozemy dodac klienta:

[PHP] pobierz, plaintext 
<?php
$aClientData = array('id' => null,
							'email' => $_POST['email'],
							'password' => md5($_POST['passwordfirst']),
							'company' => $_POST['company'],
							'street' => $_POST['street'],
							'city' => $_POST['city'],
							'zip' => $_POST['zip'],
							'nip' => $_POST['nip'],
							'telephone' => $_POST['telephone']);
 
	   $oClient = new Client(null,$aClientData);
	   $oClient->addSelf();
?>
[PHP] pobierz, plaintext 

edytowac:

[PHP] pobierz, plaintext 
<?php
$oClient = new Client($iId);
	  $oClient->setCompany($_POST['company']);
	  $oClient->setEmail($_POST['email']);
	  $oClient->setStreet($_POST['street']);
	  $oClient->setZipCode($_POST['zip']);
	  $oClient->setCity($_POST['city']);
	  $oClient->setNip($_POST['nip']);
	  $oClient->setTelephone($_POST['telephone']);
	  $oClient->update();
?>
[PHP] pobierz, plaintext 

lub usuwac:

[PHP] pobierz, plaintext 
<?php
$oClient = new Client($_GET['id']);
$oClient->delete();
?>
[PHP] pobierz, plaintext 

uff. mam nadzieje, ze zrozumiesz jak cos to sluze pomoca

ofc: co do client collectioner mozemy go uzupelnic:

[PHP] pobierz, plaintext 
<?php
$oClientCollectioner =  Utils::fillUpClientCollectioner($_GET['p'],$_GET['k']);
?>
[PHP] pobierz, plaintext 

i podac do foreach:

[PHP] pobierz, plaintext 
<?php
foreach($oClientCollectioner as $oClient)
		 {
			 ($styl=='nieparzysty')? $styl='parzysty' : $styl='nieparzysty';
		   echo '<tr class="'.$styl.'">';
			echo '<td class="dane_d" style="border-left:1px #999999 solid;">'.$oClient->getCompany().'</td>';
			echo '<td class="dane_d">'.$oClient->getNip().'</td>';
			echo '<td class="dane_d">'.$oClient->getEmail().'</td>';
			echo '<td class="dane_d">'.$oClient->getStreet().'</td>';
			echo '<td class="dane_d">'.$oClient->getZipCode().' '.$oClient->getCity().'</td>';
			echo '<td class="dane_d">';
			echo '<a href="?part=reports&action=screports&clientid='.$oClient->getId().'">Pokaż raporty</a>';
			echo '<br />';
			echo '<a href="?part=reports&action=add&clientid='.$oClient->getId().'">Dodaj raport</a>';
		 '</td>';
		  echo '</tr>';
		 }
 
   echo '</tbody></table>';
?>
[PHP] pobierz, plaintext 

Ten post edytował envp 9.11.2006, 23:21:20

[Jarod]

Nie rozumiem skąd wziąłeś to:

[PHP] pobierz, plaintext 
<?php
$oClientCollectioner =  Utils::fillUpClientCollectioner($_GET['p'],$_GET['k']);
?>
[PHP] pobierz, plaintext 

Tyle pisania, żeby zrobić dodawanie użytkownika i wyświetlanie go. Zaraz zagłębie się bardziej w ten kod. Doceniam, że chciało Ci się tyle pisać. Czyli jesli chcę wyświetlić listę użytkowników wykonuję coś podobnego:
1. Pobieram pierwszego użytkownika tworząć obiekt.
2. Ładuję ten obiekt do kolekcji.
3. Powtarzam punkt 1 i 2 n-razy (dopóki są rekordy w bazie)
4. Iterując kolekcję wyświetlam użytkowników na ekranie?

W dobrą strone idę?

[envp]

Tak, dokładnie, a fillup:

[PHP] pobierz, plaintext 
<?php
require_once('DatabaseMySQL.class.php');
require_once('ClientCollectioner.class.php');
require_once('Client.class.php');
 
final class Utils
{
 
  static public function getClientIds()
  {
	require('_configure.php');
	$oMySQL = new DataBaseMySQL($aDBParams);
	$oMySQL->query('SELECT id from client order by company asc');
	while($aRow = $oMySQL->fetch())
	  $aIds[] = (int)$aRow['id'];
	return $aIds;
  }
 
  static public function fillUpClientCollectioner($iStart=null, $iStop=null)
  {
	$aIds = Utils::getClientIds();
 
	if($iStart == null && $iStop == null){
	  $iStart = 0;
	  $iStop = count($aIds);
	}
 
 
 
	if($iStop>count($aIds))
	{
	  $iStop = count($aIds);
	}
 
	$oClientCollectioner = new ClientCollectioner();
	for($i=$iStart;$i<$iStop;$i++)
	{
	  $oClientCollectioner->pushClient(new Client($aIds[$i]));
	}
 
	return $oClientCollectioner;
  }
 
...
?>
[PHP] pobierz, plaintext 

Ten post edytował envp 10.11.2006, 00:31:01

[g00fy]

ja bym raczej nie bawil sie w takie rzeczy.
wolal bym sobie napisac klase z 40 lnijkami za pomoca phpDoctrine, i nie martwil bym sie o zadne relacje ,sql etc.

[destroyerr]

Chciałem zapytać czy jest rozsądne przy pobieraniu np. 10 klientów => 10 zapytań do bazy. Może to zły pomysł ale może lepiej przygotować tablice z Id klientów i wrzucić ją opowiednio do zapytania, korzystać z PDO i zwracać obiekty, wsadzić do tablicy zwrócić tablicę do Util::fillUpClientCollectioner() i wniej w pętli dopiero dodać do kolekcji??
I jeszcze jedno pytanie, jeśli klienci/użytkownicy należą do grup. To czy do pola klasy client::groups należy wstawić tablice z id poszczególnych grup?? Czy skorzystać z kolektora grup i w tym polu trzymać obiekt kolektora grup??

[Athlan]

destroyerr, jeżeli chodzi o grupy użytkowników, to zazwyczaj robi się 3 tabele:
- tabela userów
- tabela grup
- handler relacji user to group

Przykładowa budowa tabel:

user table:
- id usera
- nick usera
- haslo usera

groups table:
- id grupy
- nazwa grupy

handler:
- id usera
- id grupy
(na oba pola dajesz klucz priamry)

Logując uzytkownika pobierasz jego grupy z handlera, ewentualnie nazwy grup biorąc je JOIN'em przez jej id.

Zastosowanie proste, a jakże pratyczne - chyba każdy tak robi.

Pozdrawiam, Athlan

[kwiateusz]

ja bym pominal handler i w user table: dopisał id grupy wydaje mi sie ze tak jest intuicujniej .. i mniej tabel

[ikioloak]

taa ale pod warunkiem ze jeden user moze nalezec do jednej grupy. jesli moze naliczyc do wielu, to jest to relacja wiele do wielu i rozwiazanie powyzej jest poprawne.

[siemakuba]

Pytanie z innej beczki:
czy dodawanie/pobieranie klasy User nie lepiej zorganizować za pomocą magicznej metody __call()?

Montujemy metodę:

[PHP] pobierz, plaintext 
<?php
function __call($method, $params, $return)
{   
	$method = strtolower($method);
 
	if (strpos($method, 'set') === 0)
	{
		$data = '_s'.ucfirst(str_replace('set', '', $method));
		if (isset($this->$data))
		{   $this->$data = $params[0];
		}
	}
	else if (strpos($method, 'get') === 0)
	{
		$data = '_s'.ucfirst(str_replace('get', '', $method));
		$return = isset($this->$data) ? $this->$data : null;
	}
	else
	{   $return = false;
		return false;
	}
 
	return true;
}
 
// wykorzystanie
 
$obj->setName('siemakuba');
$obj->getName('siemakuba');
?>
[PHP] pobierz, plaintext 

to dość przykładowe oczywiście, ale oszczędza pisania oddzielnych metod dla poszczególnych wartość.
Używam czegoś takiego w mojej klasie AppModel i sprawdza się znakomicie. Nie wyobrażam sobie ręcznego mapowania wszystkich właściwości poszczególnych klas potomnych modelu na odpowiadające im tabele w bazie danych.

pozdr.

[ikioloak]

@siemakuba w czym twoje rozwiazanie jest lepsze od zastosowania __get i __set. Po przegladnieciu twojego kodu nie bardzo rozumiem jaki jest sens jego stosowania.

[siemakuba]

@ikioloak: to co pokazałem to mój sposób na korzystanie z metod typu:

[PHP] pobierz, plaintext 
<?php
$obj->setName('whatever');
$obj->getName();
?>
[PHP] pobierz, plaintext 

bez konieczności pisania metody do każdej właściwości klasy którą chcę w ten sposób ustawić.

Nigdzie nie napisałem, że jest to lepsze niż stosowanie metod __get i __set ;) Napisałem, że jest to lepsze niż pisanie n metod pobierających / zwracających dane z klasy. Popatrz na pierwszy post i zobacz ile tego tam jest. Można tu owszem użyć __get i __set, ale wtedy rezygnujemy z konstrukcji:

[PHP] pobierz, plaintext 
<?php
$obj->setName('whatever');
$obj->getName();
?>
[PHP] pobierz, plaintext 

na rzecz:

[PHP] pobierz, plaintext 
<?php
$obj->Name = 'whatever';
?>
[PHP] pobierz, plaintext 

bez znaczenia czy będzie to już teraz realizowane przez __get i __set czy nie.

pozdr.