github.com/mailgun/mailgun-go/v3@v3.6.4/template.go (about) 1 package mailgun 2 3 import ( 4 "context" 5 "errors" 6 "strconv" 7 ) 8 9 type TemplateEngine string 10 11 // Used by CreateTemplate() and AddTemplateVersion() to specify the template engine 12 const ( 13 TemplateEngineMustache = TemplateEngine("mustache") 14 TemplateEngineHandlebars = TemplateEngine("handlebars") 15 TemplateEngineGo = TemplateEngine("go") 16 ) 17 18 type Template struct { 19 Name string `json:"name"` 20 Description string `json:"description"` 21 CreatedAt RFC2822Time `json:"createdAt"` 22 Version TemplateVersion `json:"version,omitempty"` 23 } 24 25 type templateResp struct { 26 Item Template `json:"template"` 27 Message string `json:"message"` 28 } 29 30 type templateListResp struct { 31 Items []Template `json:"items"` 32 Paging Paging `json:"paging"` 33 } 34 35 // Create a new template which can be used to attach template versions to 36 func (mg *MailgunImpl) CreateTemplate(ctx context.Context, template *Template) error { 37 r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint)) 38 r.setClient(mg.Client()) 39 r.setBasicAuth(basicAuthUser, mg.APIKey()) 40 41 payload := newUrlEncodedPayload() 42 43 if template.Name != "" { 44 payload.addValue("name", template.Name) 45 } 46 if template.Description != "" { 47 payload.addValue("description", template.Description) 48 } 49 50 if template.Version.Engine != "" { 51 payload.addValue("engine", string(template.Version.Engine)) 52 } 53 if template.Version.Template != "" { 54 payload.addValue("template", template.Version.Template) 55 } 56 if template.Version.Comment != "" { 57 payload.addValue("comment", template.Version.Comment) 58 } 59 60 var resp templateResp 61 if err := postResponseFromJSON(ctx, r, payload, &resp); err != nil { 62 return err 63 } 64 *template = resp.Item 65 return nil 66 } 67 68 // GetTemplate gets a template given the template name 69 func (mg *MailgunImpl) GetTemplate(ctx context.Context, name string) (Template, error) { 70 r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + name) 71 r.setClient(mg.Client()) 72 r.setBasicAuth(basicAuthUser, mg.APIKey()) 73 r.addParameter("active", "yes") 74 75 var resp templateResp 76 err := getResponseFromJSON(ctx, r, &resp) 77 if err != nil { 78 return Template{}, err 79 } 80 return resp.Item, nil 81 } 82 83 // Update the name and description of a template 84 func (mg *MailgunImpl) UpdateTemplate(ctx context.Context, template *Template) error { 85 if template.Name == "" { 86 return errors.New("UpdateTemplate() Template.Name cannot be empty") 87 } 88 89 r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + template.Name) 90 r.setClient(mg.Client()) 91 r.setBasicAuth(basicAuthUser, mg.APIKey()) 92 p := newUrlEncodedPayload() 93 94 if template.Name != "" { 95 p.addValue("name", template.Name) 96 } 97 if template.Description != "" { 98 p.addValue("description", template.Description) 99 } 100 101 var resp templateResp 102 err := putResponseFromJSON(ctx, r, p, &resp) 103 if err != nil { 104 return err 105 } 106 *template = resp.Item 107 return nil 108 } 109 110 // Delete a template given a template name 111 func (mg *MailgunImpl) DeleteTemplate(ctx context.Context, name string) error { 112 r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint) + "/" + name) 113 r.setClient(mg.Client()) 114 r.setBasicAuth(basicAuthUser, mg.APIKey()) 115 _, err := makeDeleteRequest(ctx, r) 116 return err 117 } 118 119 type TemplatesIterator struct { 120 templateListResp 121 mg Mailgun 122 err error 123 } 124 125 type ListTemplateOptions struct { 126 Limit int 127 Active bool 128 } 129 130 // List all available templates 131 func (mg *MailgunImpl) ListTemplates(opts *ListTemplateOptions) *TemplatesIterator { 132 r := newHTTPRequest(generateApiUrl(mg, templatesEndpoint)) 133 r.setClient(mg.Client()) 134 r.setBasicAuth(basicAuthUser, mg.APIKey()) 135 if opts != nil { 136 if opts.Limit != 0 { 137 r.addParameter("limit", strconv.Itoa(opts.Limit)) 138 } 139 if opts.Active { 140 r.addParameter("active", "yes") 141 } 142 } 143 url, err := r.generateUrlWithParameters() 144 return &TemplatesIterator{ 145 mg: mg, 146 templateListResp: templateListResp{Paging: Paging{Next: url, First: url}}, 147 err: err, 148 } 149 } 150 151 // If an error occurred during iteration `Err()` will return non nil 152 func (ti *TemplatesIterator) Err() error { 153 return ti.err 154 } 155 156 // Next retrieves the next page of items from the api. Returns false when there 157 // no more pages to retrieve or if there was an error. Use `.Err()` to retrieve 158 // the error 159 func (ti *TemplatesIterator) Next(ctx context.Context, items *[]Template) bool { 160 if ti.err != nil { 161 return false 162 } 163 ti.err = ti.fetch(ctx, ti.Paging.Next) 164 if ti.err != nil { 165 return false 166 } 167 cpy := make([]Template, len(ti.Items)) 168 copy(cpy, ti.Items) 169 *items = cpy 170 if len(ti.Items) == 0 { 171 return false 172 } 173 return true 174 } 175 176 // First retrieves the first page of items from the api. Returns false if there 177 // was an error. It also sets the iterator object to the first page. 178 // Use `.Err()` to retrieve the error. 179 func (ti *TemplatesIterator) First(ctx context.Context, items *[]Template) bool { 180 if ti.err != nil { 181 return false 182 } 183 ti.err = ti.fetch(ctx, ti.Paging.First) 184 if ti.err != nil { 185 return false 186 } 187 cpy := make([]Template, len(ti.Items)) 188 copy(cpy, ti.Items) 189 *items = cpy 190 return true 191 } 192 193 // Last retrieves the last page of items from the api. 194 // Calling Last() is invalid unless you first call First() or Next() 195 // Returns false if there was an error. It also sets the iterator object 196 // to the last page. Use `.Err()` to retrieve the error. 197 func (ti *TemplatesIterator) Last(ctx context.Context, items *[]Template) bool { 198 if ti.err != nil { 199 return false 200 } 201 ti.err = ti.fetch(ctx, ti.Paging.Last) 202 if ti.err != nil { 203 return false 204 } 205 cpy := make([]Template, len(ti.Items)) 206 copy(cpy, ti.Items) 207 *items = cpy 208 return true 209 } 210 211 // Previous retrieves the previous page of items from the api. Returns false when there 212 // no more pages to retrieve or if there was an error. Use `.Err()` to retrieve 213 // the error if any 214 func (ti *TemplatesIterator) Previous(ctx context.Context, items *[]Template) bool { 215 if ti.err != nil { 216 return false 217 } 218 if ti.Paging.Previous == "" { 219 return false 220 } 221 ti.err = ti.fetch(ctx, ti.Paging.Previous) 222 if ti.err != nil { 223 return false 224 } 225 cpy := make([]Template, len(ti.Items)) 226 copy(cpy, ti.Items) 227 *items = cpy 228 if len(ti.Items) == 0 { 229 return false 230 } 231 return true 232 } 233 234 func (ti *TemplatesIterator) fetch(ctx context.Context, url string) error { 235 r := newHTTPRequest(url) 236 r.setClient(ti.mg.Client()) 237 r.setBasicAuth(basicAuthUser, ti.mg.APIKey()) 238 239 return getResponseFromJSON(ctx, r, &ti.templateListResp) 240 }