Към съдържанието

Написване на клас за File Upload

  • nma
  • 14 177 прочитания

Урокът е от архива на сайта и е писан преди години. Някои бутони и менюта в програмите вече може да изглеждат различно.

Казано просто class-а е серия от функции, които работят ръка за ръка, за създаването на изходен резултат. Причината, класа да се справя блестящо с ъплоуда на файлове, е че съществуват тонове функции, които някой може да напише, като всичките са взаимнозависими от изходния резултат който предлагат, преди финалния резултат да бъде определен.

Какво е class и защо се нуждая от него?

Казано просто class-а е серия от функции, които работят ръка за ръка, за създаването на изходен резултат. Причината, класа да се справя блестящо с ъплоуда на файлове, е че съществуват тонове функции, които някой може да напише, като всичките са взаимно зависими от изходния резултат, който предлагат преди финалния резултат да бъде определен. Поради тази причина пишем клас вместо 10 функции.

Друга красота на класа е, че можете да извикате всяка от характеристиките (свойствата) вътре в класа,. Примерно, с този class, ще има 'x' броя функции, всички играещи своята роля в изходния резултат от процеса на upload . Ако желаете да използвате класа само за да проверите размера на файла, без да upload-вате на сървъра. Ако желаете само да получите файловото разширение и да го потвърдите, то се оказва, че и това може.

Преди да напишем клас, или каквото и да е, трябва да планираме. Нека да премислим, от какво се нуждаем за да направим class-а ефективен. Ще се нуждаем от аранжиране на функции, всички проверяващи (потвърждаващи) някакъв сорт процеси, смесващи тези процеси, общуващи помежду си. Да направим стъпка напред и да разгледаме, какви индивидуални функции ще напишем днес.

Проверяване на файлово разширение
Проверяване на размера на файла
Намиране размера на файла
Намиране на максимално допустимия размер на файла
Проверяване на потребителските ъплоудвани файлове
Проверка за съществуване на файл
Определяне на upload директорията
Определяне на upload log директория
Upload процес със и без проверка

Ако все още се питате, защо се нуждаете от class, отговорът е прост. Някога писали ли сте огромен код, в който всичко е взаимно свързано, с идеята да се изпълни някакъв изходен резултат? Разбира се, че сте писали и знаете в какъв досаден, къртовски труд може да се превърне това. Когато за първи път пишете клас, това си е доста трудоемко и време отнемащо, но след това никога няма да Ви се наложи да го пишете отново. Просто го извиквате и останалото е история. Classes заедно с functions, ще направят живота Ви по-лек. След казаното до тук, нека да започнем.
<?php
class Upload_Files {

var $temp_file_name;
var $file_name;
var $upload_dir;
var $upload_log_dir;
var $max_file_size;
var $banned_array;
var $ext_array;
?>


Горният отрязък от код е началото на класа. Трябва да стартирате всички класове с думата 'class'. Директно след думата 'class' е името на класа. Можете да го кръстите, както Ви харесва, но за това упражнение, ще го кръстим 'Upload_Class'. Следваща името на класа е отварящата скоба за класа. Тя казва на PHP - "Хей класа ми започва, действай".

Веднага под началото на класа, трябва да декларираме нашите променливи за този клас. Основно това са променливите, които могат да бъдат включени извън class-а, от крайния потребител. Точно както функциите (functions) могат да приемат аргументи, така могат и класовете, но с малко различен синтаксис. Тези класове казват на класа, че тези променливи могат да бъдат дефинирани от потребителя. Променливите, използвани от класа, трябва първо да бъдат дефинирани като 'var $variable_name'.

Function #1 (Проверка на файловото разширение)

<?php
function validate_extension() {
//SECTION #1
$file_name = trim($this->file_name);
$extension = strtolower(strrchr($file_name,"."));
$ext_array = $this->ext_array;
$ext_count = count($ext_array);

//SECTION #2
if (!$file_name) {
return false;
} else {
if (!$ext_array) {
return true;
} else {
foreach ($ext_array as $value) {
$first_char = substr($value,0,1);
if ($first_char <> ".") {
$extensions[] = ".".strtolower($value);
} else {
$extensions[] = strtolower($value);
}
}

//SECTION #3
foreach ($extensions as $value) {
if ($value == $extension) {
$valid_extension = "TRUE";
}
}

//SECTION #4
if ($valid_extension) {
return true;
} else {
return false;
}}}}
?>


Тази първа функция, ще провери дали файловото разширение е валидно. Как става това? Да хвърлим по един поглед на всяка секция от кода, за да открием как. За да използувате тази функция, трябва да включите и двете: името на файла и един масив с допустимите разширения. Ако желаете да приемете всички файлови разширения, не се нуждаете да изпращате масив за разширенията. В края на този урок, ще проследим как да извикаме целия class и всяка функция в class-а, но засега проучваме class-а, за да имаме ясна представа от това мощно средство.

<?php
//SECTION #1
$file_name = trim($this->file_name);
$extension = strtolower(strrchr($file_name,"."));
$ext_array = $this->ext_array;
$ext_count = count($ext_array);
?>




Section #1
Първата секция от тази функция, дефинира променливите, които ще бъдат използвани от функцията.

$file_name = Истинското име на файла декларирано от потребителя при викането на класа.
$extension = Разширението, взето от името на файла. Функцията strrchr() ще открие последния срещан character и ще чете от тази точка нататък.
$ext_array = масива деклариран от потребителя при викането на класа.
$ext_count = Броят на елементите във масив на разширенията.

<?php
//SECTION #2
if (!$file_name) {
return false;
} else {
if (!$ext_array) {
return true;
} else {
foreach ($ext_array as $value) {
$first_char = substr($value,0,1);
if ($first_char <> ".") {
$extensions[] = ".".strtolower($value);
} else {
$extensions[] = strtolower($value);
}
}
?>


Section #2
Тази секция от функцията стартира процеса на потвърждаване на файловото разширение. Първо проверяваме дали $file_name съществува, и ако е продължаваме, иначе затваряме функцията и връща резултат false, защото без име на файла, няма какво да изследваме. След това проверяваме дали $ext_array съществува. Ако не, се предполага, че сте възприели всички файлови разширения. След това стартираме нашият първи foreach() цикъл. Този цикъл, ще подсигури, че файловото разширение започва а малки букви, а ако не е ще бъде променено за да отразява това изискване и ще бъде изпратено на друг масив кръстен $extensions.

<?php
//SECTION #3
foreach ($extensions as $value) {
if ($value == $extension) {
$valid_extension = "TRUE";
}}
?>


Section #3
Сега стартираме още един цикъл. Използуваме ново дефинирания и организиран $extensions масив, като фокус на цикъла. В цикъла if е твърдението, използвано да провери дали разширението е валидно. Основно if твърдението казва, че ако файловото разширение отговаря на някоя от стойностите екстрактната от допустимите разширения, то $valid_extension променливата приема стойност true. Това е ядрото на нашия цикъл, с което се открива дали е допустим нашия файл или не е.

<?php
//SECTION #4
if ($valid_extension) {
return true;
} else {
return false;
}}}}
?>


Section #4
Последната секция от функцията е отрязък от кода, четящ дали $valid_extension променливата съществува. Ако е, функцията връща true и файлът е добре, иначе функцията връща false. Откриваме (3) затварящи скоби в края на кода, (2) за горните if-elseif твърдения и последната за затваряне на функцията.
---------------------------

Function #2 (Validation of File Size)


<?php
function validate_size() {
$temp_file_name = trim($this->temp_file_name);
$max_file_size = trim($this->max_file_size);

if (!$temp_file_name) {
$size = filesize($temp_file_name);
if ($size > $max_file_size) {
return false;
} else {
return true;
}
} else {
return false;
}
}
?>


Функцията е значително по-малка от предишната и ще преминем през нея изцяло. Първите (2) реда дефинират $temp_file_name и $max_file_size, които трябва да са зададени от крайния потребител. Следва проверка. Проверяваме дали $temp_file_name съществува, и ако не, функцията завършва и връща false. Ако $temp_file_name съществува, вземаме размера на качения файл и го сравняваме с допустимия размер - $max_file_size. Ако файлът е по-голям от позволеното функцията връща "false", иначе връща "true" и размера на файла.
--------------------------

Function #3 (Дали този файл вече съществува?)

<?php
function existing_file() {
$file_name = trim($this->file_name);
$upload_dir = $this->get_upload_directory();

if ($upload_dir == "ERROR") {
return true;
} else {
$file = $upload_dir . $file_name;
if (file_exists($file)) {
return true;
} else {
return false;
}
}
}
?>


Тази функция ще провери, дали файла за upload, не съществува вече на сървъра. Тази функция е добавена при заявка и няма много да се спираме на нея. По същество, би трябвало да имате някакъв вид преименуваща система, която да използвате, преди и да сте помислили за upload на сървъра. Примерно, когато допускаме потребител да upload-ва на сървъра, там някъде трябва да има запис в база данни, относно този файл. Така че може да вземем id номера от database и да преименуваме файла, предоставен от потребителя на id номера. (т.е. потребителя предоставя hello_world.php и той се променя на 452.php, защото това е 452-ят запис в DB) Това е много добра система за именуване, защото е изключително лесно да триете и подменяте записите. Тук няма преименуваща функция, включена в този class, но Вие лесно бихте могли да добавите.

Първите (2) реда от тази функция, декларират $file_name и $upload_dir. След това стартираме if-elseif проверка. Първо проверяваме if : имаме ли валидна директория за upload. Ако нямаме, се извършва exit на функцията и връщане на true. Знам, че изглежда наопаки да връщаме true, когато файла съществува или има грешка, но за тази функция върши работа. Името на функцията е 'exisiting_file()', така че ако върне true, значи казва че file exists и не би трябвало да се ъплоудва. Ако upload directory е валидна, продължаваме към следващата секция на if-elseif проверка.

Сега описваме пътя до нашия файл с the file name intact(цялостен,цял), т.е. $file = $upload_dir . $file_name. След това имаме малка част код, която използува PHP функцията file_exists(). Ако file exists, връщаме true, иначе връщаме false и файла е готов да бъде ъплоудван.

-------------------------------
Function #4 (Екстракт на размера на файла)


<?php
function get_file_size() {
//SECTION #1
$temp_file_name = trim($this->temp_file_name);
$kb = 1024;
$mb = 1024 * $kb;
$gb = 1024 * $mb;
$tb = 1024 * $gb;

//SECTION #2
if ($temp_file_name) {
$size = filesize($temp_file_name);
if ($size < $kb) {
$file_size = "$size Bytes";
}
elseif ($size < $mb) {
$final = round($size/$kb,2);
$file_size = "$final KB";
}
elseif ($size < $gb) {
$final = round($size/$mb,2);
$file_size = "$final MB";
}
elseif($size < $tb) {
$final = round($size/$gb,2);
$file_size = "$final GB";
} else {
$final = round($size/$tb,2);
$file_size = "$final TB";
}
} else {
$file_size = "ERROR: NO FILE PASSED TO get_file_size()";
}
return $file_size;
}
?>

Тази функция ще изследва файла, за да изведе размерите на файла. Кода е разбит на (2) секции за по-лесно разбиране.

<?php
//SECTION #1
$temp_file_name = trim($this->temp_file_name);
$kb = 1024;
$mb = 1024 * $kb;
$gb = 1024 * $mb;
$tb = 1024 * $gb;
?>




Section #1
Първата секция от тази функция дефинира Вашите променливи. Приемаме временно име за файла, както и определяме размера му с цел сравняване. Размера на файла е дефиниран в bytes.

<?php
//SECTION #2
if ($temp_file_name) {
$size = filesize($temp_file_name);
if ($size < $kb) {
$file_size = "$size Bytes";
}
elseif ($size < $mb) {
$final = round($size/$kb,2);
$file_size = "$final KB";
}
elseif ($size < $gb) {
$final = round($size/$mb,2);
$file_size = "$final MB";
}
elseif($size < $tb) {
$final = round($size/$gb,2);
$file_size = "$final GB";
} else {
$final = round($size/$tb,2);
$file_size = "$final TB";
}
} else {
$file_size = "ERROR: NO FILE PASSED TO get_file_size()";
}
return $file_size;
}
?>


Section #2

Втората секция на тази функция стартира нашия процес за проверка и изход. Първо проверяваме дали променливата $temp_file_name е валидна, ако не функцията връща грешка. В $temp_file_name, получаваме размера на файла във bytes от PHP функцията filesize(). Искаме да имаме възможност да проверим нашия log file.

Function #5 (Екстракт на Max File Size)

<?php
function get_max_size() {
$max_file_size = trim($this->max_file_size);
$kb = 1024;
$mb = 1024 * $kb;
$gb = 1024 * $mb;
$tb = 1024 * $gb;

if ($max_file_size) {
if ($max_file_size < $kb) {
$max_file_size = "max_file_size Bytes";
}
elseif ($max_file_size < $mb) {
$final = round($max_file_size/$kb,2);
$max_file_size = "$final KB";
}
elseif ($max_file_size < $gb) {
$final = round($max_file_size/$mb,2);
$max_file_size = "$final MB";
}
elseif($max_file_size < $tb) {
$final = round($max_file_size/$gb,2);
$max_file_size = "$final GB";
} else {
$final = round($max_file_size/$tb,2);
$max_file_size = "$final TB";
}
} else {
$max_file_size = "ERROR: NO SIZE PARAMETER PASSED TO get_max_size()";
}
return $max_file_size;
}
?>


Няма да разбиваме функцията на секции, защото тя е почти като горната функция. Единственото различно нещо е, че връща максималния размер на файла. Тази функция е подходяща за извикване в случай, че потребителят се опитва да upload-не file, който е прекалено голям. Бихте могли да напишете грешка и да използувате тази функция да покаже максималния допустим размер на файла.

----------------------------
Function #6 (Validation of The User)


<?php
function validate_user() {
//SECTION #1
$banned_array = $this->banned_array;
$ip = trim($_SERVER['REMOTE_ADDR']);
$cpu = gethostbyaddr($ip);
$count = count($banned_array);

//SECTION #2
if ($count < 1) {
return true;
} else {
foreach($banned_array as $key => $value) {
if ($value == $ip ."-". $cpu) {
return false;
} else {
return true;
}}}}
?>


Тази функция, ще проверява кой потребител upload-ва. Силното в този class е, че можете да блокирате потребители да ъплоудват на Вашия сървър. Използва се техниката на прихващане на IP. Всеки път, когато потребител upload-ва файл, информацията за адреса му и размера на файла, дата, и час, се записват в текстов файл на сървъра. Ако Ви се случи да имате проблем с някой, upload-ващ потребител, можете да изтриете файла, да проверите, кой е upload-вал и да добавите IP във Вашият списък със забранени потребители. Ако потребителят е открит в този списък, той или тя, няма да имат възможност за upload на файлове.

<?php
function validate_user() {
//SECTION #1
$banned_array = $this->banned_array;
$ip = trim($_SERVER['REMOTE_ADDR']);
$cpu = gethostbyaddr($ip);
$count = count($banned_array);
?>




Section #1
Тази част дефинира, всички Ваши променливи, които ще бъдат използвани . Първо дефинираме "banned array". Ако никой не попада във Вашия списък на забрана съдържан във масив можете да изпратите празен масив или не изпращайте тази променлива със class. Ако масива за забрана не е открит , функцията ще предположи, че upload-а е разрешен за всички и никакви проверки няма да произтекат. Второ взимаме потребителския IP адрес открит чрез REMOTE_ADDR. Нашата последна променлива, определя броя на елементите в потребителския масив за забрана .

<?php
//SECTION #2
if ($count < 1) {
return true;
} else {
foreach($banned_array as $key => $value) {
if ($value == $ip ."-". $cpu) {
return false;
} else {
return true;
}}}}
?>


Section #2
Втората секция стартира процеса на потвърждаване. Първо се проверява има ли някой във Вашия списък за забрана на потребители. Ако няма функцията връща true, означава че потребителя има право на upload. Иначе казано цикъла forach() е стартиран за масива и стойността на всеки ключ в масива се сравнява с $ip - $cpu name. Ако тези две (2) стойности съвпадат, функцията връща false и потребителят няма да има възможност за upload на файлове.

Function #7 (Verify The Upload Directory)


<?php
function get_upload_directory() {
//SECTION #1
$upload_dir = trim($this->upload_dir);

//SECTION #2
if ($upload_dir) {
$ud_len = strlen($upload_dir);
$last_slash = substr($upload_dir,$ud_len-1,1);
if ($last_slash <> "/") {
$upload_dir = $upload_dir."/";
} else {
$upload_dir = $upload_dir;
}

//SECTION #3
$handle = @opendir($upload_dir);
if ($handle) {
$upload_dir = $upload_dir;
closedir($handle);
} else {
$upload_dir = "ERROR";
}
} else {
$upload_dir = "ERROR";
}
return $upload_dir;
}
?>



Тази функция ще вземе upload директорията, която зададохте по-преди и ще я провери. Първо иска да види дали директорията, която сте въвели е форматирана коректно и тогава ще направи проверка да види, дали директорията съществува. Разделихме кода на (3) части, за по-лесно обяснение на ключовите секции.

<?php
//SECTION #1
$upload_dir = trim($this->upload_dir);
?>


Section #1
Това което дефинираме тук е upload директорията, която трябва да е зададена от Вас.

<?php
//SECTION #2
if ($upload_dir) {
$ud_len = strlen($upload_dir);
$last_slash = substr($upload_dir,$ud_len-1,1);
if ($last_slash <> "/") {
$upload_dir = $upload_dir."/";
} else {
$upload_dir = $upload_dir;
}
?>


Section #2
Тази секция отново стартира нашия процес за проверка състоянието на директорията, в която ще се upload-не файла. Първо проверява дали upload директорията присъства. Ако е така функцията ще продължи, иначе отива накрая и връща "invalid file directory". След това намираме дължината на името на директорията използувайки PHP функцията strlen(). Причината за извършване на това действие, е че се нуждаем да открием дължината на низа, за да изведем последния символ от низа. След това използуваме PHP функцията substr(), за да изведем последния символ от името на директорията. Ще забележите ($last_slash = substr($upload_dir,$ud_len-1,1);) че извеждаме (1) от дължината на низа на директорията и имаме добри причини да направим това. Забележете, че желаем да изведем последния символ от името на директорията. strlen() функцията пресмята броя на символа започвайки от '1', но когато пресмятате мястото на символа в низа стартирате с '0', и оттук минус '1' от цялата дължина. Ако не направим това, не бихме селектирали последния character и в крайна сметка нищо.

Причината да селектираме последния character е проста. Искаме да видим дали завършва с "/". Ако не завършва, трябва да добавим, за да работи функцията нормално. Така че настройваме променливата $last_slash, която селектира последния character и ако последния character не съответства на "/", добавяме, в противен случай не правим нищо.

<?php
//SECTION #3
$handle = @opendir($upload_dir);
if ($handle) {
$upload_dir = $upload_dir;
closedir($handle);
} else {
$upload_dir = "ERROR";
}
} else {
$upload_dir = "ERROR";
}
return $upload_dir;
}
?>


Section #3
В тази финална секция проверяваме upload директорията. Настройваме дръжка (handle) за отваряне на директорията. След това виждаме дали дръжката (handle) ще се отвори наистина. Ако да, затваряме директорията и връщаме името и, иначе връщаме съобщение за грешка, за да уведомим потребителя, че има проблем с директорията. След като проверките са заели местата си, затваряме скобите и продължаваме.

*Забелязвате символа @ пред opendir() функцията. Този символ е използван да скрие всички грешки асоциирани с функцията. Забележете, ако upload директорията е невалидна, opendir() функцията ще произведе съобщение за грешка, защото тя се обърква, но не желаем потребителя да види това съобщение и ние я потискаме, за да няма конфликт с нашия код.

Function #8 (Verify The Upload Log Directory)

<?php
function get_upload_log_directory() {
$upload_log_dir = trim($this->upload_log_dir);
if ($upload_log_dir) {
$ud_len = strlen($upload_log_dir);
$last_slash = substr($upload_log_dir,$ud_len-1,1);
if ($last_slash <> "/") {
$upload_log_dir = $upload_log_dir."/";
} else {
$upload_log_dir = $upload_log_dir;
}
$handle = @opendir($upload_log_dir);
if ($handle) {
$upload_log_dir = $upload_log_dir;
closedir($handle);
} else {
$upload_log_dir = "ERROR";
}
} else {
$upload_log_dir = "ERROR";
}
return $upload_log_dir;
}
?>


Няма да разбиваме функцията. Причината е, защото това е същата функция през която преминахме, с изключение че тя проверява и връща директория, в която се писват логовете. Всеки път, когато потребителя ъплоудва файл, .txt файл е записван на сървъра с текущата дата. Ако файла вече съществува за текущата дата просто добавяме в края.

Причината: кой, какво и кога ъплоудва. Ако някой upload-не virus, ще имате възможност да проследите потребителя и да вкарате IP-то му в забранения списък. Това е идеална функция за всеки клас (да я притежава) или script поради това, че се занимава с взаимодействието между публиката и сървъра.



------------------
Function #9 (Upload The File With No Validation)

<?php
function upload_file_no_validation() {
//SECTION #1
$temp_file_name = trim($this->temp_file_name);
$file_name = trim(strtolower($this->file_name));
$upload_dir = $this->get_upload_directory();
$upload_log_dir = $this->get_upload_log_directory();
$file_size = $this->get_file_size();
$ip = trim($_SERVER['REMOTE_ADDR']);
$cpu = gethostbyaddr($ip);
$m = date("m");
$d = date("d");
$y = date("Y");
$date = date("m/d/Y");
$time = date("h:i:s A");

//SECTION #2
if (($upload_dir == "ERROR") OR ($upload_log_dir == "ERROR")) {
return false;
} else {
if (is_uploaded_file($temp_file_name)) {
if (move_uploaded_file($temp_file_name,$upload_dir . $file_name)) {
$log = $upload_log_dir.$y."_".$m."_".$d.".txt";
$fp = fopen($log,"a+");
fwrite($fp,"
$ip-$cpu | $file_name | $file_size | $date | $time");
fclose($fp);
return true;
} else {
return false;
}
} else {
return false;
}}}
?>

Това е една от двете ключови функции в този class. Тази функция и следващата са тези, които ще опитат uploat на Вашия файл.
След 8 предварителни функции и 'x' броя реда код, започваме да напипваме хубавата част. Тази функция ще upload-не Вашия файл. Единственото нещо, което утвърждава са (2) директории за upload. Ако са некоректни, файла няма да се upload-не. Ако не Ви "дреме" за размера на файла, типа му, потребителите, или дали файла съществува, тогава използувайте тази функция за upload.

Функцията е разделена на (2) части с цел по-лекото и усвояване. Да хвърлим един поглед, какво може да става вътре в една такава функция.

<?php
//SECTION #1
$temp_file_name = trim($this->temp_file_name);
$file_name = trim(strtolower($this->file_name));
$upload_dir = $this->get_upload_directory();
$upload_log_dir = $this->get_upload_log_directory();
$file_size = $this->get_file_size();
$ip = trim($_SERVER['REMOTE_ADDR']);
$cpu = gethostbyaddr($ip);
$m = date("m");
$d = date("d");
$y = date("Y");
$date = date("m/d/Y");
$time = date("h:i:s A");
?>


Section #1
Функцията трябва да дефинира (12) различни променливи, за да може партито да започне. Долу е показан списък с променливите, с кратко описание към тях.

$temp_file_name = Временното име на файла.
$file_name = Реалното име на файла.
$upload_dir = Името на директорията за качване взето от функцията get_upload_directory().
$upload_log_dir = Името на директорията за логове.
$file_size = Размерите на файла.
$ip = IP-то на потребителя.
$cpu = Интернет хоста на потребителя
$m = Текущия месец от 2числа (2)
$d = Текущия ден от 2числа (2)
$y = Текущата година 4-цифри (4)
$date = Днешната дата 01/01/2003
$time = Текущото време 11:12:56 AM


<?php
//SECTION #2
if (($upload_dir == "ERROR") OR ($upload_log_dir == "ERROR")) {
return false;
} else {
if (is_uploaded_file($temp_file_name)) {
if (move_uploaded_file($temp_file_name,$upload_dir . $file_name)) {
$log = $upload_log_dir.$y."_".$m."_".$d.".txt";
$fp = fopen($log,"a+");
fwrite($fp,"
$ip-$cpu | $file_name | $file_size | $date | $time");
fclose($fp);
return true;
} else {
return false;
}
} else {
return false;
}}}
?>

Section #2
Това е секцията от кода, в която магията се случва. Тя стартира процесите на валидация и upload. Първо прави проверка да се убеди че upload директориите са валидни, и ако не са, функцията връща false и exits, иначе продължаваме към следващия проверяващ процес.

Искаме да се убедим, че файла се е upload-нал в "temp" директория. Вижте във Вашият php.ini файл, секцията питаща за "temp upload directory" и където файла се upload-ва. След като е upload-нат, трябва да го вземаме от тази директория и да го преместим в коректната директория. Така че правим проверка, за да се убедим че файла се е upload-нал във временната директорията с използването на функцията is_uploaded_file(). Ако се е ъплоуаднал продължаваме, в противен случай функцията връща "false" и завършва.

Сега трябва да проверим дали файла е имал възможността да бъде преместен от временната директория в коректната, като използваме функцията move_uploaded_file(). Ако е, тогава upload-а е готов, функцията връща true, и е въведен запис в днешния (текущия) log файл. Log файл се съхранява за всеки ден, когато е ъплоудван файл. Всеки log файл ще бъде с името на текущата дата. (т.е. 07192003.txt) Ако файла вече съществува, добавяме дата към края му, иначе стартираме нов файл. Във всеки log файл информацията, която се съхранява е ip адреса, интернет провайдъра, името на файла, размера на файла, датата на upload, и времето на upload разделени с '|'.

Ако преместването на файла пропадне функцията ще върне "false" и след това "exit". Нека отидем сега на последната функция за този class.

Function #10 (Upload The File With Validation)

<?php
function upload_file_with_validation() {
//SECTION #1
$temp_file_name = trim($this->temp_file_name);
$file_name = trim(strtolower($this->file_name));
$upload_dir = $this->get_upload_directory();
$upload_log_dir = $this->get_upload_log_directory();
$file_size = $this->get_file_size();
$ip = trim($_SERVER['REMOTE_ADDR']);
$cpu = gethostbyaddr($ip);
$m = date("m");
$d = date("d");
$y = date("Y");
$date = date("m/d/Y");
$time = date("h:i:s A");
$existing_file = $this->existing_file(); //<-Add On
$valid_user = $this->validate_user(); //<-Add On
$valid_size = $this->validate_size(); //<-Add On
$valid_ext = $this->validate_extension(); //<-Add On

//SECTION #2
if (($upload_dir == "ERROR") OR ($upload_log_dir == "ERROR")) {
return false;
}
elseif ((((!$valid_user) OR (!$valid_size) OR (!$valid_ext) OR ($existing_file)))) {
return false;
} else {
if (is_uploaded_file($temp_file_name)) {
if (move_uploaded_file($temp_file_name,$upload_dir . $file_name)) {
$log = $upload_log_dir.$y."_".$m."_".$d.".txt";
$fp = fopen($log,"a+");
fwrite($fp,"
$ip-$cpu | $file_name | $file_size | $date | $time");
fclose($fp);
return true;
} else {
return false;
}
} else {
return false;
}}}
?>


Тази функция е същата, като една от тези които разгледахме, с изключение че добавя допълнителни 6 реда код. Имаме (4) допълнителни променливи в section #1. Всеки един е показан долу с кратко описание.



$existing_file = Връща "true" ако файл с такова има вече съществува, "false" ако не.
$valid_user = Проверява дали такъв потребител съществува.
$valid_size = За проверка дали размера на файла е валиден.
$valid_ext = Извиква validate_extension() за да провери дали разширението на файла е от позволените.
Тези (4) реда са необходими, така че можем да валидираме дали да допуснем файла за upload. Друг добавен ред от кода е в Section #2 и е показан долу.

<?php
elseif ((((!$valid_user) OR (!$valid_size) OR (!$valid_ext) OR ($existing_file)))) {
return false;
?>


Това са нашите основни стъпки от процеса за проверка. If проверява дали потребителя е реален, размера на файла е валиден, разширението на файла е валидно и дали файла вече съществува на сървъра. Ако всички проверки са верни, се преминава към същия процес описан преди за upload на файл и запис на нов ред в log файла за тази дата. Сега всичко, което трябва да направим е да извикаме class-а.

------------------
Извикване на Class-а

Включването на класа във Вашия файл става с include() функцията. Долу е процеса на извикване на class-а.

<?php
//SECTION #1
$upload_class = new Upload_Files;
$upload_class->temp_file_name = trim($_FILES['upload']['tmp_name']);
$upload_class->file_name = trim(strtolower($_FILES['upload']['name']));
$upload_class->upload_dir = "uploads/";
$upload_class->upload_log_dir = "uploads/upload_logs/";
$upload_class->max_file_size = 524288;
$upload_class->banned_array = array("");
$upload_class->ext_array = array(".jpg",".gif",".jpeg",".png");

//SECTION #2
$valid_ext = $upload_class->validate_extension();
$valid_size = $upload_class->validate_size();
$valid_user = $upload_class->validate_user();
$max_size = $upload_class->get_max_size();
$file_size = $upload_class->get_file_size();
$upload_directory = $upload_class->get_upload_directory();
$upload_log_directory = $upload_class->get_upload_log_directory();
$upload_file = $upload_class->upload_file_with_validation();
?>


Section #1
В първа секция, трябва да стартираме class-а и да дефинираме нашите class променливи. Когато стартирате ново копие на class-а, трябва да зададете променлива за класа. В този случай нашата основна променлива е $upload_class, и тогава стартираме класа. Напишете нов за да може PHP да разбере, че стартирате нов class и се обърнете към името на класа. След това трябва да дефинираме всички променливи за нашия class. За дефиниране на променливите, трябва да стартираме нашата $upload_class. Трябва да оставите PHP да разбере, че вашето желание е тази променлива да бъде изпратена на class-а. Припомнете си, в самото начало на class-а, променливите които бяха дефинирани. Е сега ще ги активираме. Да направим бърз преглед на всяка променлива.

$upload_class->temp_file_name = trim($_FILES['upload']['tmp_name']); [set the temp file name]
$upload_class->file_name = trim(strtolower($_FILES['upload']['name'])); [set the actual file name]
$upload_class->upload_dir = "uploads/"; [set the upload directory]
$upload_class->upload_log_dir = "uploads/upload_logs/"; [set the upload log directory]
$upload_class->max_file_size = 524288; [set the max file size - .5MB or 512KB]
$upload_class->banned_array = array(""); [set the banned users array]
$upload_class->ext_array = array(".jpg",".gif",".jpeg",".png"); [set the acceptable file extensions]
Не е нужно да дефинирате всяка променлива, ако не планирате да използувате проверяващи скриптове. Ако ще правите само upload, се нуждаете само от първите (4) променливи, вместо от всичките (7). Още помнете, че ако нямате списък със забранени потребители, няма нужда да дефинирате такъв и ако ще приемате всички файлови разширения, няма нужда от такава променлива.


<?php
//SECTION #2
$valid_ext = $upload_class->validate_extension();
$valid_size = $upload_class->validate_size();
$valid_user = $upload_class->validate_user();
$max_size = $upload_class->get_max_size();
$file_size = $upload_class->get_file_size();
$upload_directory = $upload_class->get_upload_directory();
$upload_log_directory = $upload_class->get_upload_log_directory();
$upload_file = $upload_class->upload_file_with_validation();
?>


Section #2
Втората секция извиква всички функции в class-а. Няма нужда да се извикват всички функции, но показваме, че бихте могли да го направите. Добра причина за извикване на всички функции е че бихте могли да заредите системата за връщане на отговорите. В този ред на мисли бихте могли да кажете if !$valid_ext и да върнете съобщение за грешка на потребителя уведомяващо го, че файловото разширение е некоректно. Можете да извикате само $file_size и да върнете числото на потребителя. Единствената функция, която Ви е необходима за upload е последния ред стартиращ с $upload_file. Ако извиквате функцията с проверка, използувайте последния ред горе, иначе без да използвате долния.

<?php
$upload_file = $upload_class->upload_file_with_no_validation();
?>




Споделете: