Upload file

Excel API : UploadFile

Interface Details

Endpoint

PUT http://api.aspose.cloud/v4.0/cells/storage/file/{path}

Function Description

The request parameters of uploadFile API are:

Parameter Name	Type	Path/Query String/HTTPBody	Description
UploadFiles	File	FormData	Upload files to cloud storage.
path	String	Path
storageName	String	Query

Response Description

{
  "Name": "FilesUploadResult",
  "Description": [
    "File upload result"
  ],
  "Type": "Class",
  "IsAbstract": false,
  "Properties": [
    {
      "Name": "Uploaded",
      "Description": [
        "List of uploaded file names"
      ],
      "Nullable": true,
      "ReadOnly": false,
      "IsInherit": false,
      "DataType": {
        "Identifier": "Container",
        "Reference": "String",
        "ElementDataType": {
          "Identifier": "String",
          "Name": "string"
        },
        "Name": "container"
      }
    },
    {
      "Name": "Errors",
      "Description": [
        "List of errors."
      ],
      "Nullable": true,
      "ReadOnly": false,
      "IsInherit": false,
      "DataType": {
        "Identifier": "Container",
        "Reference": "Error",
        "ElementDataType": {
          "Identifier": "Class",
          "Reference": "Error",
          "Name": "class:error"
        },
        "Name": "container"
      }
    }
  ]
}

OpenAPI Specification

The OpenAPI Specification defines a publicly accessible programming interface and lets you carry out REST interactions directly from a web browser.

Excel API SDK

Using an SDK is the best way to speed up the development. An SDK takes care of low-level details and lets you focus on your project tasks. Please check out the GitHub repository for a complete list of Aspose.Cells Cloud SDKs.

The following code examples demonstrate how to make calls to Aspose.Cells web services using various SDKs:

	using Aspose.Cells.Cloud.SDK.Api;
	using Aspose.Cells.Cloud.SDK.Model;
	using Aspose.Cells.Cloud.SDK.Request;
	using System;
	using System.IO;
	using System.Collections.Generic;
	using Range = Aspose.Cells.Cloud.SDK.Model.Range;

	public static class Example40_UploadFile
	{
	public static void Run()
	{
	CellsApi cellsApi = new CellsApi("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
	IDictionary<string, System.IO.Stream> mapFiles =new Dictionary<string, System.IO.Stream>();
	string remoteFolder = "TestData/In";

	string localName = "Book1.xlsx";
	string remoteName = "Book1.xlsx";

	var request = new UploadFileRequest(
	uploadFiles: localName ,
	path: remoteFolder + "/" + remoteName,
	storageName: ""
	);
	cellsApi.UploadFile(request);
	}
	}

view raw Example40_UploadFile.cs hosted with ❤ by GitHub

Java

	package com.aspose.cloud.cells.api;

	import com.aspose.cloud.cells.client.*;
	import com.aspose.cloud.cells.model.*;
	import com.aspose.cloud.cells.request.*;

	import org.junit.Test;
	import java.util.ArrayList;
	import java.util.List;
	import java.io.File;
	import java.util.HashMap;

	public class ExampleUploadFile {
	private CellsApi api;
	public ExampleUploadFile(){
	try {
	api = new CellsApi(
	System.getenv("CellsCloudClientId"),
	System.getenv("CellsCloudClientSecret"),
	"v3.0",
	System.getenv("CellsCloudApiBaseUrl")
	);
	} catch (ApiException e) {
	e.printStackTrace();
	}
	}

	public void Run(){
	try{
	String remoteFolder = "TestData/In";

	String localName = "Book1.xlsx";
	String remoteName = "Book1.xlsx";

	UploadFileRequest uploadFileRequest = new UploadFileRequest();
	uploadFileRequest.setPath( remoteFolder + "/" + remoteName );
	uploadFileRequest.setStorageName( "");
	HashMap<String,File> files = new HashMap<String,File>();
	files.put( localName , new File(localName ));
	uploadFileRequest.setUploadFiles(files);
	cellsApi.uploadFile(uploadFileRequest);

	UploadFileRequest request = new UploadFileRequest();


	request.setPath(remoteFolder + "/" + remoteName);

	request.setStorageName("");

	HashMap<String,File> fileMap = new HashMap<String,File>();
	fileMap.put(localName ,CellsApiUtil.GetFileHolder(localName) );
	request.setUploadFiles(fileMap);
	this.api.uploadFile(request);

	} catch (ApiException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	}
	}
	}

view raw Example40_UploadFile.java hosted with ❤ by GitHub

PHP

	<?php
	require_once('vendor\autoload.php');
	use \Aspose\Cells\Cloud\Api\CellsApi;
	use \Aspose\Cells\Cloud\Request\UploadFileRequest;

	$cellsApi = new CellsApi(getenv("CellsCloudClientId"),getenv("CellsCloudClientSecret"),"v3.0",getenv("CellsCloudApiBaseUrl"));

	$remoteFolder = "TestData/In";

	$localName = "Book1.xlsx";
	$remoteName = "Book1.xlsx";

	$mapFiles = array ();
	$mapFiles[$localName] = CellsApiTestBase::getfullfilename($localName);
	CellsApiTestBase::ready( $this->instance,$localName ,$remoteFolder . "/" . $remoteName , "");

	$request = new UploadFileRequest();
	$request->setUploadFiles( $mapFiles);
	$request->setPath( $remoteFolder . "/" . $remoteName);
	$request->setStorageName( "");
	$$cellsApi->uploadFile($request);

view raw Example40_UploadFile.php hosted with ❤ by GitHub

Ruby

	require 'openssl'
	require 'bundler'
	require 'aspose_cells_cloud'

	@instance = AsposeCellsCloud::CellsApi.new(ENV['CellsCloudClientId'], ENV['CellsCloudClientSecret'],'v3.0',ENV['CellsCloudApiBaseUrl'])

	remote_folder = 'TestData/In'

	local_name = 'Book1.xlsx'
	remote_name = 'Book1.xlsx'


	mapFiles = { }
	mapFiles = { }
	mapFiles[local_name] = ::File.open(File.expand_path("TestData/"+local_name),"r")

	uploadrequest = AsposeCellsCloud::UploadFileRequest.new( { :UploadFiles=>mapFiles,:path=>remote_folder })
	@instance.upload_file(uploadrequest)
	mapFiles[local_name]= ::File.open(File.expand_path("TestData/"+local_name),"r")
	request = AsposeCellsCloud::UploadFileRequest.new(:UploadFiles=>mapFiles,:path=>remote_folder + '/' + remote_name,:storageName=>'');
	@instance.upload_file(request);

view raw Example40_UploadFile.rb hosted with ❤ by GitHub

Node.js

	var fs = require('fs');
	var path = require('path');
	const _ = require('asposecellscloud');

	const cellsApi = new CellsApi(process.env.CellsCloudClientId, process.env.CellsCloudClientSecret,"v3.0",process.env.CellsCloudApiBaseUrl);

	var remoteFolder = "TestData/In"

	var localName = "Book1.xlsx"
	var remoteName = "Book1.xlsx"

	var localNameRequest = new model.UploadFileRequest();
	localNameRequest.uploadFiles ={localName:fs.createReadStream(localPath + localName)};
	localNameRequest.path = remoteFolder + "/" + remoteName ;
	localNameRequest.storageName ="";
	cellsApi.uploadFile(localNameRequest );

	var mapFiles = {};

	mapFiles[localName]= fs.createReadStream(localPath +localName) ;

	var request = new model.UploadFileRequest();
	request.uploadFiles = mapFiles;
	request.path = remoteFolder + "/" + remoteName;
	request.storageName = "";
	return cellsApi.uploadFile(request).then((result) => {
	expect(result.response.statusCode).to.equal(200);
	});

view raw Example40_UploadFile.ts hosted with ❤ by GitHub

Python

	import os
	import sys
	from asposecellscloud.apis.cells_api import CellsApi
	from asposecellscloud.models import *
	from asposecellscloud.requests import *

	api = CellsApi(os.getenv('CellsCloudClientId'),os.getenv('CellsCloudClientSecret'),"v3.0",os.getenv('CellsCloudApiBaseUrl'))
	remote_folder = 'TestData/In'

	local_name = 'Book1.xlsx'
	remote_name = 'Book1.xlsx'

	mapFiles = {
	local_name: os.path.dirname(os.path.realpath(__file__)) + "/../TestData/" +local_name
	}
	mapFiles = {
	local_name: local_name
	}
	request = UploadFileRequest( mapFiles, remote_folder + '/' + remote_name,storage_name= '')
	api.upload_file(request)

	request = UploadFileRequest( mapFiles, remote_folder + '/' + remote_name,storage_name= '')
	api.upload_file(request)

view raw Example40_UploadFile.py hosted with ❤ by GitHub

Perl

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $mapFiles = {};

	$mapFiles->{$localName}= "TestData/".$localName ;

	my $request = AsposeCellsCloud::Request::UploadFileRequest->new();
	$request->{upload_files} = $mapFiles;
	$request->{path} = $remoteFolder . '/' . $remoteName;
	$request->{storage_name} = '';
	$instance->upload_file(request=> $request);

view raw Example40_UploadFile.pl hosted with ❤ by GitHub

	package main

	import (
	"os"

	asposecellscloud "github.com/aspose-cells-cloud/aspose-cells-cloud-go"
	)
	func main() {
	instance := asposecellscloud.NewCellsApiService(os.Getenv("ProductClientId"), os.Getenv("ProductClientSecret"), "https://api.aspose.cloud", "v3.0")
	remoteFolder := "TestData/In"

	localName := "Book1.xlsx"
	remoteName := "Book1.xlsx"

	localNameRequest := new(asposecellscloud.UploadFileRequest)
	localNameRequest.UploadFiles = make(map[string]string)
	localNameRequest.UploadFiles[localName] = localName
	localNameRequest.Path = remoteFolder + "/" + remoteName
	localNameRequest.StorageName =""
	instance.UploadFile(localNameRequest )

	var mapFiles map[string]string
	mapFiles = make(map[string]string)
	mapFiles[localName]= GetBaseTest().localTestDataFolder + localName

	request := new (asposecellscloud.UploadFileRequest)
	request.UploadFiles = mapFiles
	request.Path = remoteFolder + "/" + remoteName
	request.StorageName = ""
	_, httpResponse, err := instance.UploadFile(request)
	if err != nil {
	t.Error(err)
	} else if httpResponse.StatusCode < 200 \|\| httpResponse.StatusCode > 299 {
	t.Fail()
	}
	}

view raw Example40_UploadFile.go hosted with ❤ by GitHub