PHP Upload::size方法代码示例

 public function uploadfile()
 {
     if ($_GET['from'] == 'swfupload') {
         $uid = intval($_GET['uid']);
         $username = trim($_GET['username']);
         $token = sha1($uid . $username . formhash());
         if (!$uid || !$username || $token != $_GET['token']) {
             echo json_encode(array('state' => 0, 'info' => 'nologin'));
             exit;
         }
     } else {
         $this->_checkuser();
         $uid = $this->uid;
     }
     $config = $GLOBALS['G']['config']['output'];
     $upload = new Upload();
     $attachment = 'attach/' . date('Y') . '/' . date('m') . '/' . $upload->setfilename();
     if ($upload->save(ROOT_PATH . '/' . $config['attachdir'] . '/' . $attachment)) {
         $attachdata = array('uid' => $uid, 'attachname' => $upload->oriname(), 'attachment' => $attachment, 'attachsize' => $upload->size(), 'attachtype' => $upload->type(), 'attachtime' => time());
         $attachdata['attachid'] = $this->t('attachment')->insert($attachdata, true);
         echo json_encode(array('state' => 1, 'data' => $attachdata));
         exit;
     } else {
         echo json_encode(array('state' => 0, 'info' => 'Upload Failed(' . $upload->error . ')'));
         exit;
     }
 }

 public function action_image()
 {
     if (Core::post('photo_delete') and Auth::instance()->get_user()->delete_image() == TRUE) {
         Alert::set(Alert::SUCCESS, __('Photo deleted.'));
         $this->redirect(Route::url('oc-panel', array('controller' => 'profile', 'action' => 'edit')));
     }
     // end of photo delete
     //get image
     $image = $_FILES['profile_image'];
     //file post
     if (!Upload::valid($image) or !Upload::not_empty($image) or !Upload::type($image, explode(',', core::config('image.allowed_formats'))) or !Upload::size($image, core::config('image.max_image_size') . 'M')) {
         if (Upload::not_empty($image) && !Upload::type($image, explode(',', core::config('image.allowed_formats')))) {
             Alert::set(Alert::ALERT, $image['name'] . ' ' . __('Is not valid format, please use one of this formats "jpg, jpeg, png"'));
             $this->redirect(Route::url('oc-panel', array('controller' => 'profile', 'action' => 'edit')));
         }
         if (!Upload::size($image, core::config('image.max_image_size') . 'M')) {
             Alert::set(Alert::ALERT, $image['name'] . ' ' . __('Is not of valid size. Size is limited on ' . core::config('general.max_image_size') . 'MB per image'));
             $this->redirect(Route::url('oc-panel', array('controller' => 'profile', 'action' => 'edit')));
         }
         Alert::set(Alert::ALERT, $image['name'] . ' ' . __('Image is not valid. Please try again.'));
         $this->redirect(Route::url('oc-panel', array('controller' => 'profile', 'action' => 'edit')));
     } else {
         if ($image != NULL) {
             $user = Auth::instance()->get_user();
             // saving/uploadng zip file to dir.
             $root = DOCROOT . 'images/users/';
             //root folder
             $image_name = $user->id_user . '.png';
             $width = core::config('image.width');
             // @TODO dynamic !?
             $height = core::config('image.height');
             // @TODO dynamic !?
             $image_quality = core::config('image.quality');
             // if folder does not exist, try to make it
             if (!is_dir($root) and !@mkdir($root, 0775, TRUE)) {
                 // mkdir not successful ?
                 Alert::set(Alert::ERROR, __('Image folder is missing and cannot be created with mkdir. Please correct to be able to upload images.'));
                 return FALSE;
                 // exit function
             }
             // save file to root folder, file, name, dir
             if ($file = Upload::save($image, $image_name, $root)) {
                 // resize uploaded image
                 Image::factory($file)->orientate()->resize($width, $height, Image::AUTO)->save($root . $image_name, $image_quality);
                 // update category info
                 $user->has_image = 1;
                 $user->last_modified = Date::unix2mysql();
                 $user->save();
                 Alert::set(Alert::SUCCESS, $image['name'] . ' ' . __('Image is uploaded.'));
             } else {
                 Alert::set(Alert::ERROR, $image['name'] . ' ' . __('Icon file could not been saved.'));
             }
             $this->redirect(Route::url('oc-panel', array('controller' => 'profile', 'action' => 'edit')));
         }
     }
 }

 /**
  * CRUD controller: CREATE
  */
 public function action_create()
 {
     $this->auto_render = FALSE;
     $this->template = View::factory('js');
     if (!isset($_FILES['image'])) {
         $this->template->content = json_encode('KO');
         return;
     }
     $image = $_FILES['image'];
     if (core::config('image.aws_s3_active')) {
         require_once Kohana::find_file('vendor', 'amazon-s3-php-class/S3', 'php');
         $s3 = new S3(core::config('image.aws_access_key'), core::config('image.aws_secret_key'));
     }
     if (!Upload::valid($image) or !Upload::not_empty($image) or !Upload::type($image, explode(',', core::config('image.allowed_formats'))) or !Upload::size($image, core::config('image.max_image_size') . 'M')) {
         if (Upload::not_empty($image) and !Upload::type($image, explode(',', core::config('image.allowed_formats')))) {
             $this->template->content = json_encode(array('msg' => $image['name'] . ' ' . sprintf(__('Is not valid format, please use one of this formats "%s"'), core::config('image.allowed_formats'))));
             return;
         }
         if (!Upload::size($image, core::config('image.max_image_size') . 'M')) {
             $this->template->content = json_encode(array('msg' => $image['name'] . ' ' . sprintf(__('Is not of valid size. Size is limited to %s MB per image'), core::config('image.max_image_size'))));
             return;
         }
         $this->template->content = json_encode(array('msg' => $image['name'] . ' ' . __('Image is not valid. Please try again.')));
         return;
     } elseif ($image != NULL) {
         // saving/uploading img file to dir.
         $path = 'images/cms/';
         $root = DOCROOT . $path;
         //root folder
         $image_name = URL::title(pathinfo($image['name'], PATHINFO_FILENAME));
         $image_name = Text::limit_chars(URL::title(pathinfo($image['name'], PATHINFO_FILENAME)), 200);
         $image_name = time() . '.' . $image_name;
         // if folder does not exist, try to make it
         if (!file_exists($root) and !@mkdir($root, 0775, true)) {
             // mkdir not successful ?
             $this->template->content = json_encode(array('msg' => __('Image folder is missing and cannot be created with mkdir. Please correct to be able to upload images.')));
             return;
             // exit function
         }
         // save file to root folder, file, name, dir
         if ($file = Upload::save($image, $image_name, $root)) {
             // put image to Amazon S3
             if (core::config('image.aws_s3_active')) {
                 $s3->putObject($s3->inputFile($file), core::config('image.aws_s3_bucket'), $path . $image_name, S3::ACL_PUBLIC_READ);
             }
             $this->template->content = json_encode(array('link' => Core::config('general.base_url') . $path . $image_name));
             return;
         } else {
             $this->template->content = json_encode(array('msg' => $image['name'] . ' ' . __('Image file could not been saved.')));
             return;
         }
         $this->template->content = json_encode(array('msg' => $image['name'] . ' ' . __('Image is not valid. Please try again.')));
     }
 }

 public function action_add()
 {
     $user_id = $this->user->id;
     if (empty($user_id)) {
         $this->redirect('/');
     }
     $article = new Model_Article();
     $article->title = Arr::get($_POST, 'title');
     $article->description = Arr::get($_POST, 'description');
     $article->text = Arr::get($_POST, 'text');
     $cover = Arr::get($_FILES, 'cover');
     $errors = FALSE;
     $table_values = array();
     if ($article->title != '') {
         $table_values['title'] = array('value' => $article->title);
     } else {
         $errors = TRUE;
     }
     if ($article->description != '') {
         $table_values['description'] = array('value' => $article->description);
     } else {
         $errors = TRUE;
     }
     if ($article->text != '') {
         $table_values['text'] = array('value' => $article->text);
     } else {
         $errors = TRUE;
     }
     if (!Upload::valid($cover) or !Upload::not_empty($cover) or !Upload::type($cover, array('jpg', 'jpeg', 'png')) or !Upload::size($cover, '10M')) {
         $table_values['cover'] = TRUE;
         $errors = TRUE;
     }
     if ($errors) {
         // $this->view["editor"] = View::factory('templates/articles/editor', array("storedNodes" => $table_values['text']['value']));
         $content = View::factory('templates/articles/new', $this->view);
         $this->template->content = View::factory("templates/articles/wrapper", array("active" => "newArticle", "content" => $content));
         return false;
     }
     // getting new name for cover
     $article->cover = $this->methods->save_cover($cover);
     $article->user_id = $user_id;
     $article->is_published = true;
     // FIXME изменить, когда будет доступны режимы публикации
     $article->insert();
     // redirect to new article
     $this->redirect('/article/' . $article->id);
 }

 public function action_image()
 {
     //get image
     $image = $_FILES['profile_image'];
     //file post
     if (!Upload::valid($image) or !Upload::not_empty($image) or !Upload::type($image, explode(',', core::config('image.allowed_formats'))) or !Upload::size($image, core::config('image.max_image_size') . 'M')) {
         if (Upload::not_empty($image) && !Upload::type($image, explode(',', core::config('image.allowed_formats')))) {
             Alert::set(Alert::ALERT, $image['name'] . ' ' . __('Is not valid format, please use one of this formats "jpg, jpeg, png"'));
             $this->request->redirect(Route::url('oc-panel', array('controller' => 'profile', 'action' => 'edit')));
         }
         if (!Upload::size($image, core::config('image.max_image_size') . 'M')) {
             Alert::set(Alert::ALERT, $image['name'] . ' ' . __('Is not of valid size. Size is limited on ' . core::config('general.max_image_size') . 'MB per image'));
             $this->request->redirect(Route::url('oc-panel', array('controller' => 'profile', 'action' => 'edit')));
         }
         Alert::set(Alert::ALERT, $image['name'] . ' ' . __('Image is not valid. Please try again.'));
         $this->request->redirect(Route::url('oc-panel', array('controller' => 'profile', 'action' => 'edit')));
     } else {
         if ($image != NULL) {
             $user_id = Auth::instance()->get_user()->id_user;
             // saving/uploadng zip file to dir.
             $root = DOCROOT . 'images/users/';
             //root folder
             $image_name = $user_id . '.png';
             $width = core::config('image.width');
             // @TODO dynamic !?
             $height = core::config('image.height');
             // @TODO dynamic !?
             $image_quality = core::config('image.quality');
             // if folder doesnt exists
             if (!file_exists($root)) {
                 mkdir($root, 775, true);
             }
             // save file to root folder, file, name, dir
             if ($file = Upload::save($image, $image_name, $root)) {
                 // resize uploaded image
                 Image::factory($file)->resize($width, $height, Image::AUTO)->save($root . $image_name, $image_quality);
             }
             Alert::set(Alert::SUCCESS, $image['name'] . ' ' . __('Image is uploaded.'));
             $this->request->redirect(Route::url('oc-panel', array('controller' => 'profile', 'action' => 'edit')));
         }
     }
 }

 protected function _save_image($image, $directory)
 {
     if (!Upload::valid($image) || !Upload::not_empty($image) || !Upload::type($image, array('jpg', 'jpeg', 'png', 'gif')) || !Upload::size($image, '2M')) {
         return false;
     }
     if (!is_dir($directory)) {
         mkdir($directory, 0777, true);
     }
     if ($file = Upload::save($image, NULL, $directory)) {
         try {
             $filename = Text::random('alnum', 20) . '.jpg';
             Image::factory($file)->save($directory . $filename);
             unlink($file);
             return $filename;
         } catch (ErrorException $e) {
             // ...
         }
     }
     return false;
 }

 public function testUpload()
 {
     $this->instance->init();
     $this->serverHandler->expects($this->once())->method('name')->willReturn('tests/samsonos.png');
     $this->serverHandler->expects($this->once())->method('size')->willReturn('1003');
     $this->serverHandler->expects($this->once())->method('file')->willReturn(file_get_contents('tests/samsonos.png'));
     $this->serverHandler->expects($this->once())->method('type')->willReturn('png');
     $upload = new Upload(array(), null, $this->instance);
     $upload->upload($filePath, $uploadName, $fileName);
     $this->assertTrue($upload->extension('png'));
     $this->assertEquals($upload->extension(), 'png');
     $this->assertEquals($upload->mimeType(), 'png');
     $this->assertEquals($upload->size(), 1003);
     $this->assertEquals($fileName, 'tests/samsonos.png');
     $this->assertEquals($upload->realName(), 'tests/samsonos.png');
     $this->assertNotNull($filePath);
     $this->assertNotNull($uploadName);
     $this->assertNotNull($upload->path());
     $this->assertNotNull($upload->name());
     $this->assertNotNull($upload->fullPath());
 }

 public function action_add()
 {
     $file = $_FILES['image'];
     if (!Upload::valid($file)) {
         $ret = array('status' => 'error', 'msg' => '不是有效的文件');
         $this->content = json_encode($ret, JSON_UNESCAPED_UNICODE);
         return;
     } elseif (!Upload::not_empty($file)) {
         $ret = array('status' => 'error', 'msg' => '上传文件为空');
         $this->content = json_encode($ret, JSON_UNESCAPED_UNICODE);
         return;
     } elseif (!Upload::type($file, array('jpg', 'png'))) {
         $ret = array('status' => 'error', 'msg' => '文件格式只能为jpg,png');
         $this->content = json_encode($ret, JSON_UNESCAPED_UNICODE);
         return;
     } elseif (!Upload::size($file, '8M')) {
         $ret = array('status' => 'error', 'msg' => '文件大小不能超过8M');
         $this->content = json_encode($ret, JSON_UNESCAPED_UNICODE);
         return;
     }
     $this->_add($file);
     $this->redirect(Request::$referrer);
 }

 /**
  * Creates or updates the current image
  *
  * If $key is passed, the record will be assumed to exist
  * and an update will be executed, even if the model isn't loaded().
  *
  * @param   mixed  $key
  * @return  $this
  */
 public function save($key = null)
 {
     $new = !$this->loaded() && !$key;
     if ($new) {
         if (!$this->file || !Upload::not_empty($this->file)) {
             throw new Kohana_Exception(__('No image'));
         } else {
             if (!Upload::size($this->file, Kohana::config('image.filesize'))) {
                 throw new Kohana_Exception(__('Image too big (limit :size)', array(':size' => Kohana::config('image.filesize'))));
             } else {
                 if (!Upload::type($this->file, Kohana::config('image.filetypes'))) {
                     throw new Kohana_Exception(__('Invalid image type (use :types)', array(':types' => implode(', ', Kohana::config('image.filetypes')))));
                 }
             }
         }
     }
     parent::save($key);
     // Some magic on created images only
     if ($new) {
         // Make sure we have the new target directory
         $new_path = Kohana::config('image.path') . URL::id($this->id);
         if (!is_dir($new_path)) {
             mkdir($new_path, 0777, true);
             chmod($new_path, 0777);
         }
         if (is_writable($new_path)) {
             $new_path = rtrim($new_path, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
         } else {
             throw new Kohana_Exception(get_class($this) . ' can not write to directory');
         }
         // New file name with some random postfix for hard to guess filenames
         !$this->postfix and $this->postfix = Text::random('alnum', 8);
         $new_file = $this->id . '_' . $this->postfix . Kohana::config('image.postfix_original') . '.jpg';
         // Rename and move to correct directory using image id
         $old_path = Kohana::config('image.upload_path');
         $old_file = $this->file;
         if (!rename($old_path . $old_file, $new_path . $new_file)) {
             throw new Kohana_Exception(get_class($this) . ' could not move uploaded image');
         }
         $this->file = $new_file;
         // Start creating images
         $this->_generate_images($new_path . $new_file);
         parent::save();
     }
     return $this;
 }

 /**
  * size() should throw an exception of the supplied max size is invalid
  *
  * @test
  * @covers upload::size
  * @expectedException Kohana_Exception
  */
 public function test_size_throws_exception_for_invalid_size()
 {
     $this->setEnvironment(array('_FILES' => array('unit_test' => array('error' => UPLOAD_ERR_OK, 'name' => 'Unit_Test File', 'type' => 'image/png', 'tmp_name' => Kohana::find_file('tests', 'test_data/github', 'png'), 'size' => filesize(Kohana::find_file('tests', 'test_data/github', 'png'))))));
     Upload::size($_FILES['unit_test'], '1DooDah');
 }

 public function copyFiles($settings, $gid)
 {
     //Допустимые типы
     $validTypes = array('image/jpg', 'image/jpeg', 'image/gif', 'image/wbmp');
     //Поле с которого происходит выбор файлов
     Upload::$index = 'images';
     //Максимальный размер в кб
     Upload::$size = 15000;
     //Передача типов в класс
     Upload::validType($validTypes);
     //Проверка валидности файлов
     $files = Upload::validate();
     //Загрузка во временную директорию
     $result = Upload::uploadFiles($files, 'tmp', true);
     Bufer::add(array('result' => $result));
     $dir_galery_pic = 'uploads/images/galery/' . $gid . '/pic';
     $dir_galery_thumb = 'uploads/images/galery/' . $gid . '/thumb';
     //Если есть файлы, прошедшие проверку
     if (!empty($result['valid'])) {
         foreach ($result['valid'] as $file) {
             $image = $file['hashname'] . '.' . $file['ext'];
             $preview_w = $settings['preview_w'];
             $preview_h = $settings['preview_h'];
             $quality = isset($settings['quality']) ? $settings['quality'] : 100;
             $imageInfo = getimagesize($file['fullpath'], $quality);
             $img = new Images($file['fullpath']);
             $resizeThumb = $img->resize($preview_w, $preview_h, $dir_galery_thumb, $image);
             $width = isset($settings['resize_w']) ? $settings['resize_w'] : $imageInfo[0];
             $height = isset($settings['resize_h']) ? $settings['resize_h'] : $imageInfo[1];
             $img = new Images($file['fullpath']);
             $resizeBig = $img->resize($width, $height, $dir_galery_pic, $image);
             if (isset($settings['watermark_text'])) {
                 $alfa = $settings['water_set']['fontAlpha'];
                 $position = $settings['water_set']['position'];
                 $align = $settings['water_set']['align'];
                 $font = $settings['water_set']['fontFamily'];
                 $size = $settings['water_set']['fontSize'];
                 $color = $settings['water_set']['fontColor'];
                 $margin = $settings['water_set']['margin'];
                 $text = $settings['watermark_text'];
                 $img = new Images($dir_galery_pic . '/' . $image);
                 $img->waterSettings(array('fontAlpha' => $alfa, 'fontSize' => $size, 'fontFamily' => $font, 'fontColor' => $color, 'position' => $position, 'align' => $align, 'margin' => 10));
                 $arrInfo = $img->waterMarkText($text, $dir_galery_pic, false);
             }
             if (isset($settings['watermark_image'])) {
                 $alfa = $settings['water_set']['imgAlpha'];
                 $position = $settings['water_set']['position'];
                 $align = $settings['water_set']['align'];
                 $margin = $settings['water_set']['margin'];
                 $image = $settings['watermark_image'];
                 $img = new Images($dir_galery_pic . '/' . $image);
                 $img->waterSettings(array('imgAlpha' => $alfa, 'position' => $position, 'align' => $align, 'margin' => 10));
                 $arrInfo = $img->waterMarkImg($image, $dir_galery, false);
             }
             $images[] = array('pic' => $dir_galery_pic . '/' . $image, 'thumb' => $dir_galery_thumb . '/' . $image);
             Upload::deleteFile($file['fullpath']);
         }
     }
     if (isset($images) && isset($gid)) {
         $result = $this->addImagesOnDb($gid, $images);
     }
 }

 /**
  * returns true if file is of valid type.
  * Its used to check file sent to user from advert usercontact
  * @param array file
  * @return BOOL 
  */
 public static function is_valid_file($file)
 {
     //catch file
     $file = $_FILES['file'];
     //validate file
     if ($file !== NULL) {
         if (!Upload::valid($file) or !Upload::not_empty($file) or !Upload::type($file, array('jpg', 'jpeg', 'png', 'pdf', 'doc', 'docx')) or !Upload::size($file, '3M')) {
             return FALSE;
         }
         return TRUE;
     }
 }

 /**
  * Tests Upload::size
  *
  * @test
  * @dataProvider provider_size
  * @covers upload::size
  * @param string $field the files field to test
  * @param string $bytes valid bite size
  * @param array $environment set the $_FILES array
  * @param $expected what to expect
  */
 function test_size($field, $bytes, $environment, $expected)
 {
     $this->setEnvironment($environment);
     $this->assertSame($expected, Upload::size($_FILES[$field], $bytes));
 }

 public function action_uploadmarkimg()
 {
     $dir = SLINEDATA . '/mark';
     //水印图片存储目录
     if (!is_dir($dir)) {
         mkdir($dir);
     }
     $path_info = pathinfo($_FILES['Filedata']['name']);
     $filename = 'mark.' . $path_info['extension'];
     Upload::$default_directory = $dir;
     //默认保存文件夹
     Upload::$remove_spaces = true;
     //上传文件删除空格
     $file = $_FILES['Filedata'];
     $arr = array();
     if (Upload::valid($file) && Upload::size($file, "500KB") && Upload::type($file, array('jpg', 'png', 'gif'))) {
         if (Upload::save($file, $filename)) {
             $arr['success'] = 'true';
             $arr['bigpic'] = $GLOBALS['$cfg_basehost'] . '/data/mark/' . $filename;
         }
     } else {
         $arr['success'] = 'false';
         $arr['msg'] = '上传失败,请检查图片大小,图片格式.';
     }
     echo json_encode($arr);
 }

 /**
  * returns true if file is of valid type.
  * Its used to check file sent to user from advert usercontact
  * @return BOOL 
  */
 public function is_valid_file($file)
 {
     //catch file
     $file = $_FILES['file'];
     //validate file
     if ($file !== NULL) {
         if (!Upload::valid($file) or !Upload::not_empty($file) or !Upload::type($file, array('jpg', 'jpeg', 'png', 'pdf', 'doc', 'docx')) or !Upload::size($file, core::config('image.max_image_size') . 'M')) {
             return FALSE;
         }
         return TRUE;
     }
 }