Stiùireadh Luath

comhairle

A’ cleachdadh Cursor, Claude, no inneal AI eile airson còdachadh? Ceangail e ris na sgrìobhainnean Legalesign airson taic fhaighinn stèidhichte air co-theacsa fhad ‘s a leanas tu an stiùireadh seo.

Ann an an stiùireadh seo, bidh thu a’ coileant na prìomh ghairmean API a tha a’ mhòr-chuid de luchd-leasachaidh feumach orra anns an amalachadh eSignature - luchdachadh suas sgrìobhainn agus a chuir a-mach airson soidhnigeadh.

Tha Legalesign API sgèileach, ioma-ghnìomhach, agus air a dhearbhadh ann an siostaman ar luchd-cleachdaidh airson iomadh bliadhna. Faodaidh tu a chleachdadh airson sgrìobhainn le aon neach-soidhnigeadh, no cuir a-mach sgrìobhainnean airson fhianais no ceadan, air an optimize airson buidhearan, le foirmean agus barrachd. Faodaidh tu amalachadh airson aon adhbhar no a thoirt a-staigh taobh a-staigh do bhathar-bog airson do luchd-ceannach - faic amalachaidhean.

Tha am REST API a’ dèanamh a’ mhòr-chuid de ghnìomhachdan agus ’s e an dòigh as fhasa tòiseachadh. Ma tha feum agad air barrachd, thoir sùil air an GraphQL interface. Tha Legalesign API an toiseach le GraphQL. Faodaidh tu an dà chuid a chleachdadh, mar as fheàrr leat.

Leanaidh sinn na ceumannan seo:

1. Cruthaich cunntas + iuchair API (faic Faigh dearbhadh airson ruigsinneachd API).
2. Dearbhaich gu bheil na creideasan ag obair agus faigh do ID sgioba.
3. Luchdaich suas sgrìobhainn tron app-lìn.
4. Cuir e a-mach airson soidhnigeadh tron API.
5. Luchdaich sìos e às dèidh soidhnigeadh.
6. Luchdaich suas sgrìobhainn tron API.

Tha an REST API Legalesign furasta a chleachdadh. Tha an iomradh teignigeach a’ toirt a-steach deasaiche còd. Faodaidh tu iarraidh dìreach bhon iomradh teignigeach leis an iuchair API agad, no dìreach lethbhreac is pasgadh gu dìreach a-steach don chòd agad.

Figura 1: Deasaiche Còd REST API.

Leabharlannan Cliant

• C# + Mar a nì thu e
• Java
• Node.js
• PHP
• Python
• Ruby

No airson an eadar-aghaidh GraphQL Node.js

comhairle

Tha sinn a’ moladh gun obraich luchd-leasachaidh gu dìreach leis an API seach na SDKan. Gus cuideachadh, tha gineadair còd gearr is pasg anns an sònrachadh teignigeach, agus faodaidh do AI anntaexamples luath a thoirt gu buil a’ cleachdadh an OpenAPI spec. Carson? Tha barrachd ghnìomhan aig API na na SDKan, bidh thu airson aithneachadh air na puingean deireannach a chleachdas tu a h-uile cùis, seachain thu cus-anail agus eisimeileachd, agus - stèidhichte air ar n-eòlas- cuir crìoch air nas luaithe cuideachd.

1. Cruthaich cunntas

Rach gu legalesign sign up agus lean a’ phròiseas gus cunntas a chruthachadh.

Bidh iarrtas ort sgioba a chruthachadh. ’S e na sgeilpichean togail aig Legalesign sgiobanan. Tha a h-uile làimhseachadh sgrìobhainn a’ tachairt ann an sgioba. Feumaidh tu iomradh a thoirt air do sgioba ann am barrachd a’ mhòr-chuid de ghairmean API.

fiosrachadh

Tha 'sgioba' no 'buidheann' an aon rud. Anns an app-lìn bidh sinn a’ bruidhinn mu dheidhinn 'sgiobanan', ach anns an schema API ’s e buidheann a th' ann.

Suidhichidhean API

Rach gu API Dashboard. Dèan gineadh air do chreideasan API anns an earrann iuchair API.

Gabh mionaid airson ath-sgrùdadh a dhèanamh air a’ Phuirt-ùrlar Luchd-leasachaidh.

Àrainneachd Sandbox

Ann an Earrann Àrainneachd, thig rabhadh a-mach ma tha thu ann an modh sandbox no riochdachail.

Tha cuingealachaidhean ann an Sandbox air càite a bheir thu do sgrìobhainnean. Chì thu foirm gus suas ri 5 puist-d ceadaichte a chur ris - cuir beagan a-nis.

Nuair a tha d’ amalachadh deiseil: gluais gu modh riochdachail.

comhairle

Cruthaich dàrna sgioba. Cleachd an sgioba agad a’ chiad fhear airson leasachadh agus sgiobanan eile airson riochdachadh. Inns don taic ainm do sgioba leasachaidh gus a thoirt a-mach às a’ bhileachaidh.

Iuchair API

Anns an earrann iuchair API chì thu mion-fhiosrachadh do na iuchraichean API agad. Cha chaith thu ach am prìomh iuchair fhaicinn nuair a chuireas tu fear ùr.

Tha earrann an Quickstart a’ toirt a-steach eisimpleirean gearraidh is pasgaidh gus do iuchair a dhearbhadh.

Webhooks & Logannan

Cur ris na webhooks (na luchd-èisteachd agad airson tachartasan Legalesign), agus dèan ath-sgrùdadh air na logannan 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 creideasan agad ag obair. Cuir àite ainm-cleachdaidh agus prìomh luachan anns a’ chòd gu h-ìosal.

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

curl -H "Authorization: ApiKey username:secret" -H "Content-Type: application/json" -X GET https://eu-api.legalesign.com/api/v1/group/

Node.js

import fetch from 'node-fetch';

async function getGroups() {
  const response = await fetch('https://eu-api.legalesign.com/api/v1/group/', {
    method: 'GET',
    headers: {
      'Authorization': 'ApiKey username:secret',
      '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);
});

Python

import requests

headers = {
    "Authorization": "ApiKey username:secret",
    "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())

C#

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", "ApiKey username:secret");
        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);
    }
}

Go

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", "ApiKey username:secret")
	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 API GET buidheann.

Nuair a ruith thu an ceist gu h-ìosal, chì thu na buidhnean agad air ais ann an JSON. Soirbheachas. 👏

Tha am fiosrachadh freagairt a’ toirt a-steach ‘resource uri’ airson do bhuidheann agus tha e coltach ri /api/v1/group/:groupId/. Thoir nota dhut, feumaidh tu seo airson a’ mhòr-chuid de ghairmean API.

comhairle

Bidh resource URI an-còmhnaidh air a chruthachadh mar an ceudna. Airson PDF bhiodh e '/api/v1/templatepdf/:pdfId/', airson sgrìobhainn a chaidh a chuir bidh e '/api/v1/document/:documentId/'. Tha e cudromach gun crìochnaich na URIs gu lèir le slàsair. Tha seo fìor cuideachd airson na h-URLs airson na gairmean API agad, crìochnaich iad an-còmhnaidh le slàsair.

Ma dh’fhàillig an iarrtas GET, dèan cinnteach gu bheil:

• Tha do ApiKey air a chruthachadh gu ceart (a’ tòiseachadh le 'ApiKey),
• Tha ceann-sgrìobhainn Content-Type agad airson application/json, agus
• Tha do URL a’ crìochnachadh le slàsair.

Faic cuideachd fuasgladh dhuilgheadasan.

3. Luchdaich suas sgrìobhainn tron app-lìn

Gus tòiseachadh, luchdich suas sgrìobhainn tron app-lìn agus cuir a-mach sin tron API. Bheir sinn cunntas air mar a luchdaich thu suas sgrìobhainn tron API nas fhaide air adhart.

Rach gu app-lìn agus luchdaich suas do sgrìobhainn. Cuir dreuchd neach-soidhnigeadh singilte ris agus tarraing raon soidhnidh. Thèid an duilleag deasaiche a chomharrachadh a bheil an sgrìobhainn ‘dligheach’ no nach eil (mar eisimpleir ’s dòcha gum bi ‘neo-dligheach’ mura cuir thu dreuchd neach-soidhnigeadh gun raon soidhnidh co-cheangailte).

Air an deasaiche foirm, lethbhreac an ID alphanumerach fhada bhon URL, dèan decòd base64 air agus caith air falbh na trì litrichean tosaigh (a bu chòir a bhith 'tpl'). Is e an còrr UUID a tha agad.

Ann an cànan REST API ’s e resource uri airson an sgrìobhainn seo /api/v1/templatepdf/UUID/.

Barrachd ionnsachadh mu IDs lìn is API.

’S e ar n-ainmneachadh gur e ‘teamplate’ a th’ ann an sgrìobhainn air a luchdachadh suas agus nuair a chuir thu a-mach fear, tha thu a’ cruthachadh ‘document’.

comhairle

Ma tha thu airson archive a dhèanamh air teamplate nuair a thèid an sgrìobhainn a chuir a-mach, cuir ‘archive_upon_send’ mar shònrachadh anns an iarrtas luchdachaidh. Ma tha thu airson nach nochd an teamplate gu bràth agus gun tèid a dhubhadh às às dèidh cur a-mach, cuir an tiotal '[deleted]' - bidh ar siostaman sganadh ga thaobh agus ga dhubhadh às às dèidh latha no dhà. Faodaidh tu cuideachd ùine gleidhidh-beag sìos a shuidheachadh aig ìre buidhne - barrachd ionnsachadh.

4. Cuir a-mach sgrìobhainn airson soidhnigeadh

A-nis cuir sinn seo tron API. Cuimhnich cleachdadh puist-d anns na puist-d ‘ceadaichte’ agad anns an sandbox. Cleachd na tabaichean gu h-ìosal gus an iarrtas fhaighinn anns an cànan as fheàrr leat.

cURL

curl -H "Authorization: ApiKey [username]:[secret]" -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/

Node.js

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': 'ApiKey [username]:[secret]',
      '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);
});

Python

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": "ApiKey [username]:[secret]",
    "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"))

C#

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", "ApiKey [username]:[secret]");

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

Go

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", "ApiKey [username]:[secret]")
	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 bòrd-camaichean uile. Iomradh API airson sgrìobhainn a cur.

comhairle

Nuair a thadhlas tu air an iomradh sgrìobhainnean airson sgrìobhainn a chur, thoir sùil mhath air na h-aoisean iomchaidh uile. Chì thu mòran a chuidicheas le cleachdaidhean amalachaidh - bileagan airson stadan is IDs agad fhèin (a thig air ais thugad ann an webhooks), ath-stiùireadh airson luchd-soidhnigeadh, cuir teacsa gnàthaichte sa pdf, agus barrachd.

Gairm soirbheachail bheir e còd inbhe 201. ✨

Faigh ID an sgrìobhainn ùr a chaidh a chuir

Is e prìomh phàirt na freagairt ceann-sgrìobhainn an àiteachaidh. Tha seo a’ toirt dhut ID ùr an sgrìobhainn.

comhairle

Cleachd bileagan ‘tag’ air sgrìobhainnean agus cuir do dh’ iomraidhean fhèin airson ceangal fèin-ghluasadach ris an stòr-dàta agad fhèin.

Bidh an ceann-sgrìobhainn àiteachaidh a’ coimhead mar /api/v1/status/:documentId/.

Bidh an URI ‘status’ a’ toirt air ais goirid (agus luath airson ceasnachadh) de shònrachaidhean sgrìobhainn.

Gus a h-uile càil a thoirt air ais bho sgrìobhainn cleachd /api/v1/document/:documentId/.

fiosrachadh

Ma tha iarrtas mì-shoirbheachail, tha am BODHACHAN freagairt mar as trice a’ toirt a-steach fiosrachadh mu mhearachdan. Ma chan eil thu a’ faighinn còd soirbheachaidh, thoir sùil air am BODHACHAN airson teacsa mìneachaidh. Faic cuideachd fuasgladh dhuilgheadasan.

Barrachd ionnsachadh 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 a fhuair thu gu h-àrd, dèan iarrtas luchdaich sìos PDF anns an cànan a th’ agad:

cURL

curl -H "Authorization: ApiKey [username]:[secret]" -o download.pdf -X GET https://eu-api.legalesign.com/api/v1/pdf/:documentId/

Node.js

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': 'ApiKey [username]:[secret]',
    },
  });

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

Python

import requests

headers = {"Authorization": "ApiKey [username]:[secret]"}

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)

C#

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", "ApiKey [username]:[secret]");

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

Go

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", "ApiKey [username]:[secret]")

	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 luchdaich sìos PDF API.

Tha am faidhle PDF anns a’ bhodhaig freagairt. Bidh an àithne curl '-o' a’ cur am BODHACHAN freagairt gu dìreach ann am faidhle.

Bidh mòran leabharlannan REST no HTTP a’ làimhseachadh nithean freagairt HTTP mar gum biodh iad nan fhaidhlichean agus san aon dòigh sàbhail an t-uinneag freagairt agad mar thabhartas àbhaisteach.

comhairle

Cleachd webhooks airson fios fhaighinn mu tachartas soidhnigeadh agus an uairsin luchdaich sìos an sgrìobhainn. Faic webhooks.

6. Luchdaich suas PDF

Cliog an seo airson sample PDF le bileagan teacsa a luchdachadh sìos, barrachd mun raointean foirmean PDF ri thighinn.

Airson an gairm seo, tionndaidh am PDF agad gu sreang le còd base64. Chan eil seo air a dhèanamh gu ceart anns a’ ghineadair còd san sgrìobhainn. An àite sin, lethbhreac am pseudocode seo agus nì do AI càirdeil a thionndadh gu cànan na b’ 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': 'ApiKey username:secret',
  '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 luchdachadh suas PDF API.

Mar as àbhaist, thèid freagairt POST soirbheachail a thoirt seachad le inbhe ‘201’ agus bidh am ID ùr anns a’ cheann-sgrìobhainn ‘location’ den fhreagairt.

assert response.status == 201
pdfId = response.headers['location']

Bidh am resource URI pdf agad coltach ri /api/v1/templatepdf/:pdfId/.

Cuir a-mach an PDF ùr

Till air ais chun chòd a chleachd thu airson an sgrìobhainn a chuir a-mach an toiseach, agus cuir àite an luachan templatepdf.

Dèan an iarrtas a-rithist agus sin agad e, chuir thu do PDF a-mach airson soidhnigeadh.

Mus tòisich thu air còdachadh, leughidh tu a-steach gus barrachd ionnsachadh mu raointean PDF.

Dè mu dheidhinn raointean PDF?

Ciamar a tha Legalesign a’ faighinn a-mach càite an fheumar an neach soidhnigeadh a shoidhnigeadh air PDF, no roinnean ri atharrachadh nuair a thèid a chur a-mach? ’S e an fhreagairt gu bheil an PDF againn air a ullachadh ro-làimh le bileagan: chuir sinn bileag teacsa Legalesign taobh a-staigh a’ PDF agus shuidhich sinn 'process_tags' air fìor anns an iarrtas luchdachadh suas PDF.

[Download sample PDF le bileagan teacsa] (https://static.legalesign.com/tutorialQuickstartPdf.pdf).

Tha bileagan teacsa air an cruthachadh gu sònraichte airson a chur ann am PDF. Nì Legalesign sgrios air na bileagan anns an fhaidhle agad, ag ath-nuadhachadh nan bileagan le raointean soidhnidh agus foirm. Airson aon neach soidhnigeadh, chan fheumar ach <<t=signature>> a chur ris. Aithnicheas Legalesign e agus suidheachadh an soidhnidh an sin. Ionnsaich mu bhileagan teacsa.

Tha bileagan teacsa a’ toirt beagan oideachaidh agus feum air deuchainn is mearachd. Tha dòighean eile gu h-ìosal, ach gheibh thu comas làn na siostam foirmean Legalesign leotha. Cleachd an app-lìn gus bileagan a dheuchainn. Cuir fios gu taic airson cuideachadh agus eisimpleirean.

Seo ceithir dòighean eile air raointean a shuidheachadh:

1. An dreach as fhasa/as luaithe. Suidhich am PDF agad a’ cleachdadh app-lìn Legalesign.

Às dèidh dhut PDF a luchdachadh, thèid thu gu an eadar-aghaidh deasaiche far an urrainn dhut raointean foirmeachaidh a tharraing is a leigeil sìos.

Tarraing agus leig sìos raon soidhnidh, an uairsin gabh an ID a dh’ encoded anns an seòladh-lìn. Bidh seo coltach ri ‘dHBsMTRlZTQ0ZWUtZGE0Ni0xMWVmLTllZmUtMDI5ZGQ0ODkzZGRk’.

Dèan decòd base64 air an ID seo agus chì thu UUID le ‘tpl’ mar ro-ainm. ’S e an UUID (gun 'tpl') am PDFID agad. Barrachd ionnsachadh mu IDs Legalesign.

Bidh am resource uri PDF API agad mar - /api/v1/templatepdf/:pdfId/.

Cuir seo a-steach mar shònrachadh 'templatepdf' anns a’ ghairm send document.

fiosrachadh

Ma tha thu an dùil an PDF seo a chur a-mach barrachd air aon turas, dèan cinnteach gun tèid ‘Auto archive’ a chuir dheth. Faic mar a nì thu seo.

2. Cleachd co-òrdanaichean x/y airson raointean.

Is e am modh as sìmplidh airson tòiseachadh le co-òrdanaichean x/y a bhith a’ suidheachadh PDF san app-lìn agus an uairsin iarrtas API airson na raointean sin ( GET PDF Fields - /api/v1/templatepdf/:pdfId/fields/ ).

Is e an aon JSON schema a gheibh thu air ais a tha a dhìth ort airson raointean a chruthachadh cuideachd.

Cleachd e mar teamplate. Atharraich luachan sam bith agus cuir air ais e gu an aon phuing trèanaidh (a’ dèanamh atharrachadh air an ID PDF mar a tha iomchaidh). Suidheachadh Raon PDF .

3. Cuir an duilleag deasaiche PDF againn a-steach (NEW!)

Cleachd ar tocsainean deasaiche gus deasaiche PDF Legion a chuir beò anns an app agad fhèin. Barrachd ionnsachadh mun deasaiche sgrìobhainn.

4. Raointean Foirm PDF (NEW!)

Ma tha raointean Foirm PDF àbhaisteach anns am PDF agad, faodaidh Legalesign an toirt a-steach gu fèin-obrachail.

Còdadh sona!

Ann an an stiùireadh seo fhuair thu creideasan API, rinn thu ceist soirbheachail airson do bhuidheann(nan), chuir thu a-mach sgrìobhainn airson soidhnigeadh a’ cleachdadh HTML agus PDF, agus luchdaich thu sìos sgrìobhainn air a shoidhnigeadh.

Còdadh sona! Tha sinn an seo airson cuideachadh, cuir fios gu taic airson cuideachadh sam bith.

comhairle

Deagh obair, ràinig thu deireadh - tapadh leibh airson a bhith a’ leughadh seo. An iarrtas mu dheireadh againn, agus an comhairle, stèidhichte air iomadh bliadhna de eòlas leis luchd-leasachaidh a’ ceangal ri API seo, ’s e gum bi thu a’ gabhail mionaid gus na h-aoisean air an àrd-ùrlar create document a leughadh gu mionaideach (agus briogadh troimhe airson faicinn dè tha 'signers', 'pdftext' agus 'signertext' a’ toirt a-steach) - is e seo an gairm as cudromaiche anns an amalachadh agad. Cruthaich sgrìobhainn soidhnigeadh.

Ceumannan a leanas:

• Webhooks airson fiosan beòthail
• Cuir an deasaiche foirmean a-steach
• Cuir an duilleag soidhnigeadh a-steach