Téléchargement de fichier angulaire


193

Je suis un débutant avec Angular, je veux savoir comment créer une partie de téléchargement de fichier Angular 5 , j'essaie de trouver un tutoriel ou un document, mais je ne vois rien nulle part. Une idée pour ça? Et j'ai essayé ng4-files mais cela ne fonctionne pas pour Angular 5


2
alors voulez-vous glisser-déposer ou simple Choose Filetéléchargement btn? Bdw dans les deux cas, il vous suffit de télécharger en utilisant FormData
Dhyey

4
Jetez un œil à primeng, je l'utilise depuis un moment et il fonctionne avec angular v5. primefaces.org/primeng/#/fileupload
Bunyamin Coskuner

Pour ceux qui ont juste besoin de télécharger JSON sur le client, consultez cette question: stackoverflow.com/questions/54971238/…
AnthonyW

Réponses:


427

Voici un exemple de travail pour le téléchargement de fichiers vers l'API:

Étape 1: modèle HTML (file-upload.component.html)

Définissez une balise d'entrée simple de type file. Ajoutez une fonction à (change)-event pour gérer le choix des fichiers.

<div class="form-group">
    <label for="file">Choose File</label>
    <input type="file"
           id="file"
           (change)="handleFileInput($event.target.files)">
</div>

Étape 2: Gestion du téléchargement dans TypeScript (file-upload.component.ts)

Définissez une variable par défaut pour le fichier sélectionné.

fileToUpload: File = null;

Créez la fonction que vous utilisez dans (change)-event de votre balise d'entrée de fichier:

handleFileInput(files: FileList) {
    this.fileToUpload = files.item(0);
}

Si vous souhaitez gérer la sélection multifichier, vous pouvez parcourir ce tableau de fichiers.

Créez maintenant la fonction de téléchargement de fichier en vous appelant file-upload.service:

uploadFileToActivity() {
    this.fileUploadService.postFile(this.fileToUpload).subscribe(data => {
      // do something, if upload success
      }, error => {
        console.log(error);
      });
  }

Étape 3: Service de téléchargement de fichiers (file-upload.service.ts)

En téléchargeant un fichier via la méthode POST, vous devez utiliser FormData, car vous pouvez donc ajouter un fichier à la requête http.

postFile(fileToUpload: File): Observable<boolean> {
    const endpoint = 'your-destination-url';
    const formData: FormData = new FormData();
    formData.append('fileKey', fileToUpload, fileToUpload.name);
    return this.httpClient
      .post(endpoint, formData, { headers: yourHeadersConfig })
      .map(() => { return true; })
      .catch((e) => this.handleError(e));
}

Donc, c'est un exemple de travail très simple, que j'utilise tous les jours dans mon travail.


6
@Katie avez-vous activé les polyfills?
Gregor Doroschenko

2
@GregorDoroschenko J'essayais d'utiliser un modèle avec des informations supplémentaires sur le fichier et je devais le faire pour le faire fonctionner: const invFormData: FormData = new FormData(); invFormData.append('invoiceAttachment', invoiceAttachment, invoiceAttachment.name); invFormData.append('invoiceInfo', JSON.stringify(invoiceInfo)); le contrôleur a deux paramètres correspondants, mais j'ai dû analyser le JSON dans le contrôleur. Mon contrôleur Core 2 ne prendrait pas automatiquement le modèle dans le paramètre. Ma conception originale était un modèle avec une propriété de fichier, mais je ne pouvais pas le faire fonctionner
Papa Stahl

1
@GregorDoroschenko J'ai essayé ce codecreateContrat(fileToUpload: File, newContrat: Contrat): Observable<boolean> { let headers = new Headers(); const endpoint = Api.getUrl(Api.URLS.createContrat)); const formData: FormData =new FormData(); formData.append('fileKey', fileToUpload, FileToUpload.name); let body newContrat.gup(this.auth.getCurrentUser().token); return this.http .post(endpoint, formData, body) .map(() => { return true; }) }
OnnaB

1
@GregorDoroschenko Et pour moi, ça ne marche pas. Je poste dans ws:Content-Disposition: form-data; name="fileKey"; filename="file.docx" Content-Type: application/octet-stream <file>
OnnaB

1
@OnnaB Si vous utilisez FormData pour le fichier et pour d'autres propriétés, vous devez analyser votre fichier et d'autres propriétés en tant que FormData. Vous ne pouvez pas utiliser FormData et body en même temps.
Gregor Doroschenko

23

De cette façon, j'implémente le fichier de téléchargement vers l'API Web dans le projet.

Je partage pour qui le souci.

const formData: FormData = new FormData();
formData.append('Image', image, image.name);
formData.append('ComponentId', componentId);
return this.http.post('/api/dashboard/UploadImage', formData);

Pas à pas

API Web ASP.NET

[HttpPost]
[Route("api/dashboard/UploadImage")]
public HttpResponseMessage UploadImage() 
{
    string imageName = null;
    var httpRequest = HttpContext.Current.Request;
    //Upload Image
    var postedFile = httpRequest.Files["Image"];
    //Create custom filename
    if (postedFile != null)
    {
        imageName = new String(Path.GetFileNameWithoutExtension(postedFile.FileName).Take(10).ToArray()).Replace(" ", "-");
        imageName = imageName + DateTime.Now.ToString("yymmssfff") + Path.GetExtension(postedFile.FileName);
        var filePath = HttpContext.Current.Server.MapPath("~/Images/" + imageName);
        postedFile.SaveAs(filePath);
    }
}

Formulaire HTML

<form #imageForm=ngForm (ngSubmit)="OnSubmit(Image)">

    <img [src]="imageUrl" class="imgArea">
    <div class="image-upload">
        <label for="file-input">
            <img src="upload.jpg" />
        </label>

        <input id="file-input" #Image type="file" (change)="handleFileInput($event.target.files)" />
        <button type="submit" class="btn-large btn-submit" [disabled]="Image.value=='' || !imageForm.valid"><i
                class="material-icons">save</i></button>
    </div>
</form>

Fichier TS pour utiliser l'API

OnSubmit(Image) {
    this.dashboardService.uploadImage(this.componentId, this.fileToUpload).subscribe(
      data => {
        console.log('done');
        Image.value = null;
        this.imageUrl = "/assets/img/logo.png";
      }
    );
  }

Service TS

uploadImage(componentId, image) {
        const formData: FormData = new FormData();
        formData.append('Image', image, image.name);
        formData.append('ComponentId', componentId);
        return this.http.post('/api/dashboard/UploadImage', formData);
    }

1
Quelle est votre façon de ne pas envoyer d'en-têtes?
Shalom Dahan

14

Une méthode très simple et rapide utilise ng2-file-upload .

Installez ng2-file-upload via npm. npm i ng2-file-upload --save

Au premier module d'import dans votre module.

import { FileUploadModule } from 'ng2-file-upload';

Add it to [imports] under @NgModule:
imports: [ ... FileUploadModule, ... ]

Balisage:

<input ng2FileSelect type="file" accept=".xml" [uploader]="uploader"/>

Dans vos commentaires:

import { FileUploader } from 'ng2-file-upload';
...
uploader: FileUploader = new FileUploader({ url: "api/your_upload", removeAfterUpload: false, autoUpload: true });

C'est l'utilisation la plus simple de ceci. Pour connaître toute la puissance de ce voir démo


4
comment obtenir une réponse lors du téléchargement de l'image? quelle sera la réponse, la documentation manque cette partie.
Muhammad Shahzad

7

J'utilise Angular 5.2.11, j'aime la solution fournie par Gregor Doroschenko, mais j'ai remarqué que le fichier téléchargé est de zéro octet, j'ai dû faire un petit changement pour que cela fonctionne pour moi.

postFile(fileToUpload: File): Observable<boolean> {
  const endpoint = 'your-destination-url';
  return this.httpClient
    .post(endpoint, fileToUpload, { headers: yourHeadersConfig })
    .map(() => { return true; })
    .catch((e) => this.handleError(e));
}

Les lignes suivantes (formData) ne fonctionnaient pas pour moi.

const formData: FormData = new FormData();
formData.append('fileKey', fileToUpload, fileToUpload.name);

https://github.com/amitrke/ngrke/blob/master/src/app/services/fileupload.service.ts


6

Ok, comme ce fil apparaît parmi les premiers résultats de google et pour les autres utilisateurs ayant la même question, vous n'êtes pas obligé de réactiver la roue comme indiqué par trueboroda, il y a la bibliothèque ng2-file-upload qui simplifie ce processus de téléchargement d'un fichier avec angulaire 6 et 7 tout ce que vous devez faire est:

Installez la dernière CLI angulaire

yarn add global @angular/cli

Ensuite, installez rx-compat pour des raisons de compatibilité

npm install rxjs-compat --save

Installez ng2-file-upload

npm install ng2-file-upload --save

Importez la directive FileSelectDirective dans votre module.

import { FileSelectDirective } from 'ng2-file-upload';

Add it to [declarations] under @NgModule:
declarations: [ ... FileSelectDirective , ... ]

Dans votre composant

import { FileUploader } from 'ng2-file-upload/ng2-file-upload';
...

export class AppComponent implements OnInit {

   public uploader: FileUploader = new FileUploader({url: URL, itemAlias: 'photo'});
}

Modèle

<input type="file" name="photo" ng2FileSelect [uploader]="uploader" />

Pour une meilleure compréhension, vous pouvez consulter ce lien: Comment télécharger un fichier avec Angular 6/7


1
Merci pour le lien. Le téléchargement fonctionne bien sur le bureau, mais je ne peux pas toute ma vie faire fonctionner les téléchargements sur des appareils mobiles comme iOS. Je peux sélectionner un fichier dans la pellicule, mais lorsque je le télécharge, il échoue toujours. Des idées? FYI, exécutez ceci dans le safari mobile, pas dans une application qui est installée.
ScottN

1
Salut @ScottN et vous êtes les bienvenus, peut-être que le problème vient du navigateur que vous utilisez? l'avez-vous testé avec un autre?
Mohamed Makkaoui

1
Salut @Mohamed Makkaoui merci pour la réponse. Je l'ai essayé dans Chrome sur iOS et toujours le même résultat. Je suis curieux de savoir s'il s'agit d'un problème d'en-tête lors de la publication sur le serveur? J'utilise une WebAPI personnalisée écrite en .Net et PAS AWS FYI.
ScottN

1
Bonjour @ScottN, nous ne serons pas en mesure de savoir s'il s'agit d'un problème d'en-tête tant que vous n'aurez pas débogué votre code à l'aide de ce lien developer.google.com/web/tools/chrome-devtools/… et voir le message d'erreur que vous obtenez.
Mohamed Makkaoui

6

Personnellement, je fais cela en utilisant ngx-material-file-input pour le front-end et Firebase pour le back-end. Plus précisément, C loud Storage pour Firebase pour le back-end combiné avec Cloud Firestore. Ci-dessous un exemple, qui limite le fichier à ne pas dépasser 20 Mo et n'accepte que certaines extensions de fichier. J'utilise également Cloud Firestore pour stocker des liens vers les fichiers téléchargés, mais vous pouvez ignorer cela.

contact.component.html

<mat-form-field>
  <!--
    Accept only files in the following format: .doc, .docx, .jpg, .jpeg, .pdf, .png, .xls, .xlsx. However, this is easy to bypass, Cloud Storage rules has been set up on the back-end side.
  -->
  <ngx-mat-file-input
    [accept]="[
      '.doc',
      '.docx',
      '.jpg',
      '.jpeg',
      '.pdf',
      '.png',
      '.xls',
      '.xlsx'
    ]"
    (change)="uploadFile($event)"
    formControlName="fileUploader"
    multiple
    aria-label="Here you can add additional files about your project, which can be helpeful for us."
    placeholder="Additional files"
    title="Additional files"
    type="file"
  >
  </ngx-mat-file-input>
  <mat-icon matSuffix>folder</mat-icon>
  <mat-hint
    >Accepted formats: DOC, DOCX, JPG, JPEG, PDF, PNG, XLS and XLSX,
    maximum files upload size: 20 MB.
  </mat-hint>
  <!--
    Non-null assertion operators are required to let know the compiler that this value is not empty and exists.
  -->
  <mat-error
    *ngIf="contactForm.get('fileUploader')!.hasError('maxContentSize')"
  >
    This size is too large,
    <strong
      >maximum acceptable upload size is
      {{
        contactForm.get('fileUploader')?.getError('maxContentSize')
          .maxSize | byteFormat
      }}</strong
    >
    (uploaded size:
    {{
      contactForm.get('fileUploader')?.getError('maxContentSize')
        .actualSize | byteFormat
    }}).
  </mat-error>
</mat-form-field>

contact.component.ts (partie du validateur de taille)

import { FileValidator } from 'ngx-material-file-input';
import { FormBuilder, FormGroup, Validators } from '@angular/forms';

/**
 * @constructor
 * @description Creates a new instance of this component.
 * @param  {formBuilder} - an abstraction class object to create a form group control for the contact form.
 */
constructor(
  private angularFirestore: AngularFirestore,
  private angularFireStorage: AngularFireStorage,
  private formBuilder: FormBuilder
) {}

public maxFileSize = 20971520;
public contactForm: FormGroup = this.formBuilder.group({
    fileUploader: [
      '',
      Validators.compose([
        FileValidator.maxContentSize(this.maxFileSize),
        Validators.maxLength(512),
        Validators.minLength(2)
      ])
    ]
})

contact.component.ts (partie téléchargeur de fichiers)

import { AngularFirestore } from '@angular/fire/firestore';
import {
  AngularFireStorage,
  AngularFireStorageReference,
  AngularFireUploadTask
} from '@angular/fire/storage';
import { catchError, finalize } from 'rxjs/operators';
import { throwError } from 'rxjs';

public downloadURL: string[] = [];
/**
* @description Upload additional files to Cloud Firestore and get URL to the files.
   * @param {event} - object of sent files.
   * @returns {void}
   */
  public uploadFile(event: any): void {
    // Iterate through all uploaded files.
    for (let i = 0; i < event.target.files.length; i++) {
      const randomId = Math.random()
        .toString(36)
        .substring(2); // Create random ID, so the same file names can be uploaded to Cloud Firestore.

      const file = event.target.files[i]; // Get each uploaded file.

      // Get file reference.
      const fileRef: AngularFireStorageReference = this.angularFireStorage.ref(
        randomId
      );

      // Create upload task.
      const task: AngularFireUploadTask = this.angularFireStorage.upload(
        randomId,
        file
      );

      // Upload file to Cloud Firestore.
      task
        .snapshotChanges()
        .pipe(
          finalize(() => {
            fileRef.getDownloadURL().subscribe((downloadURL: string) => {
              this.angularFirestore
                .collection(process.env.FIRESTORE_COLLECTION_FILES!) // Non-null assertion operator is required to let know the compiler that this value is not empty and exists.
                .add({ downloadURL: downloadURL });
              this.downloadURL.push(downloadURL);
            });
          }),
          catchError((error: any) => {
            return throwError(error);
          })
        )
        .subscribe();
    }
  }

règles de stockage

rules_version = '2';
service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
        allow read; // Required in order to send this as attachment.
      // Allow write files Firebase Storage, only if:
      // 1) File is no more than 20MB
      // 2) Content type is in one of the following formats: .doc, .docx, .jpg, .jpeg, .pdf, .png, .xls, .xlsx.
      allow write: if request.resource.size <= 20 * 1024 * 1024
        && (request.resource.contentType.matches('application/msword')
        || request.resource.contentType.matches('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
        || request.resource.contentType.matches('image/jpg')
        || request.resource.contentType.matches('image/jpeg')
        || request.resource.contentType.matches('application/pdf')
                || request.resource.contentType.matches('image/png')
        || request.resource.contentType.matches('application/vnd.ms-excel')
        || request.resource.contentType.matches('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'))
    }
  }
}

2
Regardez bien, mais pourquoi avez-vous besoin toString()de la déclaration contactForm?
trungk18

1
@ trungk18 vérifiez-le encore une fois, et vous avez raison, toString()c'est inutile, a édité ma réponse. Pour ceux qui liraient ce commentaire, à la fin de fileUploaderen contact.component.ts j'avais ])].toString()}). Maintenant , il est tout simplement: ])]}).
Daniel Danielecki

5
  1. HTML

    <div class="form-group">
      <label for="file">Choose File</label><br /> <input type="file" id="file" (change)="uploadFiles($event.target.files)">
    </div>

    <button type="button" (click)="RequestUpload()">Ok</button>
  1. Fichier ts
public formData = new FormData();
ReqJson: any = {};

uploadFiles( file ) {
        console.log( 'file', file )
        for ( let i = 0; i < file.length; i++ ) {
            this.formData.append( "file", file[i], file[i]['name'] );
        }
    }

RequestUpload() {
        this.ReqJson["patientId"] = "12"
        this.ReqJson["requesterName"] = "test1"
        this.ReqJson["requestDate"] = "1/1/2019"
        this.ReqJson["location"] = "INDIA"
        this.formData.append( 'Info', JSON.stringify( this.ReqJson ) )
            this.http.post( '/Request', this.formData )
                .subscribe(( ) => {                 
                });     
    }
  1. Backend Spring (fichier java)

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

@Controller
public class Request {
    private static String UPLOADED_FOLDER = "c://temp//";

    @PostMapping("/Request")
    @ResponseBody
    public String uploadFile(@RequestParam("file") MultipartFile file, @RequestParam("Info") String Info) {
        System.out.println("Json is" + Info);
        if (file.isEmpty()) {
            return "No file attached";
        }
        try {
            // Get the file and save it somewhere
            byte[] bytes = file.getBytes();
            Path path = Paths.get(UPLOADED_FOLDER + file.getOriginalFilename());
            Files.write(path, bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "Succuss";
    }
}

Nous devons créer un dossier "temp" dans le lecteur C, puis ce code imprimera le Json dans la console et enregistrera le fichier téléchargé dans le dossier créé


Comment récupérer ce fichier? Avez-vous des conseils à ce sujet?
Siddharth Choudhary

De plus, mon serveur Spring fonctionne sur 8080 et Angular sur 3000. Maintenant, quand je marque server_url comme localhost: 8080 / api / uploadForm, il dit que les cors ne sont pas autorisés!
Siddharth Choudhary

byte [] octets = fichier.getBytes (); il donnera le flux d'octets .. vous pouvez le convertir en fichier, pour le problème de cors, vous pouvez trouver une solution dans Google
Shafeeq Mohammed

5

Tout d'abord, vous devez configurer HttpClient dans votre projet Angular.

Ouvrez le fichier src / app / app.module.ts, importez HttpClientModule et ajoutez-le au tableau des importations du module comme suit:

import { BrowserModule } from '@angular/platform-browser';  
import { NgModule } from '@angular/core';
import { AppRoutingModule } from './app-routing.module';  
import { AppComponent } from './app.component';  
import { HttpClientModule } from '@angular/common/http';

@NgModule({  
  declarations: [  
    AppComponent,  
  ],  
  imports: [  
    BrowserModule,  
    AppRoutingModule,  
    HttpClientModule  
  ],  
  providers: [],  
  bootstrap: [AppComponent]  
})  
export class AppModule { }

Ensuite, générez un composant:

$ ng generate component home

Ensuite, générez un service de téléchargement:

$ ng generate service upload

Ensuite, ouvrez le fichier src / app / upload.service.ts comme suit:

import { HttpClient, HttpEvent, HttpErrorResponse, HttpEventType } from  '@angular/common/http';  
import { map } from  'rxjs/operators';

@Injectable({  
  providedIn: 'root'  
})  
export class UploadService { 
    SERVER_URL: string = "https://file.io/";  
    constructor(private httpClient: HttpClient) { }
    public upload(formData) {

      return this.httpClient.post<any>(this.SERVER_URL, formData, {  
         reportProgress: true,  
         observe: 'events'  
      });  
   }
}

Ensuite, ouvrez le fichier src / app / home / home.component.ts et commencez par ajouter les importations suivantes:

import { Component, OnInit, ViewChild, ElementRef  } from '@angular/core';
import { HttpEventType, HttpErrorResponse } from '@angular/common/http';
import { of } from 'rxjs';  
import { catchError, map } from 'rxjs/operators';  
import { UploadService } from  '../upload.service';

Ensuite, définissez les variables fileUpload et files et injectez UploadService comme suit:

@Component({  
  selector: 'app-home',  
  templateUrl: './home.component.html',  
  styleUrls: ['./home.component.css']  
})  
export class HomeComponent implements OnInit {
    @ViewChild("fileUpload", {static: false}) fileUpload: ElementRef;files  = [];  
    constructor(private uploadService: UploadService) { }

Ensuite, définissez la méthode uploadFile ():

uploadFile(file) {  
    const formData = new FormData();  
    formData.append('file', file.data);  
    file.inProgress = true;  
    this.uploadService.upload(formData).pipe(  
      map(event => {  
        switch (event.type) {  
          case HttpEventType.UploadProgress:  
            file.progress = Math.round(event.loaded * 100 / event.total);  
            break;  
          case HttpEventType.Response:  
            return event;  
        }  
      }),  
      catchError((error: HttpErrorResponse) => {  
        file.inProgress = false;  
        return of(`${file.data.name} upload failed.`);  
      })).subscribe((event: any) => {  
        if (typeof (event) === 'object') {  
          console.log(event.body);  
        }  
      });  
  }

Ensuite, définissez la méthode uploadFiles () qui peut être utilisée pour télécharger plusieurs fichiers image:

private uploadFiles() {  
    this.fileUpload.nativeElement.value = '';  
    this.files.forEach(file => {  
      this.uploadFile(file);  
    });  
}

Ensuite, définissez la méthode onClick ():

onClick() {  
    const fileUpload = this.fileUpload.nativeElement;fileUpload.onchange = () => {  
    for (let index = 0; index < fileUpload.files.length; index++)  
    {  
     const file = fileUpload.files[index];  
     this.files.push({ data: file, inProgress: false, progress: 0});  
    }  
      this.uploadFiles();  
    };  
    fileUpload.click();  
}

Ensuite, nous devons créer le modèle HTML de notre interface utilisateur de téléchargement d'images. Ouvrez le fichier src / app / home / home.component.html et ajoutez le contenu suivant:

       <div style="text-align:center; margin-top: 100px; ">

        <button mat-button color="warn" (click)="onClick()">  
            Upload  
        </button>  
    <input type="file" #fileUpload id="fileUpload" name="fileUpload" multiple="multiple" accept="image/*" style="display:none;" /></div>

Découvrez ce tutoriel et cet article


4

Exemple complet de téléchargement de fichiers en utilisant Angular et nodejs (express)

Code HTML

            <div class="form-group">
                <label for="file">Choose File</label><br/>
                <input type="file" id="file" (change)="uploadFile($event.target.files)" multiple>
            </div>

Code composant TS

uploadFile(files) {
    console.log('files', files)
        var formData = new FormData();

    for(let i =0; i < files.length; i++){
      formData.append("files", files[i], files[i]['name']);
        }

    this.httpService.httpPost('/fileUpload', formData)
      .subscribe((response) => {
        console.log('response', response)
      },
        (error) => {
      console.log('error in fileupload', error)
       })
  }

Code Node Js

fileUpload contrôleur d'API

function start(req, res) {
fileUploadService.fileUpload(req, res)
    .then(fileUploadServiceResponse => {
        res.status(200).send(fileUploadServiceResponse)
    })
    .catch(error => {
        res.status(400).send(error)
    })
}

module.exports.start = start

Télécharger le service à l'aide de multer

const multer = require('multer') // import library
const moment = require('moment')
const q = require('q')
const _ = require('underscore')
const fs = require('fs')
const dir = './public'

/** Store file on local folder */
let storage = multer.diskStorage({
destination: function (req, file, cb) {
    cb(null, 'public')
},
filename: function (req, file, cb) {
    let date = moment(moment.now()).format('YYYYMMDDHHMMSS')
    cb(null, date + '_' + file.originalname.replace(/-/g, '_').replace(/ /g,     '_'))
}
})

/** Upload files  */
let upload = multer({ storage: storage }).array('files')

/** Exports fileUpload function */
module.exports = {
fileUpload: function (req, res) {
    let deferred = q.defer()

    /** Create dir if not exist */
    if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir)
        console.log(`\n\n ${dir} dose not exist, hence created \n\n`)
    }

    upload(req, res, function (err) {
        if (req && (_.isEmpty(req.files))) {
            deferred.resolve({ status: 200, message: 'File not attached', data: [] })
        } else {
            if (err) {
                deferred.reject({ status: 400, message: 'error', data: err })
            } else {
                deferred.resolve({
                    status: 200,
                    message: 'File attached',
                    filename: _.pluck(req.files,
                        'filename'),
                    data: req.files
                })
            }
        }
    })
    return deferred.promise
}
}

1
d'où vient httpService?
James le

@James httpService est un module http d'angular pour effectuer un appel http vers le serveur. Vous pouvez utiliser n'importe quel service http que vous voulez.import {HttpClientModule} depuis '@ angular / common / http';
Rohit Parte le

2

Essaye ça

Installer

npm install primeng --save

Importer

import {FileUploadModule} from 'primeng/primeng';

HTML

<p-fileUpload name="myfile[]" url="./upload.php" multiple="multiple"
    accept="image/*" auto="auto"></p-fileUpload>

1
je suis fatigué en utilisant l'exemple ci-dessus. Mais je reçois ./upload.php introuvable.
Sandeep Kamath

2
Vous devriez fournir votre URL à l'endroit où elle doit être chargée au lieu de upload.php @sandeep kamath
Vignesh

1
@Vignesh merci pour votre réponse. Mais j'ai trouvé que je ne donne pas du tout l'attribut url, il charge le fichier, devrait être celui par défaut.
Sandeep Kamath

1
Pouvez-vous s'il vous plaît expliquer comment nous pouvons recevoir le fichier en php si nous le faisons dans cette méthode.
Shaikh Arbaaz

2

En angulaire 7/8/9

Lien source

entrez la description de l'image ici

Utilisation du formulaire Bootstrap

<form>
    <div class="form-group">
        <fieldset class="form-group">

            <label>Upload Logo</label>
            {{imageError}}
            <div class="custom-file fileInputProfileWrap">
                <input type="file" (change)="fileChangeEvent($event)" class="fileInputProfile">
                <div class="img-space">

                    <ng-container *ngIf="isImageSaved; else elseTemplate">
                        <img [src]="cardImageBase64" />
                    </ng-container>
                    <ng-template #elseTemplate>

                        <img src="./../../assets/placeholder.png" class="img-responsive">
                    </ng-template>

                </div>

            </div>
        </fieldset>
    </div>
    <a class="btn btn-danger" (click)="removeImage()" *ngIf="isImageSaved">Remove</a>
</form>

Dans la classe de composant

fileChangeEvent(fileInput: any) {
    this.imageError = null;
    if (fileInput.target.files && fileInput.target.files[0]) {
        // Size Filter Bytes
        const max_size = 20971520;
        const allowed_types = ['image/png', 'image/jpeg'];
        const max_height = 15200;
        const max_width = 25600;

        if (fileInput.target.files[0].size > max_size) {
            this.imageError =
                'Maximum size allowed is ' + max_size / 1000 + 'Mb';

            return false;
        }

        if (!_.includes(allowed_types, fileInput.target.files[0].type)) {
            this.imageError = 'Only Images are allowed ( JPG | PNG )';
            return false;
        }
        const reader = new FileReader();
        reader.onload = (e: any) => {
            const image = new Image();
            image.src = e.target.result;
            image.onload = rs => {
                const img_height = rs.currentTarget['height'];
                const img_width = rs.currentTarget['width'];

                console.log(img_height, img_width);


                if (img_height > max_height && img_width > max_width) {
                    this.imageError =
                        'Maximum dimentions allowed ' +
                        max_height +
                        '*' +
                        max_width +
                        'px';
                    return false;
                } else {
                    const imgBase64Path = e.target.result;
                    this.cardImageBase64 = imgBase64Path;
                    this.isImageSaved = true;
                    // this.previewImagePath = imgBase64Path;
                }
            };
        };

        reader.readAsDataURL(fileInput.target.files[0]);
    }
}

removeImage() {
    this.cardImageBase64 = null;
    this.isImageSaved = false;
}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.