PHP File di Sistema di Gestione

StackOverflow https://stackoverflow.com/questions/1072665

Domanda

Abbiamo bisogno di creare un file di interfaccia di gestione che si integra con il client attuale sito web costruito su cakephp.

Il file manager deve solo permettere agli utenti di vedere i file che hanno i permessi.

L'utente sarà in grado di caricare i file(di qualsiasi dimensione) e altri utenti di scaricare i file (se consentito dalle autorizzazioni).

Questo non è un problema per molti sistemi di gestione dei file che si possono acquistare, ma nessuno che mi può trovare integrerà con la loro corrente di registro nel sistema.Il cliente vuole solo agli utenti di accedere una volta per accedere al proprio pannello utente e i loro file.Quindi, per quanto posso vedere la nostra unica opzione è creare un file di interfaccia per la gestione di noi stessi.

Quali sono alcune delle opzioni che abbiamo per consentire il caricamento tramite PHP?Ho capito che abbiamo bisogno di aumentare il php limite di upload, ma c'è un soffitto che php/apache permetterà?

Il file sarà probabilmente cap out a circa 150MB se è rilevante, tuttavia, ci possono essere situazioni in cui i file sono di dimensioni più grandi.

Inoltre, quali sono le cose da fare e da non fare di file upload/controllo su un server Linux?

Suppongo che non ho una vera 'specifico' di domande, ma vorrei qualche consiglio su dove cominciare e alcune delle insidie tipiche ci incorrere in.

È stato utile?

Soluzione

La gestione dei File è abbastanza facile, in realtà.Qui ci sono alcuni suggerimenti che possono puntare nella giusta direzione.

Prima di tutto, se questo è un carico equilibrato web server situazione, è necessario intensificare la complessità di un po ' di tutto per mettere i file in un unico luogo.Se questo è il caso, contattarmi e sarò felice di inviarvi il nostro super-light file server/client usiamo per la stessa situazione.

Ci sono un paio di variabili si vuole agire per consentire più grande di upload.Mi consiglia di utilizzare apache direttive per limitare tali modifiche a un file particolare:

<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>

Architettura:

Creare una tabella di database che memorizza alcune informazioni su ogni file.

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

Che cosa è Owner_Field e Owner_Key?Un modo semplice per dire che "l'entità" il proprietario del file.In questo caso non c'erano più tipi di file che vengono caricati.Nel tuo caso, un semplice User_ID il campo può essere adeguata.

Lo scopo di immagazzinare il proprietario, in modo che è possibile limitare chi può scaricare e cancellare il file.Che sarà di fondamentale importanza per proteggere il download.

Qui è un esempio di classe che possono essere utilizzati per accettare l'upload di file da browser.Avrai bisogno di modificarlo in base alle esigenze, naturalmente.

Ci sono un paio di cose da notare sul codice riportato di seguito.Dal momento che questo viene utilizzato con un'Applicazione Server e File Server, ci sono un paio di cose a "sostituire".

  1. Tutte le occorrenze di App::CallAPI(...) dovrà essere sostituita con una query o di un insieme di query che fare la "stessa cosa".
  2. Tutte le occorrenze di App::$FS->... dovrà essere sostituito con il file corretto di gestione delle funzioni in PHP come move_uploaded_file, readfile, ecc...

Ecco.Tenete a mente che ci sono le funzioni che permettono di vedere i file di proprietà di un determinato utente, eliminare i file, e così via e così via.Una spiegazione più dettagliata, in fondo...

<?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']);
        }
    }

}

Note:

Si prega di tenere presente che questa classe NON implementare la sicurezza.Si presuppone che il chiamante ha autenticato Owner_Field e Owner_Key prima di chiamare FileClient::Serve(...) ecc...

E 'un po' tardi, quindi, se alcune di queste non ha senso, basta lasciare un commento.Hanno una grande serata, e spero che questo aiuta alcuni.

PS.L'interfaccia utente può essere semplice tabelle di upload di file con campi, ecc..O si potrebbe essere di fantasia e utilizzare un flash uploader...

Altri suggerimenti

Mi consiglia di avere uno sguardo alla seguente comunità-ha contribuito CakePHP esempi di codice:

qui è una buona scelta.È necessario installare un client ed un singolo file php sul server.Ma scorre veloce!!!

http://the-sync-star.com/

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top