# Golang 


1 - Install go SDK 

To install the SDK and its dependencies, run the following Go command.

```go
	
	go get -u github.com/aws/aws-sdk-go/…

```
If you set the environment variable to 1, you can use the following command to get the SDK. The SDK's runtime dependencies are vendored in the vendor/ folder.

```go
	
	go get -u github.com/aws/aws-sdk-go
```

2 - initialize your folder using (if not already initialized)

```go
	
	go mod init  
```
3 - make connection with the EQS client

To make the connection with the EQS client , you need to pass configurations and credentials.

	
**Configurations-**

```go

    region_name- your_region               
    endpoint_url - eqs_endpoint_url (provided by e2e networks eqs service)	

```
**Credentials-**

```go

	aws_access_key_id - your_access_key_id
	aws_secret_key_id - your_secret_key_id

```

## Make connection with EQS

There are many ways to provide credentials and configuration to connect with EQS service -

**a)** providing credentials directly to client object -

**warning -** *Hardcoded credentials in application is not recommended*

*create a new file named* **credentials.go** *.*

```go

	import (
		"fmt"
		"github.com/aws/aws-sdk-go/aws"
		"github.com/aws/aws-sdk-go/aws/session"
		"github.com/aws/aws-sdk-go/service/sqs"
	)

	//..

	accessKey := "your-access-key"
	secretKey := "your-secret-key"
	creds := credentials.NewStaticCredentials(accessKey, secretKey, "")
	sess , err := session.NewSession(&aws.Config{
				Region: aws.String("region_name"),
				Endpoint: aws.String("endpoint_url"),
				Credentials: creds,
			});

	if err != nil {
		fmt.println(“Failed to create session”,err)
		os.Exit(1)
	}
	eqs_client := sqs.New(sess)	
```

**b)** you can put credentials and configurations in  the **config** and **credentials** file , and these files should be located at   **~/.aws/config**,  **~/.aws/credentials** location, client will automatically access these credentials and configurations.

*put in* **~/.aws/credentials** *file*

```go
	
	[default]
	region = “your_region”

	```

*put in* **~/.aws/configuration** *file*

```go

	[default]
	aws_access_key_id = “your access key id”
	aws_secret_access_key = “your secret key”
```
*create a new file named* **credentials.go** *.*

```go

	import (
		"fmt"
		"github.com/aws/aws-sdk-go/aws"
		"github.com/aws/aws-sdk-go/aws/session"
		"github.com/aws/aws-sdk-go/service/sqs"
	)

	//..

	sess , err := session.NewSession(&aws.Config{
		Endpoint: aws.String(ENDPOINT),
	});

	if err != nil {
		fmt.println(“Failed to create session”,err)
		os.Exit(1)
	}
	eqs_client := sqs.New(sess)
```	

**c)** you can make the connection with the EQS client by passing the credentials and configuration into the **environment variables** file.

*using terminal* **(Linux, OS X or Unix)**
```go

	$ export AWS_ACCESS_KEY_ID = your_access_key_id
	$ export AWS_SECRET_ACCESS_KEY = your_secret_key
	$ export AWS_DEFAULT_REGION = your_eqs_region
```
*using terminal* **(Windows)**

```go

	> set AWS_ACCESS_KEY_ID = your_access_key_id
	> set AWS_SECRET_ACCESS_KEY = your_secret_key
	> set AWS_DEFAULT_REGION = your_eqs_region

```

**or,** *edit your environment variable file*

```go

	AWS_ACCESS_KEY_ID = your_access_key_id
	AWS_SECRET_ACCESS_KEY = your_secret_access_key
	AWS_DEFAULT_REGION = your_eqs_region
```
*create a new file named* **credentials.go** *.*
```go 

	import (
		"fmt"
		"os"
		"github.com/aws/aws-sdk-go/aws"
		"github.com/aws/aws-sdk-go/aws/session"
		"github.com/aws/aws-sdk-go/service/sqs"
		"github.com/joho/godotenv"
	)

	//..

	err := godotenv.Load(".env")
	if err != nil {
		fmt.Println("Error loading .env file")
		return 
	}

	accessKey := os.Getenv("AWS_ACCESS_KEY_ID")
	secretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
	region := os.Getenv("AWS_REGION")
	
	creds := credentials.NewStaticCredentials(accessKey, secretKey, "")
	config := &aws.Config{
		Region:      aws.String(region),
		Endpoint:    aws.String("endpoint_url"),
		Credentials: creds,
	}
	sess := session.Must(session.NewSession(config))

	eqs_client := sqs.New(sess)
```

**Methods available for eqs_client**

## Change Visibility Timeout

Visibility Timeout refers to the amount of time that a message remains invisible to other consumers after it has been retrieved by a consumer.


**Request Syntax**

*get queue name, receipt handle, visibility timeout*
```go

	queue := flag.String("q", "your_queue_name", "The name of the queue")
	handle := flag.String("h", "message_receipt_handle", "The receipt handle of the message")
	visibility := flag.Int64("v", 50, "The duration, in seconds, that the message is not visible to other consumers")
	flag.Parse()

	if *queue == "" || *handle == "" {
		fmt.Println("You must supply a queue name (-q QUEUE) and message receipt handle (-h
		HANDLE)")
		return
	}
	if *visibility < 0 {
		*visibility = 0
	}
	if *visibility > 12*60*60 {
		*visibility = 12 * 60 * 60
	}
```

*get queue url using eqs_client*
```go

	result, err := eqs_client.GetQueueUrl(&sqs.GetQueueUrlInput{
 			QueueName: queue,
	})
	queueURL := urlResult.QueueUrl
```

*calling ChangeMessageVisibility method using eqs_client*
```go

	_, err := eqs_client.ChangeMessageVisibility(&sqs.ChangeMessageVisibilityInput{
		ReceiptHandle: handle,
		QueueUrl: queueURL,
		VisibilityTimeout: visibility,
	})

```

**Parameters**

	**QueueUrl** (string)- [Required]  
			The URL of the E2E EQS queue whose message's visibility is changed.

	**ReceiptHandle** (string) - [Required]  
			The receipt handle is associated with the message whose visibility timeout is changed. This parameter is returned by the *ReceiveMessage* action
	
	**VisibilityTimeout** (integer) - [Required] 
			The new value for the message's visibility timeout (in seconds)

			Valid values -  0 to 43,200 seconds (12 hours)

			default - 30 second


**Response Syntax**

```go

	nil
```

## Create Queue

**Request Syntax**

*get queue name*
```go

	queue := flag.String("q", "your_queue_name", "The name of the queue")
	flag.Parse()

	if *queue == "" {
		fmt.Println("You must supply a queue name (-q QUEUE")
		return
	}
```

*Use CreateQueue method using eqs_client to create a queue using queue name, You can also define attributes and tags for the queue*
```go

	result, err := eqs_client.CreateQueue(&sqs.CreateQueueInput{
	QueueName: queue,
	Attributes: map[string]*string{
		"DelaySeconds": aws.String("60"),
		"MessageRetentionPeriod": aws.String("86400"),
	},
	Tags: map[string]*string{
		"Environment": aws.String("Production"),
		"Application": aws.String("MyApp"),
	},
	})
```

*take queue url from* **result**

```go

	fmt.Println("URL: " + *result.QueueUrl)

```

**Parameters**

	**QueueName** (string)- [Required]
			1 - A queue name can have up to 80 characters

			2 - Valid values: alphanumeric characters, hyphens ( -), and underscores ( _).

	**Attributes**  (map)- Attributes could be 

			1 - DelaySeconds - Time(second), to which extent delivery of messages is delayed in the queue 

				Valid values - 0 to 900 (second)

				default - 0 (second)

			2 - MaximumMessageSize - The size of the message after which the queue will reject the message 

				Valid values - 1,024 bytes (1 KiB) to 262,144 bytes (256 KiB)

				default - 262,144 bytes(256 KiB) 

			3 - MessageRetentionPeriod - Time to which extent a queue will retain a message 

				Valid values -  60 seconds (1 minute) to 1,209,600 seconds (14 days)

				default -  345,600 (4 days)

			4 - ReceiveMessageWaitTimeSeconds - Time to which extent *ReceiveMessage* action waits before receiving a message

				Valid values - 0 to 20 (seconds)

				default -  0 (second)

			5 - VisibilityTimeout - The amount of time that a message in a queue is invisible to other consumers after a consumer retrieves it.

				Valid values -  0 to 43,200 seconds (12 hours)

				default - 30 second

	**tags** (map) - 

			1 - Adding more than 50 tags to a queue isn't recommended.

			2 - A new tag with a key identical to that of an existing tag overwrites the existing tag.
			

**Response Syntax** *(result)*
```go

	{ QueueUrl: "queue_url"}

```

## Delete message


**Request Syntax**

*get the queue name and message handle*

```go

	queue := flag.String("q", "", "The name of the queue")
	messageHandle := flag.String("m", "", "The receipt handle of the message")
	flag.Parse()
	
	if *queue == "" || *messageHandle == "" {
		fmt.Println("You must supply a queue name (-q QUEUE) and message receipt handle (-m
		MESSAGE-HANDLE)")
		return
	}	
```

*pass queue url and message handle and call DeleteMessage method using client*

```go

	_, err := eqs_client.DeleteMessage(&sqs.DeleteMessageInput{
		QueueUrl: queueURL,
		ReceiptHandle: messageHandle,
	})

```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue from which messages are deleted.

	**ReceiptHandle** (string) - [Required]
		The receipt handle is associated with the message to delete.

**Response Syntax**
```go

	nil

```

## Delete message in batch


**Request Syntax**

*prepare the input for DeleteMessageBatch API call*
```go

	input = &sqs.DeleteMessageBatchInput{QueueUrl: aws.String(queueURL), }

	for i, receiptHandle := range messageReceiptHandles {
		input.Entries = append(input.Entries, &sqs.DeleteMessageBatchRequestEntry{
			Id:            aws.String(strconv.Itoa(i)),
			ReceiptHandle: receiptHandle,
		})
	}
```

*call the DeleteMessageBatch method using eqs_client*

```go

	_, err = eqs_client.DeleteMessageBatch(input)

	if err!= nil {
		return err
	}
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue from which messages are deleted.

	**Entries**  (slice) - [Required]
		(map)
		*id [Required]-(string) An identifier for this particular receipt handle used to communicate the result*
		*ReceiptHandle [Required] -(string) A receipt handle*

**Response Syntax**
```go

	{
	  "Successful": [{"Id": "string"}, ],
	  "Failed": [
	  {
		  "Id": "string", 
		  "SenderFault": True | False, 
		  "Code": "string", 
		  "Message": "string",
	  },
	  ],
	}
```

## Delete queue


**Request Syntax**

*getting the queue url**

```go

	queueURL := "your-queue-url"
```

*calling the DeleteQueue method using eqs_client*

```go

	_, err := eqs_client.DeleteQueue(&sqs.DeleteQueueInput{
		QueueUrl: aws.String(queueURL),
	})
	if err != nil {
		// handle error
	}
```

**Parameters**

	**QueueUrl** (string) - [Required]
	 
		The URL of the E2E EQS queue to delete.

**Response Syntax**

```go

	nil


```

## Get queue attributes

**Request Syntax**

*calling GetQueueAttributes method using eqs_client*
```go

	result, err := eqs_client.GetQueueAttributes(&sqs.GetQueueAttributesInput{
		QueueUrl: aws.String("queue-url"),
		AttributeNames: []*string{
			aws.String(sqs.QueueAttributeNameAll),
		},
	})
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue from which attributes are get.

	**AttributeNames** (slice) - [Optional]
		A list of attributes for which to retrieve information

		*All - it specifies, returns all values*

		you can also specify specific attributes in the list 

		*As - ['VisibilityTimeout' , 'MaximumMessageSize' , 'MessageRetentionPeriod' , 'ApproximateNumberOfMessages' ,'ApproximateNumberOfMessagesNotVisible' , 'CreatedTimestamp' , 'LastModifiedTimestamp' , 'QueueArn' , 'ApproximateNumberOfMessagesDelayed' , 'DelaySeconds' , 'ReceiveMessageWaitTimeSeconds']*


**Response Syntax**
```go

	{
	   Attributes: map[string]*string{
	       "VisibilityTimeout": aws.String("60"),
	   },
	}

```

## Get queue url

**Request Syntax**

*getting input using queue name*
```go

	input := &sqs.GetQueueUrlInput{
		QueueName: aws.String("my_queue_name"),
	}

*calling GetQueueUrl method using eqs_client passing input as params*
```go

	result, err := eqs_client.GetQueueUrl(input)

	if err != nil {
		fmt.println("Error in getting queue", err)
		return
	}

	fmt.Println("Queue URL:", *result.QueueUrl)
```

**Parameters**

	**QueueName** (string) -[Required]
		The name of the queue whose URL must be fetched.

**Response Syntax**
```go

	{ QueueUrl: string, }
```
## List queue tags

**Request Syntax**

*defining input using queue url*
```go

    input := &sqs.ListQueueTagsInput{
        QueueUrl: aws.String(queueUrl),
    }
```

*calling ListQueueTags method using eqs_client*
```go
	
    resp, err := eqs_client.ListQueueTags(input)
    if err != nil {
        fmt.Println("Error listing queue tags:", err)
        return
    }
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue of which all the tags must be listed.

**Response Syntax**

```go

	type ListQueueTagsOutput struct {
		Tags map[string]*string `type:"map" required:"true"`
	}
```

## List queues


**Request Syntax**

*Set the queue name prefix and max results to retrieve*
```go
	
    queueNamePrefix := "my-queue"
    maxResults := int64(10)
```
*Call the ListQueues API with the specified parameters*
```go

    resp, err := svc.ListQueues(&sqs.ListQueuesInput{
        QueueNamePrefix: &queueNamePrefix,
        MaxResults: &maxResults,
    })

    if err != nil {
        fmt.Println("Error listing queues:", err)
        return
    }
```
*Print out the URLs of the returned queues*
```go
	
    for _, url := range resp.QueueUrls {
        fmt.Println(*url)
    }
```
**Parameters**
	**QueueNamePrefix** (string) -  [Optional]
		A string to use for filtering the list results. Only those queues whose name begins with the specified string are returned.

	**MaxResults** (integer) - [Optional]
		The maximum number of results to include in the response.
		Valid values - 1 to 1000


**Response Syntax** *(resp)*
```go

	type ListQueuesOutput struct {
		QueueUrls []*string `type:"list" required:"true"`
	}
```

## Purge queue


delete all the messages from queue.

**Request Syntax**

*calling PurgeQueue method using eqs_client*
```go

	_, err := eqs_client.PurgeQueue(&sqs.PurgeQueueInput{
		QueueUrl: queueURL,
	})

	if err != nil {
		fmt.Println("Error purging queue:", err)
		return
	}
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue of which all the messages must be deleted.


**Response Syntax**
```go

	nil
```

## Receive Message

**Request Syntax**
*getting queue url, visibility timeout, AttributeNames, MessageAttributeNames, maxNumberOfMessages and waitTimeSeconds*
```go

	queueURL := "YOUR_QUEUE_URL"
	attributeNames := []*string{
		aws.String("All"), // returns all attributes
	}
	messageAttributeNames := []*string{
		aws.String("ATTRIBUTE_NAME"),
	}
	maxNumberOfMessages := aws.Int64(2)
	visibilityTimeout := aws.Int64(25)
	waitTimeSeconds := aws.Int64(10)
```

*calling ReceiveMessage method using eqs_client*

```go

	result, err := eqs_client.ReceiveMessage(&sqs.ReceiveMessageInput{
		AttributeNames:        attributeNames,
		MessageAttributeNames: messageAttributeNames,
		MaxNumberOfMessages:   maxNumberOfMessages,
		QueueUrl:              &queueURL,
		VisibilityTimeout:     visibilityTimeout,
		WaitTimeSeconds:       waitTimeSeconds,
	})

	if err != nil {
		fmt.Println("Error receiving messages:", err)
		return
	}
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue from which messages are received.

	**AttributeNames** (slice) - 
		A list of attributes that need to be returned along with each message.

		*All - it specifies, returns all values*

		you can also specify specific attributes in the list 

		*As - ['VisibilityTimeout' , 'MaximumMessageSize' , 'MessageRetentionPeriod' , 'ApproximateNumberOfMessages' ,'ApproximateNumberOfMessagesNotVisible' , 'CreatedTimestamp' , 'LastModifiedTimestamp' , 'QueueArn' , 'ApproximateNumberOfMessagesDelayed' , 'DelaySeconds' , 'ReceiveMessageWaitTimeSeconds']*

	**MessageAttributeNames** (slice) - 
		The name of the message attribute.
	
	**MaxNumberOfMessages** (integer) -
		The maximum number of messages to return.

		Valid range - 1 to 10

		default - 1
	
	**VisibilityTimeout** (integer) -
		The duration (in seconds) that the received messages are hidden from subsequent retrieve requests after being retrieved by a ReceiveMessage request.

	**WaitTimeSeconds** (integer) - 
		The duration (in seconds) for which the call waits for a message to arrive in the queue before returning.


**Response Syntax**

```go

	type ReceiveMessageOutput struct {
    	Messages []*Message // a list of received messages
	}

	type Message struct {
		MessageId            *string
		ReceiptHandle        *string
		MD5OfBody            *string
		Body                 *string
		MD5OfMessageAttributes *string
		Attributes           map[string]*string // message system attributes
		MessageAttributes    map[string]*MessageAttributeValue // message user-defined attributes
	}

	type MessageAttributeValue struct {
		StringValue *string // string value of the message attribute
		BinaryValue []byte // binary value of the message attribute
		DataType    *string // data type of the message attribute
	}
```

## Send message

**Request Syntax**
*setting up params*
```go

    params := &sqs.SendMessageInput{
    QueueUrl: aws.String("QUEUE_URL_HERE"),
    MessageBody: aws.String("MESSAGE_BODY_HERE"),
    DelaySeconds: aws.Int64(123),
    MessageAttributes: map[string]*sqs.MessageAttributeValue{
        "ATTRIBUTE_NAME_HERE": {
            DataType: aws.String("STRING"),
            StringValue: aws.String("ATTRIBUTE_VALUE_HERE"),
        },
    },
    MessageSystemAttributes: map[string]*sqs.MessageSystemAttributeValue{
        "SYSTEM_ATTRIBUTE_NAME_HERE": {
            DataType: aws.String("STRING"),
            StringValue: aws.String("SYSTEM_ATTRIBUTE_VALUE_HERE"),
        },
    },
	}
```
*calling Send message method using eqs_client*

```go

	resp, err := eqs_client.SendMessage(params)
	if err != nil {
		// handle error
		return
	}
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue to which messages are send.
	
	**MessageBody** (string) - [Required]
		The message to send. The minimum size is one character. The maximum size is 256 KB.

	**DelaySeconds** (integer) -
		The length of time, in seconds, for which to delay a specific message.

	**MessageAttributes** (map) - 

			Each message attribute consists of a Name, Type, and Value .

			Name, type, value and the message body must not be empty or null .

			(string) - name of the message attributes

			(map)  - Value of message attributes

				1 - StringValue (string) - Strings are Unicode with UTF-8 binary encoding.

				2 - BinaryValue (bytes) - Binary type attributes can store any binary data, such as compressed data, encrypted data, or images.

			(string) - [Required] Type of message attributes

				EQS support the following data type 

				Binary, Number, String

	**MessageSystemAttributes** (map) - 
			Each message system attribute consists of a Name, Type, and Value.

			The name, type, value and message body must not be empty or null.

			(string) - the name of the message attributes

			(map)  - Value of message attributes

				1 - StringValue (string) - Strings are Unicode with UTF-8 binary encoding.

				2 - BinaryValue (bytes) - Binary type attributes can store any binary data, such as compressed data, encrypted data, or images.

			(string) - Type of message attributes

				EQS support the following data type 

				Binary , Number , String
	
**Response Syntax**
```go

	resp := &sqs.SendMessageOutput{
		MD5OfMessageBody:           aws.String("hash_of_message_body"),
		MD5OfMessageAttributes:     aws.String("hash_of_message_attribute"),
		MD5OfMessageSystemAttributes: aws.String("hash_of_message_system_attributes"),
		MessageId:                  aws.String("message_id"),
		SequenceNumber:             aws.String("sequence_number"),
	}

```

## Send message in batch


**Request Syntax**
*calling SendMessageBatch method using eqs_client*
```go
	
    resp, err := eqs_client.SendMessageBatch(&sqs.SendMessageBatchInput{
    QueueUrl: aws.String("QUEUE_URL"),
    Entries: []*sqs.SendMessageBatchRequestEntry{
        {
            Id:           aws.String("MESSAGE_ID_1"),
            MessageBody:  aws.String("MESSAGE_BODY_1"),
            DelaySeconds: aws.Int64(0),
            MessageAttributes: map[string]*sqs.MessageAttributeValue{
                "ATTRIBUTE_NAME_1": &sqs.MessageAttributeValue{
                    DataType:    aws.String("STRING"),
                    StringValue: aws.String("ATTRIBUTE_VALUE_1"),
                },
                "ATTRIBUTE_NAME_2": &sqs.MessageAttributeValue{
                    DataType:    aws.String("NUMBER"),
                    StringValue: aws.String("ATTRIBUTE_VALUE_2"),
                },
            },
            MessageSystemAttributes: map[string]*sqs.MessageSystemAttributeValue{
                "SYSTEM_ATTRIBUTE_NAME_1": &sqs.MessageSystemAttributeValue{
                    DataType:    aws.String("STRING"),
                    StringValue: aws.String("SYSTEM_ATTRIBUTE_VALUE_1"),
                },
                "SYSTEM_ATTRIBUTE_NAME_2": &sqs.MessageSystemAttributeValue{
                    DataType:    aws.String("BINARY"),
                    BinaryValue: []byte("SYSTEM_ATTRIBUTE_VALUE_2"),
                },
            },
        },
        {
            Id:           aws.String("MESSAGE_ID_2"),
            MessageBody:  aws.String("MESSAGE_BODY_2"),
            DelaySeconds: aws.Int64(0),
            MessageAttributes: map[string]*sqs.MessageAttributeValue{
                "ATTRIBUTE_NAME_3": &sqs.MessageAttributeValue{
                    DataType:    aws.String("STRING"),
                    StringValue: aws.String("ATTRIBUTE_VALUE_3"),
                },
                "ATTRIBUTE_NAME_4": &sqs.MessageAttributeValue{
                    DataType:    aws.String("NUMBER"),
                    StringValue: aws.String("ATTRIBUTE_VALUE_4"),
                },
            },
            MessageSystemAttributes: map[string]*sqs.MessageSystemAttributeValue{
                "SYSTEM_ATTRIBUTE_NAME_3": &sqs.MessageSystemAttributeValue{
                    DataType:    aws.String("STRING"),
                    StringValue: aws.String("SYSTEM_ATTRIBUTE_VALUE_3"),
                },
                "SYSTEM_ATTRIBUTE_NAME_4": &sqs.MessageSystemAttributeValue{
                    DataType:    aws.String("BINARY"),
                    BinaryValue: []byte("SYSTEM_ATTRIBUTE_VALUE_4"),
                },
            },
        },
    },
	})
	
	if err != nil {
		fmt.Println("Error", err)
		return
	}
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue to which messages are sent.
	
	**Entries** (slice) - [Required]
		A list of SendMessageBatchRequestEntry items.

		(Dict) -

		Contains the details of a single E2E EQS message along with an Id.
		
		**Id** (string) - [REQUIRED]
			An identifier for a message in this batch is used to communicate the result.

		**MessageBody** (string) - [Required]
			The message to send. The minimum size is one character. The maximum size is 256 KB.

		**DelaySeconds** (integer) -
			The length of time, in seconds, for which to delay a specific message.

		**MessageAttributes** (map) - 
				Each message attribute consists of a Name, Type, and Value.

				The Name, type, value and  message body must not be empty or null.

				(string) - The name of the message attributes

				(map)  - Value of message attributes

					1 - StringValue (string) - Strings are Unicode with UTF-8 binary encoding.

					2 - BinaryValue (bytes) - Binary type attributes can store any binary data, such as compressed data, 
					encrypted data, or images.

				(string) -[Required] Type of message attributes

					EQS support the following data type 

					Binary, Number, String

		**MessageSystemAttributes** (map) - 
				Each message system attribute consists of a Name, Type, and Value.

				Name, type, value and the message body must not be empty or null.

				(string) - The name of the message attributes

				(map)  - Value of message attributes

					1 - StringValue (string) - Strings are Unicode with UTF-8 binary encoding.

					2 - BinaryValue (bytes) - Binary type attributes can store any binary data, such as compressed data,
					 encrypted data, or images.

				(string) - Type of message attributes

					EQS support following data type 

					Binary , Number , String

**Response Syntax**

```go

	type SendMessageBatchOutput struct {
		Successful []SendMessageBatchResultEntry   `locationNameList:"SendMessageBatchResultEntry"  type:"list"`
		Failed     []BatchResultErrorEntry         `locationNameList:"BatchResultErrorEntry"        type:"list"`
	}

	type SendMessageBatchResultEntry struct {
		Id                         *string                           	`type:"string"`
		MessageId                  *string                           	`type:"string"`
		MD5OfMessageAttributes     *string                           	`type:"string"`
		MD5OfMessageBody           *string                           	`type:"string"`
		MD5OfMessageSystemAttributes *string                         	`type:"string"`
		SequenceNumber             *string                          	 `type:"string"`
	}

	type BatchResultErrorEntry struct {
		Id             *string           	`type:"string"`
		SenderFault    *bool    			`type:"boolean"`
		Code           *string   			`type:"string"`
		Message        *string   			`type:"string"`
	}
```

## Set queue Attributes


**Request Syntax**

*calling SetQueueAttributes method using eqs_client*
```go

	_, err := eqs_client.SetQueueAttributes(&sqs.SetQueueAttributesInput{
		QueueUrl: aws.String("YOUR_QUEUE_URL_HERE"),
		Attributes: map[string]*string{
			"Attribute1": aws.String("Value1"),
			"Attribute2": aws.String("Value2"),
			// Add more attributes here as needed.
		},
	})

	if err != nil {
		// Handle error.
		panic(err)
	}
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue of which attributes should be set.
	
	**Attributes** (map) : [Required]
		A map of attributes to set.

**Response Syntax**

```go

	nil
```

## Tag queue


**Request Syntax**

*calling TagQueue method using eqs_client*

```go
	
    resp, err := svc.TagQueue(&sqs.TagQueueInput{
    QueueUrl: aws.String("YOUR_QUEUE_URL_HERE"),
    Tags: map[string]*string{
        "Tag1": aws.String("Value1"),
        "Tag2": aws.String("Value2"),
        // Add more tags here as needed.
    },
	})

	if err != nil {
		// Handle error.
		panic(err)
	}
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue.
	
	**Tags** (map) - [Required]
		The list of tags to be added to the specified queue.

**Response Syntax**
```go

	nil
```

## Untag Queue


**Request Syntax**

*set queue url and tags*
```go
	
    queueURL := "your_queue_url"
    tags := map[string]*string{
        "Environment": aws.String("production"),
        "Owner":       aws.String("example@example.com"),
    }
```

*set input params*

```go
	
    params := &sqs.TagQueueInput{
		QueueUrl: &queueURL,
		Tags:     tags,
    }
```

*calling UntagQueue method using eqs_client*

```go

    _, err := svc.TagQueue(params)
    if err != nil {
        fmt.Println("Error setting tags:", err)
        return
    }

    fmt.Println("Tags successfully set!")
```

**Parameters**

	**QueueUrl** (string) - [Required]
		The URL of the E2E EQS queue.
	
	**TagKeys** (slice) - [Required]
		The list of tags to be removed from the specified queue.
	

**Response Syntax**

```go

	nil
```


---