FilesExpand file tree

 master

/

gists_comments.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

119 lines (100 loc) · 3.24 KB

 master

/

gists_comments.go

Copy path

Top

File metadata and controls

• Code
• Blame

119 lines (100 loc) · 3.24 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

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

// Copyright 2013 The go-github AUTHORS. All rights reserved.

//

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package github

import (

"context"

"fmt"

"time"

)

// GistComment represents a Gist comment.

type GistComment struct {

ID *int64 `json:"id,omitempty"`

URL *string `json:"url,omitempty"`

Body *string `json:"body,omitempty"`

User *User `json:"user,omitempty"`

CreatedAt *time.Time `json:"created_at,omitempty"`

}

func (g GistComment) String() string {

return Stringify(g)

}

// ListComments lists all comments for a gist.

//

// GitHub API docs: https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist

func (s *GistsService) ListComments(ctx context.Context, gistID string, opt *ListOptions) ([]*GistComment, *Response, error) {

u := fmt.Sprintf("gists/%v/comments", gistID)

u, err := addOptions(u, opt)

if err != nil {

return nil, nil, err

}

req, err := s.client.NewRequest("GET", u, nil)

if err != nil {

return nil, nil, err

}

var comments []*GistComment

resp, err := s.client.Do(ctx, req, &comments)

if err != nil {

return nil, resp, err

}

return comments, resp, nil

}

// GetComment retrieves a single comment from a gist.

//

// GitHub API docs: https://developer.github.com/v3/gists/comments/#get-a-single-comment

func (s *GistsService) GetComment(ctx context.Context, gistID string, commentID int64) (*GistComment, *Response, error) {

u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)

req, err := s.client.NewRequest("GET", u, nil)

if err != nil {

return nil, nil, err

}

c := new(GistComment)

resp, err := s.client.Do(ctx, req, c)

if err != nil {

return nil, resp, err

}

return c, resp, nil

}

// CreateComment creates a comment for a gist.

//

// GitHub API docs: https://developer.github.com/v3/gists/comments/#create-a-comment

func (s *GistsService) CreateComment(ctx context.Context, gistID string, comment *GistComment) (*GistComment, *Response, error) {

u := fmt.Sprintf("gists/%v/comments", gistID)

req, err := s.client.NewRequest("POST", u, comment)

if err != nil {

return nil, nil, err

}

c := new(GistComment)

resp, err := s.client.Do(ctx, req, c)

if err != nil {

return nil, resp, err

}

return c, resp, nil

}

// EditComment edits an existing gist comment.

//

// GitHub API docs: https://developer.github.com/v3/gists/comments/#edit-a-comment

func (s *GistsService) EditComment(ctx context.Context, gistID string, commentID int64, comment *GistComment) (*GistComment, *Response, error) {

u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)

req, err := s.client.NewRequest("PATCH", u, comment)

if err != nil {

return nil, nil, err

}

c := new(GistComment)

resp, err := s.client.Do(ctx, req, c)

if err != nil {

return nil, resp, err

}

return c, resp, nil

}

// DeleteComment deletes a gist comment.

//

// GitHub API docs: https://developer.github.com/v3/gists/comments/#delete-a-comment

func (s *GistsService) DeleteComment(ctx context.Context, gistID string, commentID int64) (*Response, error) {

u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)

req, err := s.client.NewRequest("DELETE", u, nil)

if err != nil {

return nil, err

}

return s.client.Do(ctx, req, nil)

}