unisender

package module
v0.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 29, 2023 License: MIT Imports: 9 Imported by: 0

README

Golang API client for unisender.com

Travis Coverage Status Go Report Card GoDoc

Unisender – simple service for email and SMS campaigns. Examples and documentation available on godoc.

License

MIT License

Copyright (c) 2019 Alexey Popov

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Documentation

Overview

Package unisender allows to integrate with unisender.com – simple service for email and SMS campaigns.

Index

Examples

Constants

View Source 
const LanguageDefault = "ru"

LanguageDefault default API response language.

Variables

This section is empty.

Functions

This section is empty.

Types

type UniSender 

type UniSender struct {
	// contains filtered or unexported fields
}

UniSender API client struct.

func New 

func New(apiKey string) *UniSender

New returns new UniSender API client.

func (*UniSender) CancelCampaign 

func (u *UniSender) CancelCampaign(campaignID int64) *campaigns.CancelCampaignRequest

CancelCampaign returns request to cancel a scheduled campaign.

See: https://www.unisender.com/en/support/api/partners/cancel-campaign/

A campaign can be canceled if it has one of the following statuses:

  • "Planned",
  • "Scheduled" (scheduled),
  • "Considered by the administration" (censor_hold),
  • "Waiting for approval" (waits_censor).

The distribution status can be obtained using the getCampaignStatus method.

See: https://www.unisender.com/en/support/api/partners/getcampaignstatus/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	if err := usndr.CancelCampaign(123).Execute(); err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) CheckEmail 

func (u *UniSender) CheckEmail(emailIDs ...int64) *messages.CheckEmailRequest

CheckEmail returns request to check the delivery status of emails sent using the sendEmail method.

To speed up the work of the sendEmail method, delivery statuses are stored for a limited period of time, i.e. only for a month.

Status possible options: 

not_sent                      – The message has not been processed yet.

ok_sent                       – The message has been sent, it is in the intermediate status until the receipt
                                of the delivery/non-delivery response.

ok_delivered                  – The message has been delivered. It may change to ‘ok_read’, ‘ok_link_visited’,
                                ‘ok_unsubscribed’ or ‘ok_spam_folder’.

ok_read                       – The message has been delivered and its reading has been registered. It may change
                                to ‘ok_link_visited’, ‘ok_unsubscribed’ or ‘ok_spam_folder’.

ok_fbl                        – The message has been delivered but placed in the spam folder by the recipient.
                                Unfortunately, only some of the mail services report such information, so usually
                                you won’t receive a lot of responses with such status.

ok_link_visited               – The message has been delivered, read, and one of the links has been clicked through.
                                It may change to ‘ok_unsubscribed’ or ‘ok_spam_folder’.

ok_unsubscribed               – The message has been delivered and read, but the user unsubscribed using the link
                                in the letter. The status is final.

err_blacklisted               – The message has been rejected due to blacklisting.

err_will_retry                – One or more delivery attempts have been unsuccessful, but attempts continue.
                                The status is not final.

err_resend                    – Actually, it is equivalent to err_will_retry with some minor internal features.

err_internal                  – Internal failure. The letter needs to be re-sent. The status is final.

err_user_unknown              – The address does not exist, delivery failed. The status is final.

err_user_inactive             – The address used to exist before, but now it has been disabled. Delivery failed.
                                The status is final.

err_mailbox_discarded         – The recipient’s mailbox has been deleted. The status is final.

err_mailbox_full              – The recipient’s mailbox is full. The status is final.

err_no_dns                    – There is no record or an incorrect record in DNS.

err_no_smtp                   – There is an entry in DNS, but there is no smtp server.

err_domain_inactive           – The domain does not accept mail or does not exist. The status is final.

err_destination_misconfigured – The domain does not accept mail due to incorrect settings on the recipient’s side,
                                and the server’s response contains information about a cause that can be fixed
                                (for example, an inoperative blacklist is used, etc.).

err_spam_rejected             – The message was rejected by the server as a spam.

err_too_large                 – The letter exceeds the size allowed by the recipient’s server. Also, the reason
                                may be a rejection of the letter by the recipient’s server due to an unacceptable
                                attachment type. For example, .exe.

err_giveup                    – This status is assigned to messages with the err_will_retry, err_resend statuses
                                after expiration of the retry period.

err_spam_removed              – Sending has been canceled because the campaign has been clocked as a spam.
                                The status is not final, it can be changed to not_sent, delayed
                                or err_spam_may_retry after negotiations with the recipient’s mail service.

err_spam_may_retry            – It is equivalent to err_spam_rejected, but you can re-send the message
                                by generating a new similar letter.

ok_spam_folder                – The letter has been delivered, but the recipient’s server placed it
                                in the Spam folder. The status is final.

err_delivery_failed           – Delivery failed due to other reasons. The status is final.

err_will_retry                – One or more delivery attempts have been unsuccessful, but attempts continue.
                                The status is not final.

err_skip_letter               – Sending has been canceled because the email address is not available
                                (except for cases of err_unsubscribed and err_not_allowed).

err_spam_skipped              – Sending has been canceled because the campaign has been blocked as a spam.
                                The result is not final, it can be changed to not_sent, delayed
                                or err_spam_may_retry after negotiations with the recipient’s mail service.

err_unsubscribed              – The letter has not been sent as the address to which it was tried to be sent
                                has previously unsubscribed. You can mark this address as unsubscribed
                                in your database and not send messages to it any more. The status is final.

err_src_invalid               – Invalid sender’s email address. It is used if the “invalid sender’s email”
                                was discovered not at the stage of accepting the task and checking the parameters,
                                but at a later stage when the things to be sent are checked in detail.
                                The status is final.

err_dest_invalid              – Invalid recipient’s email address. It is used if the “invalid recipient’s email”
                                was discovered not at the stage of accepting the task and checking the parameters,
                                but at a later stage when the things to be sent are checked in detail.
                                The status is final.

err_not_allowed               – Sending has been canceled because technical support staff blocked the campaign,
                                or because of the recipient address or your account is blocked.
                                The status is final.

err_over_quota                – Sending has been canceled due to insufficiency of funds on the account or due
                                to an excess of the tariff.

err_not_available             – The address to which you have tried to send the letter is not available
                                (i.e., previous sending to this address resulted in a response
                                like “the address does not exist” or “block for spam” from the server).
                                Theoretically, the availability of the address can be restored in a few days
                                or weeks, so you may not eliminate it completely from the list of potential
                                recipients. The status is final.

err_unreachable               – Sending has been canceled because the address is not available, but, in contrast
                                to the err_not_available status, the availability of the address
                                will not be restored. The status is final.

err_lost                      – The letter wasn’t sent due to inconsistency of its parts (for example,
                                a link to the image in attachments is transferred in the letter body,
                                but the image itself is not transferred in the attachments), or it has been lost
                                because of the failure on our side. The sender needs to re-send the letter
                                on his own, since the original has not been saved. The status is final.

skip_dup_unreachable          – The address is unavailable, sending failed. The status is final.

skip_dup_temp_unreachable     – The address is temporarily unavailable. Sending failed. The status is final.

skip_dup_mailbox_full         – The recipient’s mailbox is full. The status is final.

See: https://www.unisender.com/en/support/api/messages/checkemail/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.CheckEmail(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) CheckSMS 

func (u *UniSender) CheckSMS(smsID int64) *messages.CheckSMSRequest

CheckSMS returns request to check the delivery status of sms sent using the sendSMS method.

Status possible options: 

not_sent            – The message has not been sent yet, and is waiting to be sent. The status will
                      be changed after sending.

ok_sent             – The message has been sent, but the delivery status is still unknown. The status is temporary
                      and may change.

ok_delivered        – The message has been delivered. The status is final.

err_src_invalid     – The delivery is not possible, the sender is set incorrectly. The status is final.

err_dest_invalid    – The delivery is not possible, a wrong number is indicated. The status is final.

err_skip_letter     – The delivery is impossible because the status of the phone number was changed
                      in the process of sending, or the phone number has been removed from the list,
                      or the letter has been deleted. The status is final.

err_not_allowed     – The delivery is not possible, this communications service provider is not serviced.
                      The status is final.

err_delivery_failed – The delivery failed — usually because of indication of a formally correct,
                      but non-existent number, or because the phone is turned off. The status is final.

err_lost            – The message has been lost, and the sender needs to re-send the message on his own,
                      since the original has not been saved. The status is final.

err_internal        – Internal failure. The message needs to be re-sent. The status is final.

See: https://www.unisender.com/en/support/api/partners/check-sms/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.CheckSMS(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) CreateCampaign 

func (u *UniSender) CreateCampaign(messageID int64) *campaigns.CreateCampaignRequest

CreateCampaign returns request used to schedule or immediately start sending email or SMS messages. The same message can be sent several times, but the moments of sending should have an interval of at least an hour.

See: https://www.unisender.com/en/support/api/partners/createcampaign/

This method is used to send the already created messages. To create messages in advance, use the createEmailMessage and createSmsMessage methods.

See: https://www.unisender.com/en/support/api/partners/createemailmessage/ See: https://www.unisender.com/en/support/api/partners/createsmsmessage/

Example 
package main

import (
	"log"
	"time"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.CreateCampaign(123).
		StartTime(time.Now().Add(3 * time.Hour)).
		TrackRead().
		TrackLinks().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) CreateEmailMessage 

func (u *UniSender) CreateEmailMessage(listID int64) *messages.CreateEmailMessageRequest

CreateEmailMessage returns request to create an email without sending it. The email is sent using another method — createCampaign.

See: https://www.unisender.com/en/support/api/partners/createemailmessage/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.CreateEmailMessage(123).
		SenderName("John Doe").
		SenderEmail("foo@bar.example").
		Subject("Welcome aboard!").
		Body("<b>Hi!</b>").
		GenerateText().
		WrapTypeSkip().
		LangDE().
		Tag("foo").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) CreateEmailTemplate 

func (u *UniSender) CreateEmailTemplate(title string) *messages.CreateEmailTemplateRequest

CreateEmailTemplate returns request to create an email template for a mass campaign.

See: https://www.unisender.com/en/support/api/partners/createemailmessage/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.CreateEmailTemplate("My template title").
		Subject("Welcome aboard!").
		Body("<b>Hi!</b>").
		LangDE().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) CreateField 

func (u *UniSender) CreateField(name string) *contacts.CreateFieldRequest

CreateField returns request to create a new user field, the value of which can be set for each recipient, and then it can be substituted in the letter.

See: https://www.unisender.com/en/support/api/partners/createfield/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	fieldID, err := usndr.CreateField("SomeField").
		TypeString().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(fieldID)
}

Output:

func (*UniSender) CreateList 

func (u *UniSender) CreateList(title string) *lists.CreateListRequest

CreateList returns request to create a new contact list.

See https://www.unisender.com/en/support/api/partners/createlist/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.CreateList("My new mailing list").
		BeforeSubscribeUrl("https://before-subscribe.url").
		AfterSubscribeUrl("https://after-subscribe.url").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) CreateSMSMessage 

func (u *UniSender) CreateSMSMessage(sender string) *messages.CreateSMSMessageRequest

CreateSMSMessage returns request to create an sms without sending it. The sms is sent using another method — createCampaign.

See: https://www.unisender.com/en/support/api/messages/createsmsmessage/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.CreateSMSMessage("+1234567").
		Body("<b>Hi!</b>").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) DeleteField 

func (u *UniSender) DeleteField(fieldID int64) *contacts.DeleteFieldRequest

DeleteField returns request to delete a user field.

See: https://www.unisender.com/en/support/api/partners/deletefield/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.DeleteField(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) DeleteList 

func (u *UniSender) DeleteList(listID int64) *lists.DeleteListRequest

DeleteList returns request to delete a list.

See https://www.unisender.com/en/support/api/partners/deletelist/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.DeleteList(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) DeleteMessage 

func (u *UniSender) DeleteMessage(messageID int64) *messages.DeleteMessageRequest

DeleteMessage returns request to delete a message.

See: https://www.unisender.com/en/support/api/partners/deletemessage/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.DeleteMessage(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) DeleteTag 

func (u *UniSender) DeleteTag(tagID int64) *contacts.DeleteTagRequest

DeleteTag returns request to delete a user tag.

See: https://www.unisender.com/en/support/api/partners/deletetag/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.DeleteTag(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) DeleteTemplate 

func (u *UniSender) DeleteTemplate(messageID int64) *messages.DeleteTemplateRequest

DeleteTemplate returns request to delete a template.

See: https://www.unisender.com/en/support/api/partners/deletetemplate/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.DeleteTemplate(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) Exclude 

func (u *UniSender) Exclude(contact string) *contacts.ExcludeRequest

Exclude returns request, that excludes the contact’s email or phone number from one or several lists. In contrast to the unsubscribe method, it does not mark the contact as "unsubscribed", and it can be included in the list again later using the subscribe method.

See https://www.unisender.com/en/support/api/partners/exclude/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	email := "foo@bar.example"
	err := usndr.Exclude(email).
		ContactTypeEmail().
		ListIDs(1, 2, 3).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) ExportContacts 

func (u *UniSender) ExportContacts() *contacts.ExportContactsRequest

ExportContacts returns request, that exports of contact data from UniSender.

See https://www.unisender.com/en/support/api/contacts/exportcontacts/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.ExportContacts().
		EmailStatusBlocked().
		NotifyUrl("https://foo.bar/example").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetActualMessageVersion 

func (u *UniSender) GetActualMessageVersion(messageID int64) *messages.GetActualMessageVersionRequest

GetActualMessageVersion returns request to get actual message version. The version history functionality is implemented in your personal account in UniSender. You can edit a letter you have sent before, or change the mailing list, and in this case a new version of the letter will be created. The version is the message_id that is transferred when the campaign is created with createCampaign method. The current version can be only one. You can specify in the personal account interface which version is considered relevant. When you create campaigns using API, the version history functionality is not supported: when you edit a letter that has not been previously sent within campaigns (updateEmailMessage method), message_id is not changed; when you edit a letter that has been previously sent, the result of calling the updateEmailMessage method will be a letter with a new id.

Since users can use both the API integration and the UniSender personal account, there are situations when users create new versions of a letter in the personal account. Since irrelevant versions of the letter cannot be sent, the error will be returned to the user if he tries to use message_id of an irrelevant version of the letter: «error»: «Unable to create campaign. The letter has a new version (12345678)».

See: https://www.unisender.com/en/support/api/partners/get-actual-message-version/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetActualMessageVersion(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetCampaignCommonStats 

func (u *UniSender) GetCampaignCommonStats(campaignID int64) *campaigns.GetCampaignCommonStatsRequest

GetCampaignCommonStats general information about the results of delivering messages in the given list.

See: https://www.unisender.com/en/support/api/partners/get-campaign-common-stats/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetCampaignCommonStats(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetCampaignStatus 

func (u *UniSender) GetCampaignStatus(campaignID int64) *campaigns.GetCampaignStatusRequest

GetCampaignStatus returns request to find out the status of the campaign.

Campaign status possible options: 

waits_censor   — campaign is waiting to be checked.

censor_hold    — it is actually equivalent to waits_censor: considered by the administrator, but delayed
                 for further check.

declined       — the campaign has been rejected by administrator.

waits_schedule — the task for placing the list in the queue has been received and the campaign is waiting
                 to be placed in the queue. As a rule, the campaign stays in this status one or two minutes
                 before changing its status on scheduled.

scheduled      — scheduled to be launched. It will be launched as soon as the sending time comes.

in_progress    — messages are being sent.

analysed       — all messages have been sent, the results are being analyzed.

completed      — all messages have been sent and analysis of the results is completed.

stopped        — the campaign is paused.

canceled       — the campaign is canceled (usually due to the lack of money or at the request of the user).

See: https://www.unisender.com/en/support/api/partners/getcampaignstatus/

func (*UniSender) GetCampaigns 

func (u *UniSender) GetCampaigns() *campaigns.GetCampaignsRequest

GetCampaigns returns request to get the list of all available campaigns. The number of mailings received at a time is limited to 10,000. To get a complete mailings list when there is more than 10,000, use the from and to parameters.

See: https://www.unisender.com/en/support/statistics/getcampaigns/

Example 
package main

import (
	"log"
	"time"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetCampaigns().
		From(time.Now().Add(-time.Hour)).
		To(time.Now()).
		Limit(100).
		Offset(0).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetCheckedEmail 

func (u *UniSender) GetCheckedEmail(login string) *partners.GetCheckedEmailRequest

GetCheckedEmail returns request, that gets an object with confirmed and unconfirmed sender’s addresses. Unconfirmed sender’s address is the address to which the message was sent with a link to confirm the return address, but the confirmation link wasn’t clicked.

See: https://www.unisender.com/en/support/api/messages/getcheckedemail/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetCheckedEmail("my-login").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetContact 

func (u *UniSender) GetContact(email string) *contacts.GetContactRequest

GetContact returns request to getting information about a contact (one contact only).

See https://www.unisender.com/en/support/api/contacts/getcontact/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetContact("foo@bar.example").
		IncludeLists().
		IncludeFields().
		IncludeDetails().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetContactCount 

func (u *UniSender) GetContactCount(listID int64) *contacts.GetContactCountRequest

GetContactCount returns request for count contacts by specified conditions.

See https://www.unisender.com/en/support/api/contacts/getcontactcount/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetContactCount(1).
		ParamsTypeAddress().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetContactFieldValues 

func (u *UniSender) GetContactFieldValues(email string, fieldIDs ...int64) *contacts.GetContactFieldValuesRequest

GetContactFieldValues returns request to obtain the values of the specified additional contact fields.

See: https://www.unisender.com/en/support/api/partners/getcontactfieldvalues/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetContactFieldValues("foo@bar.example", 1, 2, 3).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetCurrencyRates 

func (u *UniSender) GetCurrencyRates() *common.GetCurrencyRatesRequest

GetCurrencyRates allows you to get a list of all currencies in the UniSender system.

See: https://www.unisender.com/en/support/api/common/getcurrencyrates/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	currencyRates, err := usndr.GetCurrencyRates().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(currencyRates)
}

Output:

func (*UniSender) GetFields 

func (u *UniSender) GetFields() *contacts.GetFieldsRequest

GetFields returns request to get the list of user fields.

See: https://www.unisender.com/en/support/api/partners/getfields/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetFields().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetLists 

func (u *UniSender) GetLists() *lists.GetListsRequest

GetLists returns request to get the list of all available campaign lists.

See https://www.unisender.com/en/support/api/partners/getlists/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetLists().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetMessage 

func (u *UniSender) GetMessage(messageID int64) *messages.GetMessageRequest

GetMessage returns request to get information about SMS or email message.

See: https://www.unisender.com/en/support/api/partners/getmessage-method/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetMessage(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetMessages 

func (u *UniSender) GetMessages() *messages.GetMessagesRequest

GetMessages returns request to get the list of letters.

See: https://www.unisender.com/en/support/api/partners/getmessages/

Example 
package main

import (
	"log"
	"time"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetMessages().
		From(time.Now().Add(-24 * time.Hour)).
		To(time.Now()).
		Limit(30).
		Offset(0).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetSenderDomainList 

func (u *UniSender) GetSenderDomainList(login string) *partners.GetSenderDomainListRequest

GetSenderDomainList returns information about domains.

See: https://www.unisender.com/en/support/api/messages/getsenderdomainlist/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetSenderDomainList("my-login").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetTags 

func (u *UniSender) GetTags() *contacts.GetTagsRequest

GetFields returns request to get the list of user tags.

See: https://www.unisender.com/en/support/api/partners/gettags/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetTags().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetTemplate 

func (u *UniSender) GetTemplate(templateID int64) *messages.GetTemplateRequest

GetTemplate returns request to get information about the specified template.

See: https://www.unisender.com/en/support/api/partners/gettemplate/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetTemplate(123).
		SystemTemplateID(456).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetTemplates 

func (u *UniSender) GetTemplates() *messages.GetTemplatesRequest

GetTemplates returns request to get the list of templates.

See: https://www.unisender.com/en/support/api/partners/gettemplates/

Example 
package main

import (
	"log"
	"time"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetTemplates().
		TypeSystem().
		From(time.Now().Add(-24 * time.Hour)).
		To(time.Now()).
		Limit(30).
		Offset(0).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) GetTotalContactsCount 

func (u *UniSender) GetTotalContactsCount(login string) *contacts.GetTotalContactsCountRequest

GetTotalContactsCount returns request that counts contacts database size by the user login.

See: https://www.unisender.com/en/support/api/partners/gettotalcontactscount/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetTotalContactsCount("my-login").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:


func (u *UniSender) GetVisitedLinks(campaignID int64) *campaigns.GetVisitedLinksRequest

GetVisitedLinks returns request to report on the links visited by users in the specified email campaign.

See: https://www.unisender.com/en/support/api/partners/getvisitedlinks/

func (*UniSender) GetWebVersion 

func (u *UniSender) GetWebVersion(campaignID int64) *campaigns.GetWebVersionRequest

GetWebVersion returns request to get the link to the web version of the letter.

Sometimes it is useful to get a link to the web version of the letter. For example, you made a campaign and want to show how this email looks in a browser, or share it in social media.

See: https://www.unisender.com/en/support/api/partners/getwebversion/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.GetWebVersion(123).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) ImportContacts 

func (u *UniSender) ImportContacts(collection *contacts.ImportContactsCollection) *contacts.ImportContactsRequest

ImportContacts returns request to bulk import of contacts. It can also be used for periodic synchronization with the contact database stored on your own server (see also the description of the exportContacts method). You can import data of no more than 500 contacts per call. Larger lists must be imported in a few calls.

If there are new addresses among the signed e-mail addresses, then by default they receive the status "new".

Technical restrictions: the maximum number of user fields is 50. The timeout per call is 30 seconds from the moment the request is completely transmitted to the server. If no response is received after the timeout, then it is recommended to make up to two retries, and if there is no answer again, then contact technical support.

See https://www.unisender.com/en/support/api/contacts/importcontacts/

Example 
package main

import (
	"log"
	"time"

	"github.com/sergeyandreenko/unisender"
	"github.com/sergeyandreenko/unisender/contacts"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	collection := contacts.NewImportContactsCollection()
	collection.Email("foo1@bar.example").
		AddListID(1, time.Now()).
		SetAvailabilityAvailable().
		SetStatusActive()

	collection.Email("foo2@bar.example").
		Delete()

	res, err := usndr.ImportContacts(collection).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) IsContactInList 

func (u *UniSender) IsContactInList(email string, listIDs ...int64) *contacts.IsContactInListRequest

IsContactInList returns request to check whether the contact is in the specified user lists.

See https://www.unisender.com/en/support/api/contacts/iscontactinlist/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.IsContactInList("foo@bar.example", 1, 2, 3).
		ConditionOr().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) ListMessages 

func (u *UniSender) ListMessages() *messages.ListMessagesRequest

ListMessages returns request to get the list of letters, but without body.

See: https://www.unisender.com/en/support/api/partners/listmessages/

Example 
package main

import (
	"log"
	"time"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.ListMessages().
		From(time.Now().Add(-24 * time.Hour)).
		To(time.Now()).
		Limit(30).
		Offset(0).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) ListTemplates 

func (u *UniSender) ListTemplates() *messages.ListTemplatesRequest

ListTemplates returns request to get the list of templates, but without body.

See: https://www.unisender.com/en/support/api/partners/listmessages/

Example 
package main

import (
	"log"
	"time"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.ListTemplates().
		TypeSystem().
		From(time.Now().Add(-24 * time.Hour)).
		To(time.Now()).
		Limit(30).
		Offset(0).
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) SendEmail 

func (u *UniSender) SendEmail(email string) *messages.SendEmailRequest

SendEmail returns request to send a single individual email without personalization and with limited possibilities to obtain statistics.

See: https://www.unisender.com/en/support/api/partners/sendemail/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.SendEmail("foo@bar.example").
		SenderName("John Doe").
		SenderEmail("john@doe.example").
		Subject("Hi there").
		Body("<p>Hi there!</p>").
		LangFR().
		WrapTypeSkip().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) SendSMS 

func (u *UniSender) SendSMS(phone ...string) *messages.SendSMSRequest

SendSMS returns request for sending the one SMS to one or several recipients.

See: https://www.unisender.com/en/support/api/partners/sendsms/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.SendSMS("+1234567890").
		Sender("+987654321").
		Text("Hi there!").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) SendTestEmail 

func (u *UniSender) SendTestEmail(emailID int64) *messages.SendTestEmailRequest

SendTestEmail returns request to send a test email message.

See: https://www.unisender.com/en/support/api/partners/sendtestemail/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.SendTestEmail(123).
		To("foo@bar.example").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) SetClient 

func (u *UniSender) SetClient(client *http.Client) *UniSender

SetClient sets custom http.Request to UniSender client.

func (*UniSender) SetLanguageEnglish 

func (u *UniSender) SetLanguageEnglish() *UniSender

SetLanguageEnglish sets API response language to English.

func (*UniSender) SetLanguageItalian 

func (u *UniSender) SetLanguageItalian() *UniSender

SetLanguageItalian sets API response language to Italian.

func (*UniSender) SetLanguageRussian 

func (u *UniSender) SetLanguageRussian() *UniSender

SetLanguageRussian sets API response language to Russian.

func (*UniSender) SetLogger 

func (u *UniSender) SetLogger(logger api.Logger) *UniSender

SetLogger sets logger to UniSender client.

func (*UniSender) SetSenderDomain 

func (u *UniSender) SetSenderDomain(login, domain string) *partners.SetSenderDomainRequest

SetSenderDomain register the domain in the list for authentication and generate a dkim key for it. Confirm the address on the domain to add the domain to the list.

See: https://www.unisender.com/en/support/api/messages/setsenderdomain/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.SetSenderDomain("my-login", "john-doe.com").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) Subscribe 

func (u *UniSender) Subscribe(listIDs ...int64) *contacts.SubscribeRequest

Subscribe returns request that adds contacts (email address and/or mobile phone) of a contact to one or several lists, and also allows you to add/change the values ​​of additional fields and labels.

See https://www.unisender.com/en/support/api/contacts/subscribe/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.Subscribe().
		Email("foo@bar.example").
		Tags("foo", "bar", "example").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) Unsubscribe 

func (u *UniSender) Unsubscribe(contact string) *contacts.UnsubscribeRequest

Unsubscribe returns request that unsubscribes the contact email or phone number from one or several lists. In contrast to the exclude method, it does not exclude a contact from the lists, but marks the contact as "unsubscribed". It is impossible to restore the «active» status through API – it is only the contact who can do this by clicking on the activation link in the letter.

See https://www.unisender.com/en/support/api/partners/unsubscribe/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.Unsubscribe("foo@bar.example").
		ContactTypeEmail().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) UpdateEmailMessage 

func (u *UniSender) UpdateEmailMessage(messageID int64) *messages.UpdateEmailMessageRequest

UpdateEmailMessage returns request to change existing email message.

See: https://www.unisender.com/en/support/api/partners/updateemailmessage/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.UpdateEmailMessage(123).
		SenderName("John Doe").
		SenderEmail("foo@bar.example").
		Subject("Welcome aboard!").
		Body("<b>Hi!</b>").
		ListID(456).
		LangDE().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) UpdateEmailTemplate 

func (u *UniSender) UpdateEmailTemplate(templateID int64) *messages.UpdateEmailTemplateRequest

UpdateEmailTemplate returns request to change existing email template.

See: https://www.unisender.com/en/support/api/partners/updateemailtemplate/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.UpdateEmailTemplate(123).
		Title("New template title").
		Subject("Welcome aboard!").
		Body("<b>Hi!</b>").
		LangDE().
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) UpdateField 

func (u *UniSender) UpdateField(fieldID int64, name string) *contacts.UpdateFieldRequest

UpdateField returns request to change user field parameters.

See: https://www.unisender.com/en/support/api/partners/updatefield/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.UpdateField(123, "Name").
		PublicName("PublicName").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

func (*UniSender) UpdateList 

func (u *UniSender) UpdateList(listID int64, title string) *lists.UpdateListRequest

UpdateList returns request to change campaign list properties.

See https://www.unisender.com/en/support/api/partners/updatelist/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.UpdateList(123, "Mailing list new name").
		BeforeSubscribeUrl("https://before-subscribe.url").
		AfterSubscribeUrl("https://after-subscribe.url").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) UpdateOptInEmail 

func (u *UniSender) UpdateOptInEmail(listID int64) *lists.UpdateOptInEmailRequest

UpdateOptInEmail updates OptInEmail text. Each campaign list has the attached text of the invitation to subscribe and confirm the email that is sent to the contact to confirm the campaign. If the contact subscribes to several lists at once, a letter with the text of the first list will be sent. The text of the letter can be changed using the updateOptInEmail method. The text must include at least one link with the attribute href=”{{ConfirmUrl}}”.

See https://www.unisender.com/en/support/api/partners/updateoptinemail/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	err := usndr.UpdateOptInEmail(123).
		SenderName("John Doe").
		SenderEmail("foo@bar.example").
		Subject("Welcome aboard!").
		Body("<b>Hi!</b>").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}
}

Output:

func (*UniSender) ValidateSender 

func (u *UniSender) ValidateSender(email string) *partners.ValidateSenderRequest

ValidateSender sends a message to the email address with a link to confirm the address as the return address. After clicking on this link, you can send messages on behalf of this email address.

See: https://www.unisender.com/en/support/api/messages/validatesender/

Example 
package main

import (
	"log"

	"github.com/sergeyandreenko/unisender"
)

func main() {
	usndr := unisender.New("your-api-key").
		SetLanguageEnglish()

	res, err := usndr.ValidateSender("foo@bar.example").
		Execute()

	if err != nil {
		log.Fatalln(err)
	}

	log.Println(res)
}

Output:

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.