Tutorial Luath-Tòiseachaidh
A bheil thu a’ cleachdadh Cursor, Claude, no inneal còdaidh AI eile? Ceangail e ris na sgrìobhainnean Legalesign airson cuideachadh le fiosrachadh co-theacsail fhad ‘s a bhios tu a’ leantainn an tutarailean seo.
Anns an tutorial seo nì thu na prìomh ghairmean API a tha a’ còrdadh ri mòran luchd-leasachaidh bho aonachadh eSignature - luchdachadh suas sgrìobhainn agus a chuir a-mach airson ainm.
Tha API Legalesign sgèileadh, ioma-ghnìomhach, agus deuchainneach ann an siostaman ar luchd-ceannach fad iomadh bliadhna. Faodaidh tu a chleachdadh airson sgrìobhainn le aon neach a’ soidhnigeadh a-mhàin, no cuir a-mach sgrìobhainnean airson bhith mar fhianais no airson cead, air a dhealbhadh airson buidhnean, le foirmean agus barrachd. Faodaidh tu a chur ris airson adhbhar a-mhàin no cuir a-steach e taobh a-staigh am bathar-bog agad airson do luchd-cleachdaidh - faic aonachaidhean.
Tha an REST API a’ dèanamh a’ mhòr-chuid de dhleastanasan agus ‘s e an dòigh as fhasa tòiseachadh. Ma dh’ fheumas tu barrachd, faic an interfais GraphQL. Tha Legalesign API an toiseach leis an GraphQL. Faodaidh tu an dàrna cuid a chleachdadh, mar a tha thu ag iarraidh.
Leanamaid na ceumannan seo:
- Cruthaich cunntas + Iuchair API (faic Fhaigh dearbhadh airson ruigsinneachd API).
- Dearbhaich gu bheil na teisteanasan ag obair agus faigh do ID sgioba.
- Luchdaich suas sgrìobhainn tro an app-lìn.
- Cuir a-mach e airson ainmeachadh tro API.
- Luchdaich sìos e às dèidh ainm.
- Luchdaich suas sgrìobhainn tro API.
Tha REST API Legalesign furasta a chleachdadh. Tha am iomradh teignigeach a’ toirt a-steach deasaiche còd. Faodaidh tu iarrtasan a dhèanamh dìreach bhon iomradh teignigeach le do iuchair API, ach ma tha sin comasach dìreach lethbhreac agus pasgad dìreach dhan chòd agad.
Figear 1: Deasaiche Còd REST API.
Leabharlannan Luchd-cleachdaidh
No airson an eadar-aghaidh GraphQL Node.js
Tha sinn a’ moladh do luchd-leasachaidh obrachadh dìreach leis an API seach leis na SDKan. Gus cuideachadh, tha gineadair còd leth-bhreac agus pasgaidh sa sònrachadh teignigeach, agus faodaidh do AI a thoirt gu luath eisimpleirean a’ cleachdadh an sònrachadh OpenAPI. Carson? Tha barrachd gnìomhachd san API tùsail na anns na SDKan, bidh thu airson eòlas fhaighinn air na puingean-deuchainn, seachain thu eallach agus eisimeileachd, agus — a rèir ar n-eòlas — bidh e nas luaithe a chrìochnachadh cuideachd.
1. Cruthaich cunntas
Rachaibh gu [clàradh Legalesign] (https://legalesign.com/landing/free-trial/) agus lean am pròiseas gus cunntas a chruthachadh.
Bidh iad gad iarraidh sgioba a chruthachadh. ‘S e prìomh eileamaidean Legalesign a th’ ann an sgiobaidhean. Tha pròiseas sam bith de sgrìobhainnean a’ tachairt taobh a-staigh sgioba. Feumaidh tu iomradh a thoirt air do sgioba ann am mòran ghairmean API.
Tha 'sgioba' no 'buidheann' mar an ceudna. Sa phrògram lìn bruidhnidh sinn mun ‘sgiobaidhean’, ach san sgema API ’s e buidheann a th’ ann.
Suidhichidhean API
Rachaibh dhan Dashboard API. Cruthaich do teisteanasan API anns an earrann Iuchair API.
Gabh beagan ùine airson Ath-sgrùdadh a dhèanamh air am Portal Leasaiche.
Sandbox
San Earrann Àrainneachd, nochdaidh rabhaidhean ma tha thu ann an modh sandbox no modh riochdachaidh.
Tha modh sandbox a’ cur cuingealachadh gu 100 gairm san uair. Chan eil cuingealachaidhean air post-d luchd-faighinn.
Nuair a bhios do aonachadh deiseil: gluais gu modh riochdachaidh.
Cruthaich an dàrna sgioba. Cleachd an sgioba agad airson leasachadh agus sgioba(ean) eile airson riochdachadh. Cuir fios gu taic leis an ainm agad airson an sgioba leasachaidh gus an cuir às don bhile.
Iuchair API
San Earrann Iuchair API chì thu mion-fhiosrachadh nan iuchraichean API agad. Cha nochd ach an iuchair fhèin nuair a chruthaicheas tu fear.
Tha earrann Quickstart a' toirt a-steach eisimpleirean lethbhreac is pasgaidh gus do iuchair a dhearbhadh.
Webhooks & Logaichean
Cur ris an webhooks (na luchd-èisteachd agad airson tachartasan Legalesign), agus dèan sgrùdadh air na logaichean agad.
2. Iarrtas GET soirbheachail
Is e an URL freumh an-còmhnaidh: https://eu-api.legalesign.com/
Tòisich le iarrtas GET gus dearbhadh gu bheil na teisteanasan agad ag obair. Cuir àite do your_api_key leis an iuchair agad bhon Portal Leasaiche.
Tha Curl air a chleachdadh nan eisimpleirean, agus faodaidh tu atharrachadh eadar cURL, Node.js, Python, C#, agus Go a’ cleachdadh na tabaichean gu h-ìosal.
- cURL
- Node.js
- Python
- C#
- Go
curl -H "Authorization: Bearer your_api_key" -H "Content-Type: application/json" -X GET https://eu-api.legalesign.com/api/v1/group/
import fetch from 'node-fetch';
async function getGroups() {
const response = await fetch('https://eu-api.legalesign.com/api/v1/group/', {
method: 'GET',
headers: {
'Authorization': 'Bearer your_api_key',
'Content-Type': 'application/json',
},
});
if (!response.ok) {
throw new Error(`Request failed with status ${response.status}`);
}
const data = await response.json();
console.log(data);
}
getGroups().catch((error) => {
console.error(error);
process.exit(1);
});
import requests
headers = {
"Authorization": "Bearer your_api_key",
"Content-Type": "application/json",
}
response = requests.get(
"https://eu-api.legalesign.com/api/v1/group/",
headers=headers,
timeout=30,
)
response.raise_for_status()
print(response.json())
using System;
using System.Net.Http;
using System.Threading.Tasks;
public class Program
{
public static async Task Main()
{
using var client = new HttpClient();
using var request = new HttpRequestMessage(
HttpMethod.Get,
"https://eu-api.legalesign.com/api/v1/group/"
);
request.Headers.TryAddWithoutValidation("Authorization", "Bearer your_api_key");
request.Headers.TryAddWithoutValidation("Content-Type", "application/json");
using var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}
}
package main
import (
"fmt"
"io"
"log"
"net/http"
)
func main() {
req, err := http.NewRequest(http.MethodGet, "https://eu-api.legalesign.com/api/v1/group/", nil)
if err != nil {
log.Fatal(err)
}
req.Header.Set("Authorization", "Bearer your_api_key")
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
if resp.StatusCode >= 400 {
log.Fatalf("request failed: %s", resp.Status)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
}
Sgrìobhainnean API: iomradh GET buidheann API.
Nuair a chuir thu an ceist gu bàs, chì thu an cuid buidhnean a’ tilleadh ann an cruth JSON. Soirbheachas. 👏
Tha an dàta freagairt a’ toirt a-steach ‘uri stòrais’ airson do bhuidheann agus tha coltach ri /api/v1/group/:groupId/. Dèan nota den seo, feumaidh tu e airson a’ mhòr-chuid de ghairmean API.
Bidh uri goireis an-còmhnaidh air a chruthachadh san aon dòigh. Airson PDF bhiodh e ‘/api/v1/templatepdf/:pdfId/’, airson sgrìobhainn a chaidh a chur a-mach bidh e ‘/api/v1/document/:documentId/’. Thoir fa-near gu bheil gach URI a’ crìochnachadh le slighean-slàinte (/). Tha sin fìor cuideachd airson na URLan agad airson gairm API, crìochnaichibh iad an-còmhnaidh le slighean-slàinte.
Ma dh’fhalbh na iarrtas GET gu bàs, an uairsin dèan cinnteach gu bheil:
- am ceann-suidhe Authorization agad air a chruthachadh gu ceart (a’ tòiseachadh le
Bearer), - gu bheil ceann-suidhe Content-Type agad airson application/json, agus
- gu bheil an url agad a’ crìochnachadh le slighean-slàinte.
Faic cuideachd fuasgladh dhuilgheadasan.
3. Luchdaich suas sgrìobhainn tro an app-lìn
Gus tòiseachadh, nì sinn luchdachadh suas sgrìobhainn tro an app-lìn agus cuiridh sinn a-mach e tro API. Còmhdaichidh sinn mar a nì thu luchdadh suas sgrìobhainn tro API nas fhaide air adhart.
Rachaibh dhan app-lìn agus luchdachadh suas do sgrìobhainn. Cuir dreuchd aon neach soidhnigeadh agus tarraing raon soidhnidh. nochdaidh am duilleag deasaiche a bheil an sgrìobhainn ‘dligheach’ (mar eisimpleir ‘neo-dhligheach’ dh’fhaodadh a bhith ann ma chuireas tu dreuchd neach soidhnigeadh às aonais raon soidhnidh co-cheangailte).
Air an deasaiche foirm, lethbhraich an ID fhada alphanumeric bhon URL, dèan base64 decode air agus cuir às do na trì litrichean toiseach (bu chòir dhaibh a bhith ‘tpl’). ‘S e UUID a tha air fhàgail agus tha e na do ID.
Ann an cànan REST API ’s e /api/v1/templatepdf/UUID/ an uri stòrais airson an sgrìobhainn seo.
Faigh a-mach barrachd mu IDs web agus API.
Is e ar cleachdadh gum bi sgrìobhainn luchdaichte suas na ‘teamplaid’, agus nuair a chuireas tu aon, cruthaichidh tu ‘sgrìobhainn’.
Ma tha thu airson teamplaid a chur chun archve nuair a tha an sgrìobhainn ga chur a-mach, cuir ‘archive_upon_send’ mar feart anns an iarrtas luchdachadh suas. Ma tha thu airson nach nochd an teamplaid idir agus gun a dhubhadh às às dèidh an cur a-mach, cuir an tiotal ‘[deleted]’ air - bidh ar siostaman glanaidh ga thoirt agus ga dhubhadh às às dèidh latha no dà. Faodaidh tu cuideachd ùine cumail-dàta goirid a shuidheachadh aig ìre buidheann - faic barrachd.
4. Cuir a-mach sgrìobhainn airson ainm
A-nis cuiridh sinn seo a-mach tron API. Cleachd na tabaichean gu h-ìosal gus an iarrtas fhaighinn anns an cànan as fheàrr leat.
- cURL
- Node.js
- Python
- C#
- Go
curl -H "Authorization: Bearer your_api_key" -H "Content-Type: application/json" -X POST --data '{ "group": "/api/v1/group/[:groupId]/", "name": "Name of doc", "templatepdf": "/api/v1/templatepdf/UUID/", "signers": [{"firstname": "Joe", "lastname": "Bloggs", "email": "[your@email.com]", "order": 0 }], "do_email": true }' https://eu-api.legalesign.com/api/v1/document/
import fetch from 'node-fetch';
const payload = {
group: '/api/v1/group/[:groupId]/',
name: 'Name of doc',
templatepdf: '/api/v1/templatepdf/UUID/',
signers: [
{
firstname: 'Joe',
lastname: 'Bloggs',
email: '[your@email.com]',
order: 0,
},
],
do_email: true,
};
async function sendDocument() {
const response = await fetch('https://eu-api.legalesign.com/api/v1/document/', {
method: 'POST',
headers: {
'Authorization': 'Bearer your_api_key',
'Content-Type': 'application/json',
},
body: JSON.stringify(payload),
});
if (response.status !== 201) {
const errorBody = await response.text();
throw new Error(`Request failed with status ${response.status}: ${errorBody}`);
}
console.log('Document sent successfully');
const location = response.headers.get('location');
if (location) {
console.log(`Location: ${location}`);
}
}
sendDocument().catch((error) => {
console.error(error);
process.exit(1);
});
import requests
payload = {
"group": "/api/v1/group/[:groupId]/",
"name": "Name of doc",
"templatepdf": "/api/v1/templatepdf/UUID/",
"signers": [
{
"firstname": "Joe",
"lastname": "Bloggs",
"email": "[your@email.com]",
"order": 0,
}
],
"do_email": true,
}
headers = {
"Authorization": "Bearer your_api_key",
"Content-Type": "application/json",
}
response = requests.post(
"https://eu-api.legalesign.com/api/v1/document/",
json=payload,
headers=headers,
timeout=30,
)
response.raise_for_status()
print("Document sent successfully")
print("Location:", response.headers.get("Location"))
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
public class Program
{
public static async Task Main()
{
var payload = new
{
group = "/api/v1/group/[:groupId]/",
name = "Name of doc",
templatepdf = "/api/v1/templatepdf/UUID/",
signers = new[]
{
new
{
firstname = "Joe",
lastname = "Bloggs",
email = "[your@email.com]",
order = 0,
},
},
do_email = true,
};
using var client = new HttpClient();
using var request = new HttpRequestMessage(
HttpMethod.Post,
"https://eu-api.legalesign.com/api/v1/document/"
);
request.Headers.TryAddWithoutValidation("Authorization", "Bearer your_api_key");
var json = JsonSerializer.Serialize(payload);
request.Content = new StringContent(json, Encoding.UTF8, "application/json");
using var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine("Document sent successfully");
if (response.Headers.Location is not null)
{
Console.WriteLine($"Location: {response.Headers.Location}");
}
}
}
package main
import (
"bytes"
"encoding/json"
"fmt"
"log"
"net/http"
)
func main() {
payload := map[string]any{
"group": "/api/v1/group/[:groupId]/",
"name": "Name of doc",
"templatepdf": "/api/v1/templatepdf/UUID/",
"signers": []map[string]any{
{
"firstname": "Joe",
"lastname": "Bloggs",
"email": "[your@email.com]",
"order": 0,
},
},
"do_email": true,
}
body, err := json.Marshal(payload)
if err != nil {
log.Fatal(err)
}
req, err := http.NewRequest(
http.MethodPost,
"https://eu-api.legalesign.com/api/v1/document/",
bytes.NewReader(body),
)
if err != nil {
log.Fatal(err)
}
req.Header.Set("Authorization", "Bearer your_api_key")
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusCreated {
log.Fatalf("unexpected status: %s", resp.Status)
}
fmt.Println("Document sent successfully")
fmt.Println("Location:", resp.Header.Get("Location"))
}
Ùraich na h-àiteachan anns na cromagan ceàrnagach. Iomradh API airson a cur a-mach sgrìobhainn.
Nuair a thèid thu gu sgrìobhainnean iomraidh airson a’ chuir a-mach sgrìobhainn thoir sùil mhath air na feartan uile a tha comasach. Chì thu mòran a chuidicheas le gnìomhachas aonachaidh - bileagan airson bhith a’ toirt iomradh ort fhèin agus IDs (a thig air ais thugad anns an webhooks), ath-stiùireadh airson luchd-soidhnigidh, teacsa gnàthaichte a shuidheachadh sa PDF, agus barrachd.
Bidh gairm soirbheachail a’ faighinn còd inbhe 201. ✨
Faigh ID an sgrìobhainn a chaidh a chur a-mach ùr
‘S e an ceann-suidhe suidheachadh am pàirt chudromach den fhreagairt. Tha seo a’ toirt a-steach do ID sgrìobhainn ùr.
Cleachd feartan ‘bileag’ sgrìobhainn agus cuir do thagraidhean fhèin airson e a dhèanamh nas fhasa ceangal a dhèanamh ann am bun-stèidh dàta agad.
Bidh an ceann-suidhe suidheachadh coltach ri /api/v1/status/:documentId/.
Tha an URI ‘status’ a’ toirt seachad cruinneachadh goirid (agus luath airson faighneachd) de fheartan sgrìobhainn.
Gus a h-uile càil a iarraidh bhon sgrìobhainn cleachd /api/v1/document/:documentId/.
Ma tha iarrtas mì-shoirbheachail, mar as trice bheir an CORP den fhreagairt fiosrachadh mu mhearachdan. Ma chleachdas tu còd nach eil soirbheachail, thoir sùil air an CORP airson teacsa mìneachaidh. Faic cuideachd fuasgladh dhuilgheadasan.
Faigh a-mach barrachd mun ghairm API Send Document.
5. Luchdaich sìos an sgrìobhainn air a shoidhnigeadh
Le ID an sgrìobhainn a chaidh a chuir a-mach fhaighinn thu gu h-àrd, dèan iarrtas luchdaich sìos PDF anns an cànan as fheàrr leat:
- cURL
- Node.js
- Python
- C#
- Go
curl -H "Authorization: Bearer your_api_key" -o download.pdf -X GET https://eu-api.legalesign.com/api/v1/pdf/:documentId/
import { writeFile } from 'node:fs/promises';
import fetch from 'node-fetch';
async function downloadPdf() {
const response = await fetch('https://eu-api.legalesign.com/api/v1/pdf/:documentId/', {
method: 'GET',
headers: {
'Authorization': 'Bearer your_api_key',
},
});
if (!response.ok) {
throw new Error(`Request failed with status ${response.status}`);
}
const buffer = await response.arrayBuffer();
await writeFile('download.pdf', Buffer.from(buffer));
console.log('Saved download.pdf');
}
downloadPdf().catch((error) => {
console.error(error);
process.exit(1);
});
import requests
headers = {"Authorization": "Bearer your_api_key"}
response = requests.get(
"https://eu-api.legalesign.com/api/v1/pdf/:documentId/",
headers=headers,
stream=True,
timeout=30,
)
response.raise_for_status()
with open("download.pdf", "wb") as file:
for chunk in response.iter_content(chunk_size=8192):
file.write(chunk)
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
public class Program
{
public static async Task Main()
{
using var client = new HttpClient();
using var request = new HttpRequestMessage(
HttpMethod.Get,
"https://eu-api.legalesign.com/api/v1/pdf/:documentId/"
);
request.Headers.TryAddWithoutValidation("Authorization", "Bearer your_api_key");
using var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var bytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("download.pdf", bytes);
Console.WriteLine("Saved download.pdf");
}
}
package main
import (
"io"
"log"
"net/http"
"os"
)
func main() {
req, err := http.NewRequest(
http.MethodGet,
"https://eu-api.legalesign.com/api/v1/pdf/:documentId/",
nil,
)
if err != nil {
log.Fatal(err)
}
req.Header.Set("Authorization", "Bearer your_api_key")
resp, err := http.DefaultClient.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
if resp.StatusCode >= 400 {
log.Fatalf("request failed: %s", resp.Status)
}
file, err := os.Create("download.pdf")
if err != nil {
log.Fatal(err)
}
defer file.Close()
if _, err := io.Copy(file, resp.Body); err != nil {
log.Fatal(err)
}
log.Println("Saved download.pdf")
}
Iomradh API Luchdaich sìos PDF.
Tha am PDF dàta bunaiteach anns a’ chridhe den fhreagairt. Tha òrdugh curl ‘-o’ a’ cur corp na freagairt dìreach ann an faidhle.
Tha mòran leabharlannan REST no HTTP a’ làimhseachadh nithean freagairt HTTP mar faidhlichean, anns an cùis sin dìreach sàbhail am freagairt mar faidhle àbhaisteach.
Cleachd webhooks airson fiosrachadh fhaighinn mu thachartasan ainmichte agus an uairsin luchdaich sìos an sgrìobhainn. Faic webhooks.
6. Luchdaich suas PDF
Cliog an seo airson PDF le bileagan teacsa deiseil a luchdachadh sìos, tha barrachd mu raointean foirme PDF ri leantainn.
Airson a’ ghairm seo, thoir an PDF agad gu sreang còdaichte base64. Chan eil seo air a dhèanamh gu ceart anns an gineadair còd sa sgrìobhainn. An àite sin, lethbhraich an pseudocode seo agus bidh do AI càirdeil ga ghluasad gu cànan is fheàrr leat:
$data = (
'group': '/api/v1/group/:groupId/',
'title': 'title of pdf',
'pdf_file': base64encode(open('/path/to/file','rb')),
'process_tags': true
)
$headers = (
'Authorization': 'Bearer your_api_key',
'Content-Type': 'application/json'
)
response = httplibrary.post('https://eu-api.legalesign.com/api/v1/templatepdf/', jsonEncode($data), $headers)
assert response.status == 201
pdfId = response.headers['location']
Iomradh API luchdachadh suas PDF.
Mar as àbhaist, bidh freagairt POST soirbheachail a’ tilgeil còd inbhe ‘201’ agus bidh an ID ùr anns an ceann-suidhe ‘location’ san fhreagairt.
assert response.status == 201
pdfId = response.headers['location']
Bidh an uri stòrais PDF agad coltach ri /api/v1/templatepdf/:pdfId/.
Cuir am PDF ùr a-mach
Till air ais chun chòd a chleachd thu airson a’ chiad sgrìobhainn a chuir a-mach, agus cuir an àite luach templatepdf.
Dèan an iarrtas a-rithist agus sin agad e, chuir thu a-mach do PDF airson ainm.
Mus tòisich thu air còd a sgrìobhadh, agus ge-tà, leugh air adhart gus barrachd a dh’ionnsaigh raointean PDF.
Dè mu dheidhinn raointean PDF?
Ciamar a tha Legalesign a’ faighinn a-mach càite a bheil feum air gun tèid neach a shoidhnigeadh air an PDF, no earrannan ri atharrachadh nuair a thèid a chuir a-mach? ’S e an fhreagairt gur e gu bheil ar PDF air a ullachadh ro-làimh le bileagan: chuir sinn bileag teacsa Legalesign taobh a-staigh PDF agus chuir sinn ‘process_tags’ gu true san iarrtas luchdachadh suas PDF.
[Luchdaich sìos PDF le bileagan teacsa] (https://static.legalesign.com/tutorialQuickstartPdf.pdf).
Tha bileagan teacsa air an cruthachadh gu sònraichte airson cuir a-steach ann an PDF. Bidh Legalesign a’ mìneachadh a’ chuid teacsa ann am faidhle agad, ag atharrachadh na bileagan le raointean ainmhidhe agus foirme. Airson aon neach soidhnigeadh, feumaidh tu dìreach <<t=signature>> a chur ris. Chithear Legalesign e agus lorg e an soidhnidh an sin. Ionnsaich mu bhileagan teacsa.
Tha bileagan teacsa beagan eadarachaidh ionnsachaidh agus feumaidh iad feuchainn is mearachd. Tha dòighean eile air an liosta gu h-ìosal, ach gheibh thu comas gu tur air a’ shiostam foirme Legalesign leis a’ chiad dòigh seo. Cleachd an app-lìn airson deuchainn a dhèanamh air bileagan. Cuir fios gu [taic] (https://support.legalesign.com) airson cuideachadh agus eisimpleirean.
Seo 4 dòighean eile airson raointean a shuidheachadh:
1. An dòigh as fhasa / as luaithe. Suidhich do PDF a’ cleachdadh an app-lìn Legalesign.
Às dèidh dhut PDF a luchdachadh suas rachaibh gu eadar-aghaidh an deasaiche far an urrainn dhut raointean foirme tarraing is leigeil a-nuas.
Tarraing raon ainmhidhe, an uairsin faic ID air a chòdachadh san URL. Tha coltas air rudeigin mar 'dHBsMTRlZTQ0ZWUtZGE0Ni0xMWVmLTllZmUtMDI5ZGQ0ODkzZGRk'.
Dèan base64 decode air an ID seo agus chì thu gur e UUID a th’ ann le ‘tpl’ air thoiseach air. ’S e am pàirt UUID (cuir air falbh ‘tpl’) an pdfID agad. Faic barrachd mu IDan Legalesign.
Bidh ur uri stòrais PDF API mar - /api/v1/templatepdf/:pdfId/.
Cuir sin anns an fheart ‘templatepdf’ anns an gairm send document.
Ma tha thu an dùil an PDF seo a chuir a-mach barrachd air aon turas, dèan cinnteach nach eil ‘Auto archive’ air a chur an gnìomh. Faic mar a nì thu
2. Cleachd co-òrdanaichean x/y airson raointean.
Is e an dòigh as sìmplidh airson tòiseachadh le co-òrdanaichean x/y a bhith a’ suidheachadh PDF san app-lìn agus an uair sin iarrtas API a dhèanamh airson na raointean sin (GET PDF Fields - /api/v1/templatepdf/:pdfId/fields/).
Tha am prògram JSON a gheibh thu air ais na shreang schema JSON a dhìth ort airson raointean a chruthachadh cuideachd.
Cleachd e mar theamplaid. Atharraich luachan sam bith agus cuir POST air ais chun an aon phuing-fosglaidh (le atharrachadh ID PDF mar a dhìth). Cruthaich puing-fosglaidh raon PDF.
3. Cuir am duilleag deasaiche PDF againn a-steach. ÙR!
Cleachd am pàirtiche deasaiche againn gus an deasaiche PDF againn a chur a-steach dìreach anns an aplacaid agad fhèin. Faigh tuilleadh fiosrachaidh mun phàirtiche deasaiche sgrìobhainnean.
4. Raointean Foirm PDF ÙR!
Ma tha raointean Foirm PDF àbhaisteach anns an PDF agad, faodaidh Legalesign an toirt a-steach gu fèin-obrachail.
Còdaich gu math!
Anns an tutorial seo fhuair thu teisteanasan API, rinn thu cheistean soirbheachail airson do bhuidhnean, chuir thu a-mach sgrìobhainn airson ainm a chleachdadh HTML agus PDF, agus luchdaich thu sìos sgrìobhainn air a shoidhnigeadh.
Còdaich gu math! Tha sinn an seo airson do chuideachadh, cuir fios gu [taic] (https://support.legalesign.com) airson cuideachadh sam bith.
Math dhut, ràinig thu deireadh – tapadh leat airson a bhith a’ leughadh. Is e an iarrtas mu dheireadh agus comhairle, stèidhichte air bliadhnaichean de eòlas air luchd-leasachaidh aig a bheil aonachadh leis an API seo, gu gabh ùine dhut fhèin gus na feartan uile air a’ phuing-fosglaidh cruthachadh sgrìobhainn a leughadh (agus cliog a-steach airson faicinn dè tha ‘signers’, ‘pdftext’ agus ‘signertext’ a’ toirt a-steach) - ‘s e an gairm as cudromaiche ann an do aonachadh a th’ ann. Cruthaich sgrìobhainn ainmichte.