Subida angular de archivos


193

Soy un principiante con Angular, quiero saber cómo crear la parte de carga de Angular 5 File , estoy tratando de encontrar algún tutorial o documento, pero no veo nada en ningún lado. ¿Alguna idea para esto? Y probé archivos ng4 pero no funciona para Angular 5


2
Entonces, ¿quieres arrastrar y soltar o simplemente Choose Filecargar btn? Bdw en ambos casos, simplemente carga usando FormData
Dhyey

44
Eche un vistazo a primeng, lo he estado usando durante un tiempo y funciona con angular v5. primefaces.org/primeng/#/fileupload
Bunyamin Coskuner

Para aquellos que solo necesitan cargar JSON al cliente, revisen esta pregunta: stackoverflow.com/questions/54971238/…
AnthonyW

Respuestas:


427

Aquí hay un ejemplo de trabajo para cargar archivos a la API:

Paso 1: Plantilla HTML (file-upload.component.html)

Definir etiqueta de entrada simple de tipo file. Agregue una función al (change)evento para manejar la elección de archivos.

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

Paso 2: Carga de manejo en TypeScript (file-upload.component.ts)

Defina una variable predeterminada para el archivo seleccionado.

fileToUpload: File = null;

Cree la función que usa en el (change)evento de su etiqueta de entrada de archivo:

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

Si desea manejar la selección de múltiples archivos, puede iterar a través de esta matriz de archivos.

Ahora cree la función de carga de archivos llamándole file-upload.service:

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

Paso 3: Servicio de carga de archivos (file-upload.service.ts)

Al cargar un archivo a través del método POST, debe usarlo FormData, ya que puede agregar un archivo a la solicitud 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));
}

Entonces, este es un ejemplo de trabajo muy simple, que uso todos los días en mi trabajo.


66
@ Katie, ¿has habilitado polyfills?
Gregor Doroschenko

2
@GregorDoroschenko Estaba tratando de usar un modelo con información adicional sobre el archivo y tuve que hacer esto para que funcione: const invFormData: FormData = new FormData(); invFormData.append('invoiceAttachment', invoiceAttachment, invoiceAttachment.name); invFormData.append('invoiceInfo', JSON.stringify(invoiceInfo)); el controlador tiene dos parámetros correspondientes, pero tuve que analizar el JSON en el controlador. Mi controlador Core 2 no recogería automáticamente el modelo en el parámetro. Mi diseño original era un modelo con una propiedad de archivo, pero no pude hacerlo funcionar
Papa Stahl

1
@GregorDoroschenko Probé este códigocreateContrat(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 Y para mí no funciona. Content-Disposition: form-data; name="fileKey"; filename="file.docx" Content-Type: application/octet-stream <file>
Publico

1
@OnnaB Si está utilizando FormData para el archivo y para otras propiedades, debe analizar su archivo y otras propiedades como FormData. No puede usar FormData y body al mismo tiempo.
Gregor Doroschenko

23

De esta manera, implemento el archivo de carga a la API web en el proyecto.

Comparto por quien se preocupe.

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

Paso a paso

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);
    }
}

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

Archivo TS para usar API

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

Servicio 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
¿Cuál es su forma de no enviar encabezados?
Shalom Dahan

14

El método más fácil y rápido es usar ng2-file-upload .

Instale ng2-file-upload a través de npm. npm i ng2-file-upload --save

Al primer módulo de importación en su módulo.

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

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

Margen:

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

En tus commponentes ts:

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

Es el uso más simple de esto. Para conocer todo el poder de esto ver demo


44
¿Cómo obtener respuesta cuando se carga la imagen? cuál será la respuesta, falta documentación en esta parte.
Muhammad Shahzad

7

Estoy usando Angular 5.2.11, me gusta la solución proporcionada por Gregor Doroschenko, sin embargo, noté que el archivo cargado es de cero bytes, tuve que hacer un pequeño cambio para que funcione para mí.

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));
}

Las siguientes líneas (formData) no funcionaron para mí.

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, como este hilo aparece entre los primeros resultados de google y para otros usuarios que tienen la misma pregunta, no tienes que volver a activar la rueda como lo señala trueboroda, existe la biblioteca ng2-file-upload que simplifica este proceso de carga de un archivo con angular 6 y 7 todo lo que necesita hacer es:

Instale la última CLI angular

yarn add global @angular/cli

Luego instale rx-compat por problemas de compatibilidad

npm install rxjs-compat --save

Instalar ng2-file-upload

npm install ng2-file-upload --save

Importar Directiva Directa FileSelect en su módulo.

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

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

En su componente

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

export class AppComponent implements OnInit {

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

Modelo

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

Para una mejor comprensión, puede consultar este enlace: Cómo cargar un archivo con Angular 6/7


1
Gracias por el enlace. La carga funciona bien en el escritorio, pero no puedo conseguir que las cargas funcionen en dispositivos móviles como iOS. Puedo seleccionar un archivo del carrete de la cámara, pero cuando lo subo siempre falla. ¿Algunas ideas? Para su información, ejecutar esto en safari móvil, no en una aplicación que está instalada.
ScottN

1
Hola @ScottN y eres bienvenido, ¿tal vez el problema proviene del navegador que estás usando? ¿Lo probaste con otro?
Mohamed Makkaoui

1
Hola @ Mohamed Makkaoui, gracias por la respuesta. Lo probé en Chrome en iOS y sigue siendo el mismo resultado. Tengo curiosidad si este es un problema de encabezado al publicar en el servidor? Estoy usando un WebAPI personalizado escrito en .Net y NO AWS FYI.
ScottN

1
Hola @ScottN, no podremos saber si se trata de un problema de encabezado hasta que depure su código usando este enlace developers.google.com/web/tools/chrome-devtools/… y vea qué mensaje de error recibe.
Mohamed Makkaoui

6

Personalmente, estoy haciendo esto usando ngx-material-file-input para el front-end y Firebase para el back-end. Más precisamente, C loud Storage para Firebase para el back-end combinado con Cloud Firestore. Debajo de un ejemplo, que limita que el archivo no sea mayor de 20 MB, y acepta solo ciertas extensiones de archivo. También estoy usando Cloud Firestore para almacenar enlaces a los archivos cargados, pero puede omitir esto.

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 (parte del validador de tamaño)

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 (parte del cargador de archivos)

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();
    }
  }

almacenamiento.reglas

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
Se ve genial, pero ¿por qué necesita toString()la declaración contactForm?
trungk18

1
@ trungk18 revísalo una vez más, y tienes razón, toString()es inútil, editó mi respuesta. Para aquellos que lea este comentario, al final fileUploaderde contact.component.ts tuve ])].toString()}). Ahora es simplemente: ])]}).
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. ts File
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 (archivo 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";
    }
}

Tenemos que crear una carpeta "temp" en la unidad C, luego este código imprimirá el Json en la consola y guardará el archivo cargado en la carpeta creada


¿Cómo recuperamos ese archivo? ¿Tienes alguna guía sobre eso?
Siddharth Choudhary

Además, mi servidor de Spring se está ejecutando en 8080 y el de Angular se está ejecutando en 3000. Ahora, cuando marco server_url como localhost: 8080 / api / uploadForm, dice que no se permiten cors.
Siddharth Choudhary

byte [] bytes = archivo.getBytes (); le dará el flujo de bytes ... puede convertirlo a archivo, para el problema de los cors puede encontrar una solución en google
Shafeeq Mohammed

5

Primero, necesita configurar HttpClient en su proyecto Angular.

Abra el archivo src / app / app.module.ts, importe HttpClientModule y agréguelo a la matriz de importaciones del módulo de la siguiente manera:

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

A continuación, genere un componente:

$ ng generate component home

A continuación, genere un servicio de carga:

$ ng generate service upload

A continuación, abra el archivo src / app / upload.service.ts de la siguiente manera:

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

Luego, abra el archivo src / app / home / home.component.ts y comience agregando las siguientes importaciones:

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

A continuación, defina las variables fileUpload y files e inyecte UploadService de la siguiente manera:

@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) { }

A continuación, defina el método 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);  
        }  
      });  
  }

A continuación, defina el método uploadFiles () que puede usarse para cargar múltiples archivos de imagen:

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

A continuación, defina el método 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();  
}

A continuación, debemos crear la plantilla HTML de nuestra interfaz de usuario de carga de imágenes. Abra el archivo src / app / home / home.component.html y agregue el siguiente contenido:

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

Mira este tutorial y esta publicación


4

Ejemplo completo de carga de archivos usando Angular y nodejs (express)

código HTML

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

Código de componente 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)
       })
  }

Código de nodo Js

controlador de API fileUpload

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

Subir servicio usando 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
¿De dónde viene httpService?
James

@James httpService es un módulo http de angular para hacer una llamada http al servidor. Puede usar cualquier servicio http que desee.importar {HttpClientModule} desde '@ angular / common / http';
Rohit Parte

2

Prueba esto

Instalar en pc

npm install primeng --save

Importar

import {FileUploadModule} from 'primeng/primeng';

HTML

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

1
Estoy cansado de usar el ejemplo anterior. Pero obtengo ./upload.php no encontrado.
Sandeep Kamath

2
Debe proporcionar su URL donde debe cargarse en lugar de upload.php @sandeep kamath
Vignesh

1
@Vignesh gracias por tu respuesta. Pero descubrí que no doy el atributo url en absoluto, carga el archivo, debería ser el predeterminado.
Sandeep Kamath

1
¿Puede explicar cómo podemos recibir el archivo en php si lo hacemos con este método?
Shaikh Arbaaz

2

En angular 7/8/9

Enlace fuente

ingrese la descripción de la imagen aquí

Usando el formulario 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>

En clase de componente

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;
}
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.