FilesExpand file tree

main

/

lock.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

60 lines (55 loc) · 1.35 KB

main

/

lock.go

Copy path

Top

File metadata and controls

• Code
• Blame

60 lines (55 loc) · 1.35 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

package api

import "bytes"

import "encoding/json"

import "errors"

import "licensezero.com/cli/data"

import "io/ioutil"

import "net/http"

import "strconv"

import "fmt"

type lockRequest struct {

Action string `json:"action"`

DeveloperID string `json:"developerID"`

Token string `json:"token"`

OfferID string `json:"offerID"`

Unlock string `json:"unlock"`

}

type lockResponse struct {

Error interface{} `json:"error"`

}

// Lock sends a lock API request.

func Lock(developer *data.Developer, offerID string, unlock string) error {

bodyData := lockRequest{

Action: "lock",

OfferID: offerID,

Unlock: unlock,

DeveloperID: developer.DeveloperID,

Token: developer.Token,

}

body, err := json.Marshal(bodyData)

if err != nil {

return err

}

fmt.Println(string(body))

response, err := http.Post("https://licensezero.com/api/v0", "application/json", bytes.NewBuffer(body))

if err != nil {

return err

}

if response.StatusCode != 200 {

return errors.New("Server responded " + strconv.Itoa(response.StatusCode))

}

defer response.Body.Close()

responseBody, err := ioutil.ReadAll(response.Body)

if err != nil {

return err

}

var parsed lockResponse

err = json.Unmarshal(responseBody, &parsed)

if err != nil {

return err

}

if message, ok := parsed.Error.(string); ok {

return errors.New(message)

}

return nil

}