გადაიყვანეთ ცხრილების კონვერტირება ერთ ხაზზე: სრულყოფილი გიდი Aspose.Cells Cloud Convert API-ისთვის (.NET / Python / Java)

ლოკალური Excel-ის ინსტალაცია არ არის. კონვერსიის სერვერი, რომელიც უნდა მოვამართოთ, არ არსებობს. გადაკეთეთ XLSX → PDF, Excel → CSV/JSON/სურათები/HTML მარტივი REST‑გამოძახებებად — და მიიღეთ თქვენი პირველი “ღრუბლოვანი ცხრილების კონვერტორი” დაახლოებით სამი წუთის განმავლობაში.

“გადაიტანეთ ეს ცხრილი სხვა ფორმატში” არის ერთ-ერთი ყველაზე გავრცელებული მოთხოვნა ყოველდღიურ განვითარებაში:

• ფინანსურ და იურიდიულ გუნდებს სჭირდებათ მხოლოდ-კითხვის, ცვალებადობისგან დაცული PDF ანგარიში, ნაცვლად .xlsx-ის, რომელიც ყველას შეუძლია რედაქტირება გააკეთოს;
• მონაცემთა გუნდებს საჭიროა ცხრილური მონაცემების გადმოტანა ქვედა სისტემებში როგორც CSV / JSON;
• ვებ- და მობილური აპლიკაციებს სჭირდებათ სამუშაო ფურცლები — და нават დიაგრამები — პირდაპირ PNG / SVG ფორმატში გადაყვანა;
• პორტალებს სჭირდებათ სუფთა HTML / HTML-Table სნიპეტები ინტეგრაციისთვის;
• ვინმე უნდა ნორმალიზიროს .xls / .xlsx / .csv / .ods ფაილების ნაკრები ერთ ფორმატში.

ძველი სკოლის პასუხები — ლოკალური Excel-ის ინსტალაცია მაკროთებით, ან მძიმე COM კომპონენტი თქვენს სერვერზე — მასშტაბირებაში რთულია და მრავალპლატფორმული მხარდაჭერა რთულია. Aspose.Cells Cloud ჩანაცვლებს ყველაფერს სუფთა REST API-ით: ფაილის ატვირთვა, ახალი ფორმატის ფაილის მიღება უკან.

ამ პოსტში ჩვენ გადით სამ კონვერსიის API-ით, რომელიც გამოყოფილია ძირითადი ConversionController-ის მიერ Aspose.Cells Cloud მიკროსერვისში (წყარო: src/Aspose.Cells.Cloud.MicroService/Controllers/ConversionController.cs), მუშაობის მაგალითებით cURL, C# (.NET), Python, და Java.

1. Convert ფუნქციამ რა შეუძლია?

ConversionController არის კონტროლერი, რომელიც განკუთვნილია _ფორმატის კონვერსია / ექსპორტი_თვის. იგი აერთიანებს ძრავის-დონის, მაღალი სიზუსტის კონვერსიას სამი HTTP API-ის ნაკადში:

განხორციელების შენიშვნა: წყაროს გზები იყენებენ პრეფიქსს v{version}/cells API ვერსიით 4.0, ამიტომ ცოცხალი გამოძახებები გამოიყურება https://api.aspose.cloud/v4.0/cells/....

გარდაქმნის სიზუსტის დონე გადის ძალიან შორეულ დონეზე, “სრული ფაილის"გან

მთლიანი სამუშაო წიგნის გადაყვანის გარდა, კონტროლერი შეუძლია ერთი ელემენტის ექსპორტირება:

• კონკრეტული სამუშაო ფურცელი → PDF / გამოსახულება / CSV / JSON / HTML
• კონკრეტული უჯრედის დიაპაზონი (e.g. A1:C12) → PDF / გამოსახულება / CSV / JSON / HTML
• კონკრეტული ცხრილი → PDF / გამოსახულება / CSV / JSON / HTML
• კონკრეტული დიაგრამა → PNG / JPEG / BMP / GIF / SVG / TIFF / EMF / PDF

ასე რომ, თქვენ არასოდეს უნდა გარდაქმნათ მთელი 50 მბ სამუშაო წიგნი, უბრალოდ ერთი გრაფიკის დასაკრავად — გარდაქმნეთ მხოლოდ ის, რაც გჭირდებათ, და დაზოგეთ ბანდვიდთი და გამოთვლები

2. რომელი ფორმატებია მხარდაჭერილი?

კონტროლერში არსებული ჩაშენებული ExportData რეგისტრის მიხედვით, გადაყვანის მატრიცა დაახლოებით ასე გამოიყურება:

მოკლედ: spreadsheet-to-spreadsheet ყველა ტიპის კონვერსია, plus მთელი ოჯახი spreadsheet → PDF / image / web-data outputs — ყველა ერთ API ზედაპირზე.

3. დაწყებამდე საჭირო ორი რამ

1. რეგისტრირდით უფასო ანგარიშზე Aspose Cloud Dashboard და შექმენით აპლიკაცია, რათა მიიღოთ Client ID და Client Secret (SDK-ები ავტომატურად გაცვლიან ისინი JWT-ით — არ გჭირდებათ ავტორიზაციის ჰედერების შექმნა ხელით).
2. დააყენეთ SDK თქვენი სასურველი ენისთვის:

<!-- .NET -->
<PackageReference Include="Aspose.Cells-Cloud" Version="25.x" />

# Python
pip install asposecellscloud

<!-- Java (Maven) — note: NOT on Maven Central, so the Aspose repo below is required -->
<repositories>
    <repository>
        <id>AsposeJavaAPI</id>
        <name>Aspose Java API</name>
        <url>https://repository.aspose.cloud/repo/</url>
    </repository>
</repositories>

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-cells-cloud</artifactId>
    <version>26.8</version>
</dependency>

SDK არ არის საჭირო? ყველაფერი მარტივი REST‑ია, ამიტომ cURL‑იც მუშაობს იგივე ეფექტურობით (ქვემოთ იხილეთ).

4. სცენარი 1: ლოკალური Excel ფაილის ონლაინ გადაყვანა (სათაური Convert API)

This is PUT /v4.0/cells/convert/spreadsheet — the flagship “Convert” API: ატვირთეთ თქვენი ლოკალური ფაილი მოთხოვნის სხეულში, სერვერი მას გადაყვანის და ახალი ფაილი უკან გადაგზავნის. ღრუბლურ საცავში არაფერი შენახული ხდება და ატვირთული ასლი არ დარჩება — იდეალურია “just convert this for me” მომენტებში.

① cURL

# 1) First, get a token
curl -X POST "https://api.aspose.cloud/connect/token" \
  -d "grant_type=client_credentials" \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET"

# 2) XLSX -> PDF
curl -X PUT "https://api.aspose.cloud/v4.0/cells/convert/spreadsheet?format=pdf" \
  -H "Authorization: Bearer $TOKEN" \
  -F "file=@Book1.xlsx" \
  -o Book1.pdf

შეცვალეთ format-ის მნიშვნელობა csv, json, png, xlsx… და მიიღებთ იმ ფორმატს. ერთი პარამეტრი, ერთი გამოსავალი ფორმატი.

② C# / .NET

using Aspose.Cells.Cloud.SDK.Api;
using Aspose.Cells.Cloud.SDK.Request;

var cellsApi = new CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

var request = new ConvertSpreadsheetRequest(
    spreadsheet: "C:/invoices/Book1.xlsx",   // local file path
    format: "pdf");                          // target: pdf / csv / json / png ...

using Stream result = cellsApi.ConvertSpreadsheet(request); // converted file stream
using var outFile = File.Create("C:/invoices/Book1.pdf");
result.CopyTo(outFile);

// Even simpler: point the SDK at an output path and let it write the file
// cellsApi.ConvertSpreadsheet(request, "C:/invoices/Book1.pdf");

გჭირდებათ ბაჩის დავალება? ჩასვით ეს ციკლში საქაღალდის თავზე და მიიღებთ “მთლიანი საქაღალდის XLSX → PDF გარდაქმნას”.

③ Python

from asposecellscloud.apis.cells_api import CellsApi
from asposecellscloud.requests import ConvertSpreadsheetRequest
import os

instance = CellsApi(
    os.getenv('CellsCloudClientId'),
    os.getenv('CellsCloudClientSecret'))

# Local XLSX -> PDF, result written locally
instance.convert_spreadsheet(
    ConvertSpreadsheetRequest("Book1.xlsx", "pdf"),
    local_outpath="Book1.pdf")

# Other formats: just change the parameter — json / csv / xlsx / png ...

④ Java

import com.aspose.cloud.cells.api.CellsApi;
import com.aspose.cloud.cells.request.ConvertSpreadsheetRequest;
import java.io.File;

public class ConvertDemo {
    public static void main(String[] args) throws Exception {
        CellsApi api = new CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

ConvertSpreadsheetRequest req = new ConvertSpreadsheetRequest();
        req.setSpreadsheet("C:/invoices/Book1.xlsx");   // local file path
        req.setFormat("pdf");                           // target: pdf / csv / json / png ...

File out = api.convertSpreadsheet(req);         // converted result as a File
        out.renameTo(new File("C:/invoices/Book1.pdf"));
        System.out.println("Converted: " + out.getAbsolutePath());
    }
}

ოთხი ენა, ერთი მოქმედება: მიუთითეთ გზა + ფორმატის პარამეტრი → მიიღეთ მიზნობრივი ფაილი. ეს არის Convert API-ის მთელი გაყიდვების უპირატესობა — ზერო Excel-ის დამოკიდებულება გამოძახის მხარეს, გარეშე შაბლონების, COM კომპონენტების.

5. სცენარი 2: ღრუბელში შენახული ფაილის პირდაპირ გადაყვანა

ფაილი უკვე მდებარეობს Aspose Cloud Storage-ში (ან თქვენს ობიექტურ შენახვაში), თქვენ არ გჭირდებათ დიდი ფაილების ჩამოტვირთვა/ატვირთვა — გადაყვანა ხდება ღრუბელში, რაც მინიმიზირებს მონაცემთა გადაცემა და აუმჯობესებს დიდი სამუშაო წიგნების შესრულებას:

# cloud Book1.xlsx -> PDF, downloaded locally
curl -G "https://api.aspose.cloud/v4.0/cells/Book1.xlsx" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "format=pdf" \
  --data-urlencode "folder=Reports" \
  -o Book1.pdf

from asposecellscloud.apis.cells_api import CellsApi
from asposecellscloud.requests import ExportSpreadsheetAsFormatRequest

instance = CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")

# Convert a cloud-stored workbook straight to PDF
instance.export_spreadsheet_as_format(
    ExportSpreadsheetAsFormatRequest("Book1.xlsx", format="pdf", folder="Reports"))

თქვენ ასევე შეგიძლიათ ერთ ელემენტზე დეტალურად გადახედოთ — მაგალითად, “Sheet1-ის 3-ე გრაფიკი” როგორც PNG (cloud-storage ვარიანტი):

# chart -> PNG
curl -G "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Sheet1/charts/2" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "format=png" \
  -o chart.png

დეტალური ღრუბლოვანი საბოლოო წერტილები მიმოხილვით:

6. სცენარი 3: SaveAs — შედეგის შენახვა ღრუბლოვან საცავში

თუ გსურთ, რომ გადაყვანილი ფაილი დარჩეს ღრუბლოვან შენახვაში (ისევე, როგორც გადმოწერილი არ იყოს), გამოიყენეთ PUT /v4.0/cells/{name}/saveas. ეს ბუნებრივია ავტომატიზაციისთვის, მაგალითად “გაექსპორტეთ დღევანდელი ანგარიში PDF-ში არქივირებისთვის, ყოველ დღე”.

curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/saveas?format=pdf" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{}'

from asposecellscloud.apis.cells_api import CellsApi
from asposecellscloud.requests import SaveSpreadsheetAsRequest

instance = CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")
instance.save_spreadsheet_as(
    SaveSpreadsheetAsRequest("Book1.xlsx", format="pdf", folder="Reports"))
# Result is saved directly in cloud storage; returns CellsCloudResponse(Code=200, Status="OK")

თქვენ შეგიძლიათ გადმოვიტანოთ დეტალურად განსაზღვრული შენახვის პარამეტრები SaveOptionsData მოთხოვნის სხეულში და კონტროლოთ გამოტანის ფაილის სახელი, გამოტანის შენახვა, მომხმარებლის შრიფტები, რეგიონი/ლოკალი, პაროლი, და ა.შ. მოთხოვნის პარამეტრებით — მეტი დეტალები შეგიძლიათ იხილოთ ინჟინერიული დეტალები ქვემოთ.

7. მეტი მზადყოფის “ონლაინ კონვერტის” საბოლოო წერტილები

ზემოთ აღნიშნული სამუშაო წიგნის დონეზე კონვერსიების გარდა, კონტროლერი აჩვენებს სრულ ნაკრებს დანიშნული ლოკალური ფაილი → კონკრეტული მიზანი ენდპოინტებს (იგივე მოთხოვნის სხეულის ატვირთვა როგორც სცენარი 1), რომლებიც უფრო დეტალურია და ნაკლები ბანდვიდის მოხმარებით:

მაგალითად, “ამ შუალედის ექსპორტი CSV ფორმატში ქვედა სისტემისთვის”:

curl -X PUT "https://api.aspose.cloud/v4.0/cells/convert/range/csv" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "worksheet=Sheet1" \
  --data-urlencode "range=A1:C100" \
  -F "file=@data.xlsx" \
  -o data.csv

ეს ენდპოინტები იყენებენ იმავე upload-in-the-body შაბლონს, როგორც convert/spreadsheet. .NET SDK-ში chart შემთხვევებს აქვს ტიპის გადაფარვები, რომლებიც მიბმიან ამ v4.0 გზებზე — ConvertChartToImage (convert/chart/image) და ConvertChartToPdf (convert/chart/pdf). worksheet/*, range/* და table/* ვარიანტებს ჯერ არ აქვთ v4.0 გადაფარვა, ამიტომ მათი გამოძახება უნდა იყოს მარტივი REST‑ით, ზუსტად როგორც ზემოთ მოცემული cURL აკეთებს.

8. ინჟინერიული დეტალები & შეცდომის დამუშავება

გარდაქმნის პარამეტრები, რომლებიც ღირს იცოდეთ (მოთხოვნის პარამეტრები)

• password — პაროლით დაცული სამუშაო წიგნების გახსნა;
• fontsLocation / custom-font მხარდაჭერა — გლიფების სწორობა PDF/გამოსახულებების რენდერისას შენარჩუნება;
• რიგებისა/სვეტების ავტომატური ზომის დაყენება, და თუ უნდა დაბეჭდოთ რიგის/სვეტის სათაურები (printHeadings), რეგიონის/გვერდის პარამეტრები (region) და სხვა;
• გამოტანის მხარე: outPath / outStorageName განსაზღვრავს, სად ჩაიწერება შედეგი ღრუბლოვანი საცავში.

შეცდომის კოდები (კონტროლერის მიერ დოკუმენტირებული კონტრაქტი)

ავთენტიკაცია

ყველა SDK ავტომატურად აუთენტიფიცირდება OAuth 2.0 client_credentials და JWT‑ით; raw cURL‑ის გამოყენებისას, ჯერ /connect/token გამოძახეთ ერთხელ (იხილეთ სცენარი 1, ① ზემოთ).

9. რატომ Aspose.Cells Cloud Convert?

• ✅ ლოკალური დამოკიდებულებების გარეშე — Office/Excel-ის გარეშე, COM-ის გარეშე. გამოძახება შესაძლებელია ნებისმიერი ენისა და ნებისმიერი პლატფორმისგან (Linux, კონტეინერები, სერვერლესი);
• ✅ მაღალი სიზუსტის რენდერი — მუშაობს Aspose.Cells ძრავით, ამიტომ ფორმულები, დიაგრამები, სტილები და პაგინაცია პროფესიული ხარისხით რენდერდება PDF/გამოსახულებებში;
• ✅ ღრუბლზე-ნაცნობი — ფაილები შეიძლება დარჩეს ღრუბლში კონვერტაციისას, რათა თავიდან აიცილოთ დიდი დატვირთვების გადაზიდვა; სუფთა ონლაინ კონვერტაციას ღრუბლური შენახვა არ სჭირდება בכלל;
• ✅ მოქნილი დეტალიზაცია — სამუშაო წიგნი / სამუშაო ფურცელი / დიაპაზონი / ცხრილი / დიაგრამა: გადაყვანა ზუსტად იმ ნაწილის, რომელიც გჭირდებათ;
• ✅ ერთიანი ფორმა SDK-ებში — cURL, .NET, Python და Java მაგალითები 1:1 მიბმულია, ასე რომ შეგიძლიათ პირდაპირ დაკოპიროთ თქვენთვის სასურველი შაბლონი.

დაიწყეთ ახლა: რეგისტრირდით Aspose Cloud Dashboard-ზე, შექმენით აპლიკაცია, ჩასვით თქვენი ავტორიზაციის დეტალები რომელიმე ზემოთ მოცემულ სნიპეტში და გაუშვით — რამდენიმე წუთში მიიღებთ თქვენს საკუთარი “ღრუბლოვან Excel კონვერტორს”.

გამოგადგათ? დადეთ ვარსკვლავი, დაამატეთ სანიშნე, ან გაუზიარეთ — და გვაცნობეთ თქვენი საკუთარი ცხრილის-კონვერტაციის გამოყენების შემთხვევები კომენტარებში.