PHP système de gestion de fichiers
https://stackoverflow.com/questions/1072665
-
21-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Nous devons créer une interface de gestion de fichiers qui intègre avec les clients site actuel construit sur CakePHP.
Le gestionnaire de fichiers ne doit laisser les utilisateurs voient les fichiers qu'ils ont des autorisations aussi.
L'utilisateur sera en mesure de télécharger des fichiers (de toute taille) et ont d'autres utilisateurs téléchargent ces fichiers (si les autorisations permettent).
est pas un problème pour de nombreux systèmes de gestion de fichiers que nous pouvons acheter, mais aucun que je peux trouver intégrera avec leur journal en cours dans le système. Le client ne veut que les utilisateurs de se connecter une fois pour accéder à leur PC utilisateur et leurs fichiers. Donc, pour autant que je peux voir notre seule option est de construire nous-mêmes une interface de gestion de fichiers.
Quels sont quelques-unes des options que nous avons pour permettre les téléchargements en utilisant PHP? Je comprends que nous devons augmenter la limite de téléchargement de php, mais est-il un plafond php / apache permettra?
Les fichiers plafonnera probablement sur environ 150 Mo si cela est pertinent, mais il peut y avoir des situations où la taille des fichiers sera plus grande.
En outre quelles sont les choses à faire et à ne pas faire de téléchargement de fichiers / contrôle sur un serveur Linux?
Je suppose que je n'ai pas vraies questions « spécifiques », mais je voudrais quelques conseils sur où commencer et quelques-uns des pièges typiques nous rencontrer.
La solution
La gestion des fichiers est assez facile, en fait. Voici quelques suggestions qui peuvent vous orienter dans la bonne direction.
Tout d'abord, si cela est une charge situation serveur web équilibré, vous aurez besoin d'intensifier la complexité un peu afin de mettre les fichiers dans un lieu commun. Si tel est le cas, ping-moi et je serai heureux de vous envoyer notre serveur de fichiers super-léger / client que nous utilisons pour cette même situation.
Il y a quelques variables que vous voulez affecter afin de permettre des téléchargements plus importants. Je recommande d'utiliser les directives apache pour limiter ces changements à un fichier particulier:
<Directory /home/deploy/project/uploader>
php_value max_upload_size "200M"
php_value post_max_size "200M"
php_value max_input_time "1800"
# this one depends on how much processing you are doing to the file
php_value memory_limit "32M"
</Directory>
Architecture:
Créer une table de base de données qui stocke des informations sur chaque fichier.
CREATE TABLE `File` (
`File_MNID` int(10) unsigned NOT NULL AUTO_INCREMENT,
`Owner_Field` enum('User.User_ID', 'Resource.Resource_ID') NOT NULL,
`Owner_Key` int(10) unsigned NOT NULL,
`ContentType` varchar(64) NOT NULL,
`Size` int(10) NOT NULL,
`Hash` varchar(40) NOT NULL,
`Name` varchar(128) NOT NULL,
PRIMARY KEY (`File_MNID`),
KEY `Owner` (`Owner_Field`,`Owner_Key`)
) ENGINE=InnoDB
Qu'est-ce et Owner_Field Owner_Key? Une façon simple de dire ce que « entité » possède le fichier. Dans ce cas précis, il y avait plusieurs types de fichiers en cours de téléchargement. Dans votre cas, un simple champ peut être suffisant User_ID.
Le but de stocker le propriétaire est que vous pouvez limiter qui peut télécharger et supprimer le fichier. Ce sera crucial pour la protection des téléchargements.
Voici une classe d'échantillon qui peut être utilisé pour accepter les téléchargements de fichiers à partir du navigateur. Vous aurez besoin de le modifier en fonction, bien sûr.
Il y a quelques petites choses à noter sur le code suivant. Comme il est utilisé avec un serveur d'applications et un serveur de fichiers, il y a quelques petites choses à « remplacer ».
- Toutes les occurrences de devra
App::CallAPI(...)être remplacée par une requête ou un ensemble de requêtes qui font la « même chose ». - Toutes les occurrences de devra
App::$FS->...être remplacé par les fonctions de gestion des fichiers corrects en PHP tels quemove_uploaded_file,readfile, etc ...
Ici, il est. Gardez à l'esprit qu'il ya des fonctions ici qui vous permettent de voir les fichiers appartenant à un utilisateur donné, supprimer les fichiers, et ainsi de suite et ainsi de suite. Plus d'explications en bas ...
<?php
class FileClient
{
public static $DENY = '/\.ade$|\.adp$|\.asp$|\.bas$|\.bat$|\.chm$|\.cmd$|\.com$|\.cpl$|\.crt$|\.exe$|\.hlp$|\.hta$|\.inf$|\.ins$|\.isp$|\.its$| \.js$|\.jse$|\.lnk$|\.mda$|\.mdb$|\.mde$|\.mdt,\. mdw$|\.mdz$|\.msc$|\.msi$|\.msp$|\.mst$|\.pcd$|\.pif$|\.reg$|\.scr$|\.sct$|\.shs$|\.tmp$|\.url$|\.vb$|\.vbe$|\.vbs$|vsmacros$|\.vss$|\.vst$|\.vsw$|\.ws$|\.wsc$|\.wsf$|\.wsh$/i';
public static $MAX_SIZE = 5000000;
public static function SelectList($Owner_Field, $Owner_Key)
{
$tmp = App::CallAPI
(
'File.List',
array
(
'Owner_Field' => $Owner_Field,
'Owner_Key' => $Owner_Key,
)
);
return $tmp['Result'];
}
public static function HandleUpload($Owner_Field, $Owner_Key, $FieldName)
{
$aError = array();
if(! isset($_FILES[$FieldName]))
return false;
elseif(! is_array($_FILES[$FieldName]))
return false;
elseif(! $_FILES[$FieldName]['tmp_name'])
return false;
elseif($_FILES[$FieldName]['error'])
return array('An unknown upload error has occured.');
$sPath = $_FILES[$FieldName]['tmp_name'];
$sHash = sha1_file($sPath);
$sType = $_FILES[$FieldName]['type'];
$nSize = (int) $_FILES[$FieldName]['size'];
$sName = $_FILES[$FieldName]['name'];
if(preg_match(self::$DENY, $sName))
{
$aError[] = "File type not allowed for security reasons. If this file must be attached, please add it to a .zip file first...";
}
if($nSize > self::$MAX_SIZE)
{
$aError[] = 'File too large at $nSize bytes.';
}
// Any errors? Bail out.
if($aError)
{
return $aError;
}
$File = App::CallAPI
(
'File.Insert',
array
(
'Owner_Field' => $Owner_Field,
'Owner_Key' => $Owner_Key,
'ContentType' => $sType,
'Size' => $nSize,
'Hash' => $sHash,
'Name' => $sName,
)
);
App::InitFS();
App::$FS->PutFile("File_" . $File['File_MNID'], $sPath);
return $File['File_MNID'];
}
public static function Serve($Owner_Field, $Owner_Key, $File_MNID)
{
//Also returns the name, content-type, and ledger_MNID
$File = App::CallAPI
(
'File.Select',
array
(
'Owner_Field' => $Owner_Field,
'Owner_Key' => $Owner_Key,
'File_MNID' => $File_MNID
)
);
$Name = 'File_' . $File['File_MNID'] ;
//Content Header for that given file
header('Content-disposition: attachment; filename="' . $File['Name'] . '"');
header("Content-type:'" . $File['ContentType'] . "'");
App::InitFS();
#TODO
echo App::$FS->GetString($Name);
}
public static function Delete($Owner_Field, $Owner_Key, $File_MNID)
{
$tmp = App::CallAPI
(
'File.Delete',
array
(
'Owner_Field' => $Owner_Field,
'Owner_Key' => $Owner_Key,
'File_MNID' => $File_MNID,
)
);
App::InitFS();
App::$FS->DelFile("File_" . $File_MNID);
}
public static function DeleteAll($Owner_Field, $Owner_Key)
{
foreach(self::SelectList($Owner_Field, $Owner_Key) as $aRow)
{
self::Delete($Owner_Field, $Owner_Key, $aRow['File_MNID']);
}
}
}
Notes:
S'il vous plaît garder à l'esprit que cette classe ne met pas la sécurité. Il suppose que l'appelant a un Owner_Field et Owner_Key authentifié avant d'appeler etc ... FileClient::Serve(...)
Il est un peu tard, donc si certains de cela n'a pas de sens, il suffit de laisser un commentaire. Bonne soirée, et j'espère que cela aide certains.
PS. L'interface utilisateur peut être des tables simples et les champs de téléchargement de fichiers, etc .. Ou vous pourriez être de fantaisie et d'utiliser un flash ... Uploader
Autres conseils
Je recommande d'avoir un regard sur les CakePHP exemples de code contribué communautaires suivants:
ici est bon choix. Il vous faut installer un client PC et un seul serveur de fichiers php. Mais il court vite!
