protected override void ProcessRecord()
 {
     AmazonSimpleDB client = base.GetClient();
     Amazon.SimpleDB.Model.BatchPutAttributesRequest request = new Amazon.SimpleDB.Model.BatchPutAttributesRequest();
     request.DomainName = this._DomainName;
     Amazon.SimpleDB.Model.BatchPutAttributesResponse response = client.BatchPutAttributes(request);
 }
        private int maxItemsPerRequest = 25; // simpledb has max 25 items per batch put request

        #endregion Fields

        #region Methods

        protected override void SendBuffer(log4net.Core.LoggingEvent[] events)
        {
            var client = new AmazonSimpleDBClient(); // access and secret keys in web.config

            for (var i = 0; i < (events.Count() / maxItemsPerRequest) + 1; i++)
            {
                try
                {
                    var request = new BatchPutAttributesRequest();

                    foreach (var e in events.Skip(i * maxItemsPerRequest).Take(maxItemsPerRequest))
                    {
                        var batchItem = new ReplaceableItem()
                                            {
                                                ItemName = Guid.NewGuid().ToString()
                                            };

                        batchItem.Attribute.Add(GetAttribute("Thread", e.ThreadName));
                        batchItem.Attribute.Add(GetAttribute("Level", e.Level.Name));
                        batchItem.Attribute.Add(GetAttribute("CustomLevel", GetCustomProperty(e, "CustomLevel")));
                        batchItem.Attribute.Add(GetAttribute("Url", GetCustomProperty(e, "Url")));
                        batchItem.Attribute.Add(GetAttribute("Machine", GetCustomProperty(e, "Machine")));
                        batchItem.Attribute.Add(GetAttribute("Product", GetCustomProperty(e, "Product")));
                        batchItem.Attribute.Add(GetAttribute("UserId", GetCustomProperty(e, "UserId")));
                        batchItem.Attribute.Add(GetAttribute("UserName", GetCustomProperty(e, "UserName")));
                        batchItem.Attribute.Add(GetAttribute("TimeStamp", e.TimeStamp.ToUniversalTime().ToString("o")));
                        batchItem.Attribute.Add(GetAttribute("Message", e.RenderedMessage));
                        batchItem.Attribute.Add(GetAttribute("FormattedMessage", GetCustomProperty(e, "FormattedMessage")));
                        batchItem.Attribute.Add(GetAttribute("StackTrace", e.GetExceptionString()));

                        request.Item.Add(batchItem);
                    }

                    // Assumes Domain has already been created
                    if(!string.IsNullOrEmpty(ConfigurationManager.AppSettings["SimpleDBLogName"]))
                        request.DomainName = ConfigurationManager.AppSettings["SimpleDBLogName"];
                    else
                        request.DomainName = "Log";

                    client.BatchPutAttributes(request);
                }
                finally
                {

                }
            }
        }
        public void AttributeTestA_BatchPutAttribute()
        {
            bool hasCallbackArrived = false;
            bool actualValue = false;
            bool expectedValue = true;
            SimpleDBResponseEventHandler<object, ResponseEventArgs> handler = null;

            handler = delegate(object sender, ResponseEventArgs args)
            {
                //Unhook from event.
                _client.OnSimpleDBResponse -= handler;
                BatchPutAttributesResponse response = args.Response as BatchPutAttributesResponse;
                if (null != response)
                {
                    actualValue = true;
                }
                hasCallbackArrived = true;
            };

            //Hook to event
            _client.OnSimpleDBResponse += handler;
            BatchPutAttributesRequest request = new BatchPutAttributesRequest() { DomainName = _domainName_UnitTesting };

            //List<ReplaceableAttribute> itemA = new List<ReplaceableAttribute>();
            ReplaceableItem itemA = new ReplaceableItem { ItemName = "ItemA" };
            itemA.Attribute.Add(new ReplaceableAttribute().WithName("Category").WithValue("Company"));
            itemA.Attribute.Add(new ReplaceableAttribute().WithName("Subcategory").WithValue("Private Limited"));
            itemA.Attribute.Add(new ReplaceableAttribute().WithName("Name").WithValue("Neudesic Technologies"));

            //List<ReplaceableAttribute> itemB = new List<ReplaceableAttribute>();
            ReplaceableItem itemB = new ReplaceableItem { ItemName = "ItemB" };
            itemB.Attribute.Add(new ReplaceableAttribute().WithName("Sector").WithValue("IT"));
            itemB.Attribute.Add(new ReplaceableAttribute().WithName("Location").WithValue("Hydrabad"));
            itemB.Attribute.Add(new ReplaceableAttribute().WithName("Location").WithValue("Bangalore"));
            itemB.Attribute.Add(new ReplaceableAttribute().WithName("Size").WithValue("Large"));

            List<ReplaceableItem> replacableItem = request.Items;

            replacableItem.Add(itemA);
            replacableItem.Add(itemB);
            _client.BatchPutAttributes(request);

            EnqueueConditional(() => hasCallbackArrived);
            EnqueueCallback(() => Assert.IsTrue(expectedValue == actualValue));
            EnqueueTestComplete();
        }
        /// <summary>
        /// Initiates the asynchronous execution of the BatchPutAttributes operation.
        /// <seealso cref="Amazon.SimpleDB.IAmazonSimpleDB"/>
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<BatchPutAttributesResponse> BatchPutAttributesAsync(BatchPutAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new BatchPutAttributesRequestMarshaller();
            var unmarshaller = BatchPutAttributesResponseUnmarshaller.Instance;

            return InvokeAsync<BatchPutAttributesRequest,BatchPutAttributesResponse>(request, marshaller, 
                unmarshaller, cancellationToken);
        }
        /// <summary>
        /// The <code>BatchPutAttributes</code> operation creates or replaces attributes within
        /// one or more items. By using this operation, the client can perform multiple <a>PutAttribute</a>
        /// operation with a single call. This helps yield savings in round trips and latencies,
        /// enabling Amazon SimpleDB to optimize requests and generally produce better throughput.
        /// 
        /// 
        ///  
        /// <para>
        ///  The client may specify the item name with the <code>Item.X.ItemName</code> parameter.
        /// The client may specify new attributes using a combination of the <code>Item.X.Attribute.Y.Name</code>
        /// and <code>Item.X.Attribute.Y.Value</code> parameters. The client may specify the first
        /// attribute for the first item using the parameters <code>Item.0.Attribute.0.Name</code>
        /// and <code>Item.0.Attribute.0.Value</code>, and for the second attribute for the first
        /// item by the parameters <code>Item.0.Attribute.1.Name</code> and <code>Item.0.Attribute.1.Value</code>,
        /// and so on. 
        /// </para>
        ///  
        /// <para>
        ///  Attributes are uniquely identified within an item by their name/value combination.
        /// For example, a single item can have the attributes <code>{ "first_name", "first_value"
        /// }</code> and <code>{ "first_name", "second_value" }</code>. However, it cannot have
        /// two attribute instances where both the <code>Item.X.Attribute.Y.Name</code> and <code>Item.X.Attribute.Y.Value</code>
        /// are the same. 
        /// </para>
        ///  
        /// <para>
        ///  Optionally, the requester can supply the <code>Replace</code> parameter for each
        /// individual value. Setting this value to <code>true</code> will cause the new attribute
        /// values to replace the existing attribute values. For example, if an item <code>I</code>
        /// has the attributes <code>{ 'a', '1' }, { 'b', '2'}</code> and <code>{ 'b', '3' }</code>
        /// and the requester does a BatchPutAttributes of <code>{'I', 'b', '4' }</code> with
        /// the Replace parameter set to true, the final attributes of the item will be <code>{
        /// 'a', '1' }</code> and <code>{ 'b', '4' }</code>, replacing the previous values of
        /// the 'b' attribute with the new value. 
        /// </para>
        ///  <important> This operation is vulnerable to exceeding the maximum URL size when making
        /// a REST request using the HTTP GET method. This operation does not support conditions
        /// using <code>Expected.X.Name</code>, <code>Expected.X.Value</code>, or <code>Expected.X.Exists</code>.
        /// </important> 
        /// <para>
        ///  You can execute multiple <code>BatchPutAttributes</code> operations and other operations
        /// in parallel. However, large numbers of concurrent <code>BatchPutAttributes</code>
        /// calls can result in Service Unavailable (503) responses. 
        /// </para>
        ///  
        /// <para>
        ///  The following limitations are enforced for this operation: <ul> <li>256 attribute
        /// name-value pairs per item</li> <li>1 MB request size</li> <li>1 billion attributes
        /// per domain</li> <li>10 GB of total user data storage per domain</li> <li>25 item limit
        /// per <code>BatchPutAttributes</code> operation</li> </ul> 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes service method.</param>
        /// 
        /// <returns>The response from the BatchPutAttributes service method, as returned by SimpleDB.</returns>
        /// <exception cref="DuplicateItemNameException">
        /// The item name was specified more than once.
        /// </exception>
        /// <exception cref="InvalidParameterValueException">
        /// The value for a parameter is invalid.
        /// </exception>
        /// <exception cref="MissingParameterException">
        /// The request must contain the specified missing parameter.
        /// </exception>
        /// <exception cref="NoSuchDomainException">
        /// The specified domain does not exist.
        /// </exception>
        /// <exception cref="NumberDomainAttributesExceededException">
        /// Too many attributes in this domain.
        /// </exception>
        /// <exception cref="NumberDomainBytesExceededException">
        /// Too many bytes in this domain.
        /// </exception>
        /// <exception cref="NumberItemAttributesExceededException">
        /// Too many attributes in this item.
        /// </exception>
        /// <exception cref="NumberSubmittedAttributesExceededException">
        /// Too many attributes exist in a single call.
        /// </exception>
        /// <exception cref="NumberSubmittedItemsExceededException">
        /// Too many items exist in a single call.
        /// </exception>
        public BatchPutAttributesResponse BatchPutAttributes(BatchPutAttributesRequest request)
        {
            var marshaller = new BatchPutAttributesRequestMarshaller();
            var unmarshaller = BatchPutAttributesResponseUnmarshaller.Instance;

            return Invoke<BatchPutAttributesRequest,BatchPutAttributesResponse>(request, marshaller, unmarshaller);
        }
        public void AttributeTestA_BatchPutAttribute_ForException_WithoutItem()
        {
            bool hasCallbackArrived = false;
            string actualValue = string.Empty;
            string expectedValue = "No items specified";
            SimpleDBResponseEventHandler<object, ResponseEventArgs> handler = null;

            handler = delegate(object sender, ResponseEventArgs args)
            {
                //Unhook from event.
                _client.OnSimpleDBResponse -= handler;
                AmazonSimpleDBException response = args.Response as AmazonSimpleDBException;
                if (null != response)
                {
                    actualValue = response.Message.Trim();
                }
                hasCallbackArrived = true;
            };

            //Hook to event
            _client.OnSimpleDBResponse += handler;
            BatchPutAttributesRequest request = new BatchPutAttributesRequest() { DomainName = _domainName_UnitTesting };
            _client.BatchPutAttributes(request);

            EnqueueConditional(() => hasCallbackArrived);
            EnqueueCallback(() => Assert.IsTrue(expectedValue == actualValue));
            EnqueueTestComplete();
        }
 IAsyncResult invokeBatchPutAttributes(BatchPutAttributesRequest batchPutAttributesRequest, AsyncCallback callback, object state, bool synchronized)
 {
     IRequest irequest = new BatchPutAttributesRequestMarshaller().Marshall(batchPutAttributesRequest);
     var unmarshaller = BatchPutAttributesResponseUnmarshaller.GetInstance();
     AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
     Invoke(result);
     return result;
 }
		internal BatchPutAttributesResponse BatchPutAttributes(BatchPutAttributesRequest request)
        {
            var task = BatchPutAttributesAsync(request);
            try
            {
                return task.Result;
            }
            catch(AggregateException e)
            {
                throw e.InnerException;
            }
        }
        public static void SaveNewsStory(string domainName, string bucketName, List<NewsComponents> newsItems, AmazonSimpleDBClient sdbClient, AmazonS3Client s3Client)
        {
            //BucketHelper.CheckForBucket(itemName, s3Client);

            //foreach (var stream in newsItems.Images)
            //{
            //    PutObjectRequest putObjectRequest = new PutObjectRequest();
            //    putObjectRequest.WithBucketName(bucketName);
            //    putObjectRequest.CannedACL = S3CannedACL.PublicRead;
            //    putObjectRequest.Key = stream.fileName;
            //    putObjectRequest.InputStream = stream.photostreams;
            //    S3Response response = s3Client.PutObject(putObjectRequest);
            //    response.Dispose();
            //}
            DomainHelper.CheckForDomain(domainName, sdbClient);
            BatchPutAttributesRequest batchPutAttributesRequest = new BatchPutAttributesRequest();
            batchPutAttributesRequest.WithDomainName(domainName);
            ReplaceableItem replaceableItem;
            foreach (var list in newsItems)
            {
                replaceableItem = new ReplaceableItem();

                replaceableItem.WithItemName(Convert.ToString(list.NewsID));
                var list1 = new List<ReplaceableAttribute>{
                    new ReplaceableAttribute
                    {
                        Name = "NewsID",
                        Value = Convert.ToString(list.NewsID),
                        Replace = false
                    },
                    new ReplaceableAttribute
                    {
                        Name = "Source",
                        Value = list.Source,
                        Replace = false
                    },
                    new ReplaceableAttribute
                    {
                        Name = "Section",
                        Value = list.Section,
                        Replace = false
                    },
                    new ReplaceableAttribute
                    {
                        Name = "NewsItem",
                        Value = list.NewsItem,
                        Replace = false
                    },
                    new ReplaceableAttribute
                    {
                        Name = "NewsHeadline",
                        Value = list.NewsHeadline,
                        Replace = true
                    },
                    new ReplaceableAttribute
                    {
                        Name = "NewsAdded",
                        Value = Convert.ToString(list.NewsAdded),
                        Replace = true
                    },
                     new ReplaceableAttribute
                     {
                         Name = "Photos",
                         Value = list.NewsPhotoUrl,
                         Replace = true
                     }
                     ,
                     new ReplaceableAttribute
                     {
                         Name = "Summary",
                         Value = list.Summary,
                         Replace = true
                     },
                     new ReplaceableAttribute
                     {
                         Name = "Category",
                         Value = list.Category,
                         Replace = true
                     }
                     ,
                     new ReplaceableAttribute
                     {
                         Name = "TimeStamp",
                         Value = Convert.ToString(list.TimeStamp),
                         Replace = true
                    }
                };
                replaceableItem.WithAttribute(list1.ToArray());
                batchPutAttributesRequest.Item.Add(replaceableItem);
            }

            //PutAttributesRequest  putAttrRequest = new PutAttributesRequest()
            //    .WithDomainName(domainName)
            //    .WithItemName(Convert.ToString(newsItems.NewsID));

            // sdbClient.PutAttributes(putAttrRequest);
            sdbClient.BatchPutAttributes(batchPutAttributesRequest);
        }
        /// <summary>
        /// Initiates the asynchronous execution of the BatchPutAttributes operation.
        /// <seealso cref="Amazon.SimpleDB.IAmazonSimpleDB.BatchPutAttributes"/>
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
		public Task<BatchPutAttributesResponse> BatchPutAttributesAsync(BatchPutAttributesRequest request, CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new BatchPutAttributesRequestMarshaller();
            var unmarshaller = BatchPutAttributesResponseUnmarshaller.GetInstance();
            return Invoke<IRequest, BatchPutAttributesRequest, BatchPutAttributesResponse>(request, marshaller, unmarshaller, signer, cancellationToken);
        }
        /// <summary>
        /// <para> The <c>BatchPutAttributes</c> operation creates or replaces attributes within one or more items. By using this operation, the client
        /// can perform multiple PutAttribute operation with a single call. This helps yield savings in round trips and latencies, enabling Amazon
        /// SimpleDB to optimize requests and generally produce better throughput. </para> <para> The client may specify the item name with the
        /// <c>Item.X.ItemName</c> parameter. The client may specify new attributes using a combination of the <c>Item.X.Attribute.Y.Name</c> and
        /// <c>Item.X.Attribute.Y.Value</c> parameters. The client may specify the first attribute for the first item using the parameters
        /// <c>Item.0.Attribute.0.Name</c> and <c>Item.0.Attribute.0.Value</c> ,
        /// and for the second attribute for the first item by the parameters <c>Item.0.Attribute.1.Name</c> and <c>Item.0.Attribute.1.Value</c> ,
        /// and so on. </para> <para> Attributes are uniquely identified within an item by their name/value combination. For example, a single item
        /// can have the attributes <c>{ "first_name", "first_value" }</c> and <c>{ "first_name", "second_value" }</c> .
        /// However, it cannot have two attribute instances where both the <c>Item.X.Attribute.Y.Name</c> and <c>Item.X.Attribute.Y.Value</c> are the
        /// same. </para> <para> Optionally, the requester can supply the <c>Replace</c> parameter for each individual value. Setting this value to
        /// <c>true</c> will cause the new attribute values to replace the existing attribute values. For example, if an item <c>I</c> has the
        /// attributes <c>{ 'a', '1' }, { 'b', '2'}</c> and <c>{ 'b', '3' }</c> and the requester does a BatchPutAttributes of <c>{'I', 'b', '4' }</c>
        /// with the Replace parameter set to true, the final attributes of the item will be <c>{ 'a', '1' }</c> and <c>{ 'b', '4' }</c> ,
        /// replacing the previous values of the 'b' attribute with the new value. </para> <para><b>NOTE:</b> You cannot specify an empty string as an
        /// item or as an attribute name. The BatchPutAttributes operation succeeds or fails in its entirety. There are no partial puts. </para>
        /// <para><b>IMPORTANT:</b> This operation is vulnerable to exceeding the maximum URL size when making a REST request using the HTTP GET method.
        /// This operation does not support conditions using Expected.X.Name, Expected.X.Value, or Expected.X.Exists. </para> <para> You can execute
        /// multiple <c>BatchPutAttributes</c> operations and other operations in parallel. However, large numbers of concurrent
        /// <c>BatchPutAttributes</c> calls can result in Service Unavailable (503) responses. </para> <para> The following limitations are enforced for
        /// this operation:
        /// <ul>
        /// <li>256 attribute name-value pairs per item</li>
        /// <li>1 MB request size</li>
        /// <li>1 billion attributes per domain</li>
        /// <li>10 GB of total user data storage per domain</li>
        /// <li>25 item limit per <c>BatchPutAttributes</c> operation</li>
        /// 
        /// </ul>
        /// </para>
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes service method on
        /// AmazonSimpleDB.</param>
        /// 
        /// <exception cref="T:Amazon.SimpleDB.Model.DuplicateItemNameException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.InvalidParameterValueException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberDomainBytesExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberSubmittedItemsExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberSubmittedAttributesExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberDomainAttributesExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NoSuchDomainException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberItemAttributesExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.MissingParameterException" />
		public BatchPutAttributesResponse BatchPutAttributes(BatchPutAttributesRequest request)
        {
            var task = BatchPutAttributesAsync(request);
            try
            {
                return task.Result;
            }
            catch(AggregateException e)
            {
                ExceptionDispatchInfo.Capture(e.InnerException).Throw();
                return null;
            }
        }
        private void btnBatchPutAttributes_Click(object sender, RoutedEventArgs e)
        {
            SimpleDB.Client.OnSimpleDBResponse += BatchPutAttributeWebResponse;
            BatchPutAttributesRequest request = new BatchPutAttributesRequest() { DomainName = this.DomainName };
            this.BatchPutMessage = "Please wait...";
            List<ReplaceableAttribute> attributesOne = new List<ReplaceableAttribute>();
            List<ReplaceableAttribute> attributesTwo = new List<ReplaceableAttribute>();

            List<AttributeAndValue> aAndV = GetListAttributeAndValueFromString(this.AttributesAndValuesToPut);

            int index = 0;
            foreach (var item in aAndV)
            {
                if (index <= aAndV.Count / 2)
                    attributesOne.Add(new ReplaceableAttribute().WithName(item.Attribute).WithValue(item.Value));
                else
                    attributesTwo.Add(new ReplaceableAttribute().WithName(item.Attribute).WithValue(item.Value));
                index++;
            }

            //attributesOne.Add(new ReplaceableAttribute().WithName("Category").WithValue("Clothes"));
            //attributesOne.Add(new ReplaceableAttribute().WithName("Subcategory").WithValue("Sweater"));
            //attributesOne.Add(new ReplaceableAttribute().WithName("Name").WithValue("Cathair Sweater"));

            //attributesTwo.Add(new ReplaceableAttribute().WithName("Color").WithValue("Siamese"));
            //attributesTwo.Add(new ReplaceableAttribute().WithName("Size").WithValue("Small"));
            //attributesTwo.Add(new ReplaceableAttribute().WithName("Size").WithValue("Medium"));
            //attributesTwo.Add(new ReplaceableAttribute().WithName("Size").WithValue("Large"));

            List<ReplaceableItem> replacableItem = request.Items;

            //Get the item-names.
            foreach (var item in GetItemNames(this.ItemName))
            {
                ReplaceableItem repItem = new ReplaceableItem() { ItemName = item };
                attributesOne.ForEach(a => repItem.Attribute.Add(a));
                replacableItem.Add(repItem);
            }
            //replacableItem.Add(new ReplaceableItem() { Attribute = attributesOne, ItemName = "OneAttribute" });
            //replacableItem.Add(new ReplaceableItem() { Attribute = attributesTwo, ItemName = "TwoAttribute" });
            SimpleDB.Client.BatchPutAttributes(request);
        }
        /// <summary>
        /// Initiates the asynchronous execution of the BatchPutAttributes operation.
        /// <seealso cref="Amazon.SimpleDB.IAmazonSimpleDB"/>
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes operation on AmazonSimpleDBClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchPutAttributes
        ///         operation.</returns>
        public IAsyncResult BeginBatchPutAttributes(BatchPutAttributesRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new BatchPutAttributesRequestMarshaller();
            var unmarshaller = BatchPutAttributesResponseUnmarshaller.Instance;

            return BeginInvoke<BatchPutAttributesRequest>(request, marshaller, unmarshaller,
                callback, state);
        }
	    BatchPutAttributesResponse AmazonSimpleDB.BatchPutAttributes(BatchPutAttributesRequest request)
	    {
	        throw new NotImplementedException();
	    }
 /// <summary>
 /// <para> The <c>BatchPutAttributes</c> operation creates or replaces attributes within one or more items. By using this operation, the client
 /// can perform multiple PutAttribute operation with a single call. This helps yield savings in round trips and latencies, enabling Amazon
 /// SimpleDB to optimize requests and generally produce better throughput. </para> <para> The client may specify the item name with the
 /// <c>Item.X.ItemName</c> parameter. The client may specify new attributes using a combination of the <c>Item.X.Attribute.Y.Name</c> and
 /// <c>Item.X.Attribute.Y.Value</c> parameters. The client may specify the first attribute for the first item using the parameters
 /// <c>Item.0.Attribute.0.Name</c> and <c>Item.0.Attribute.0.Value</c> ,
 /// and for the second attribute for the first item by the parameters <c>Item.0.Attribute.1.Name</c> and <c>Item.0.Attribute.1.Value</c> ,
 /// and so on. </para> <para> Attributes are uniquely identified within an item by their name/value combination. For example, a single item
 /// can have the attributes <c>{ "first_name", "first_value" }</c> and <c>{ "first_name", "second_value" }</c> .
 /// However, it cannot have two attribute instances where both the <c>Item.X.Attribute.Y.Name</c> and <c>Item.X.Attribute.Y.Value</c> are the
 /// same. </para> <para> Optionally, the requester can supply the <c>Replace</c> parameter for each individual value. Setting this value to
 /// <c>true</c> will cause the new attribute values to replace the existing attribute values. For example, if an item <c>I</c> has the
 /// attributes <c>{ 'a', '1' }, { 'b', '2'}</c> and <c>{ 'b', '3' }</c> and the requester does a BatchPutAttributes of <c>{'I', 'b', '4' }</c>
 /// with the Replace parameter set to true, the final attributes of the item will be <c>{ 'a', '1' }</c> and <c>{ 'b', '4' }</c> ,
 /// replacing the previous values of the 'b' attribute with the new value. </para> <para><b>NOTE:</b> You cannot specify an empty string as an
 /// item or as an attribute name. The BatchPutAttributes operation succeeds or fails in its entirety. There are no partial puts. </para>
 /// <para><b>IMPORTANT:</b> This operation is vulnerable to exceeding the maximum URL size when making a REST request using the HTTP GET method.
 /// This operation does not support conditions using Expected.X.Name, Expected.X.Value, or Expected.X.Exists. </para> <para> You can execute
 /// multiple <c>BatchPutAttributes</c> operations and other operations in parallel. However, large numbers of concurrent
 /// <c>BatchPutAttributes</c> calls can result in Service Unavailable (503) responses. </para> <para> The following limitations are enforced for
 /// this operation:
 /// <ul>
 /// <li>256 attribute name-value pairs per item</li>
 /// <li>1 MB request size</li>
 /// <li>1 billion attributes per domain</li>
 /// <li>10 GB of total user data storage per domain</li>
 /// <li>25 item limit per <c>BatchPutAttributes</c> operation</li>
 /// 
 /// </ul>
 /// </para>
 /// </summary>
 /// 
 /// <param name="batchPutAttributesRequest">Container for the necessary parameters to execute the BatchPutAttributes service method on
 ///          AmazonSimpleDB.</param>
 /// 
 /// <exception cref="DuplicateItemNameException"/>
 /// <exception cref="InvalidParameterValueException"/>
 /// <exception cref="NumberDomainBytesExceededException"/>
 /// <exception cref="NumberSubmittedItemsExceededException"/>
 /// <exception cref="NumberSubmittedAttributesExceededException"/>
 /// <exception cref="NumberDomainAttributesExceededException"/>
 /// <exception cref="NoSuchDomainException"/>
 /// <exception cref="NumberItemAttributesExceededException"/>
 /// <exception cref="MissingParameterException"/>
 public BatchPutAttributesResponse BatchPutAttributes(BatchPutAttributesRequest batchPutAttributesRequest)
 {
     IAsyncResult asyncResult = invokeBatchPutAttributes(batchPutAttributesRequest, null, null, true);
     return EndBatchPutAttributes(asyncResult);
 }
	    IAsyncResult AmazonSimpleDB.BeginBatchPutAttributes(BatchPutAttributesRequest request, AsyncCallback callback, object state)
	    {
	        throw new NotImplementedException();
	    }
 /// <summary>
 /// Initiates the asynchronous execution of the BatchPutAttributes operation.
 /// <seealso cref="Amazon.SimpleDB.IAmazonSimpleDB.BatchPutAttributes"/>
 /// </summary>
 /// 
 /// <param name="batchPutAttributesRequest">Container for the necessary parameters to execute the BatchPutAttributes operation on
 ///          AmazonSimpleDB.</param>
 /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
 /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
 ///          procedure using the AsyncState property.</param>
 public IAsyncResult BeginBatchPutAttributes(BatchPutAttributesRequest batchPutAttributesRequest, AsyncCallback callback, object state)
 {
     return invokeBatchPutAttributes(batchPutAttributesRequest, callback, state, false);
 }
        /// <summary>
        /// <para> The <c>BatchPutAttributes</c> operation creates or replaces attributes within one or more items. By using this operation, the client
        /// can perform multiple PutAttribute operation with a single call. This helps yield savings in round trips and latencies, enabling Amazon
        /// SimpleDB to optimize requests and generally produce better throughput. </para> <para> The client may specify the item name with the
        /// <c>Item.X.ItemName</c> parameter. The client may specify new attributes using a combination of the <c>Item.X.Attribute.Y.Name</c> and
        /// <c>Item.X.Attribute.Y.Value</c> parameters. The client may specify the first attribute for the first item using the parameters
        /// <c>Item.0.Attribute.0.Name</c> and <c>Item.0.Attribute.0.Value</c> ,
        /// and for the second attribute for the first item by the parameters <c>Item.0.Attribute.1.Name</c> and <c>Item.0.Attribute.1.Value</c> ,
        /// and so on. </para> <para> Attributes are uniquely identified within an item by their name/value combination. For example, a single item
        /// can have the attributes <c>{ "first_name", "first_value" }</c> and <c>{ "first_name", "second_value" }</c> .
        /// However, it cannot have two attribute instances where both the <c>Item.X.Attribute.Y.Name</c> and <c>Item.X.Attribute.Y.Value</c> are the
        /// same. </para> <para> Optionally, the requester can supply the <c>Replace</c> parameter for each individual value. Setting this value to
        /// <c>true</c> will cause the new attribute values to replace the existing attribute values. For example, if an item <c>I</c> has the
        /// attributes <c>{ 'a', '1' }, { 'b', '2'}</c> and <c>{ 'b', '3' }</c> and the requester does a BatchPutAttributes of <c>{'I', 'b', '4' }</c>
        /// with the Replace parameter set to true, the final attributes of the item will be <c>{ 'a', '1' }</c> and <c>{ 'b', '4' }</c> ,
        /// replacing the previous values of the 'b' attribute with the new value. </para> <para><b>NOTE:</b> You cannot specify an empty string as an
        /// item or as an attribute name. The BatchPutAttributes operation succeeds or fails in its entirety. There are no partial puts. </para>
        /// <para><b>IMPORTANT:</b> This operation is vulnerable to exceeding the maximum URL size when making a REST request using the HTTP GET method.
        /// This operation does not support conditions using Expected.X.Name, Expected.X.Value, or Expected.X.Exists. </para> <para> You can execute
        /// multiple <c>BatchPutAttributes</c> operations and other operations in parallel. However, large numbers of concurrent
        /// <c>BatchPutAttributes</c> calls can result in Service Unavailable (503) responses. </para> <para> The following limitations are enforced for
        /// this operation:
        /// <ul>
        /// <li>256 attribute name-value pairs per item</li>
        /// <li>1 MB request size</li>
        /// <li>1 billion attributes per domain</li>
        /// <li>10 GB of total user data storage per domain</li>
        /// <li>25 item limit per <c>BatchPutAttributes</c> operation</li>
        /// 
        /// </ul>
        /// </para>
        /// </summary>
        /// 
        /// <param name="batchPutAttributesRequest">Container for the necessary parameters to execute the BatchPutAttributes service method on
        /// AmazonSimpleDB.</param>
        /// 
        /// <exception cref="T:Amazon.SimpleDB.Model.DuplicateItemNameException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.InvalidParameterValueException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberDomainBytesExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberSubmittedItemsExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberSubmittedAttributesExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberDomainAttributesExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NoSuchDomainException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.NumberItemAttributesExceededException" />
        /// <exception cref="T:Amazon.SimpleDB.Model.MissingParameterException" />
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
		public async Task<BatchPutAttributesResponse> BatchPutAttributesAsync(BatchPutAttributesRequest batchPutAttributesRequest, CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new BatchPutAttributesRequestMarshaller();
            var unmarshaller = BatchPutAttributesResponseUnmarshaller.GetInstance();
            var response = await Invoke<IRequest, BatchPutAttributesRequest, BatchPutAttributesResponse>(batchPutAttributesRequest, marshaller, unmarshaller, signer, cancellationToken)
                .ConfigureAwait(continueOnCapturedContext: false);
            return response;
        }
        public static void AmazonBatchPutPost(List<ForumPost> awsPosts,int threadIndex)
        {
            SimpleDB.Client.OnSimpleDBResponse += BatchPutAttributeWebResponse;
            BatchPutAttributesRequest request = new BatchPutAttributesRequest() { DomainName = "coreDB" };
            ReplaceableAttribute attributesOne = new ReplaceableAttribute().WithName("votes").WithValue("0").WithReplace(true);
            ReplaceableAttribute attributesTwo = new ReplaceableAttribute().WithName("module").WithValue(data.modules[data.curModuleIndex].CourseCode.ToString());
            ReplaceableAttribute attributesThree = new ReplaceableAttribute().WithName("AWSTimestamp").WithValue(data.modules[data.curModuleIndex].lastUpdated.ToString()).WithReplace(true);
            ReplaceableAttribute attributesFour;
            ReplaceableAttribute attributesFive = new ReplaceableAttribute().WithName("root").WithValue(data.modules[data.curModuleIndex].jPosts["Results"][0]["Threads"][threadIndex]["ID"].ToString());

            //int forumIndex = 0;
            //int i = 0;

            List<ReplaceableItem> replacableItem = request.Items;
            int t = 0;

            //List<ForumPostTitle> titles = fetchForumTitles(data.curModuleIndex, data.curForumIndex, 0);
            foreach (var post in awsPosts)
            {

                attributesFour = new ReplaceableAttribute().WithName("title").WithValue(post.Heading.ToString());
                //attributesFive = new ReplaceableAttribute().WithName("subscriber").WithValue(data.modules[data.curModuleIndex].lastUpdated.ToString());

                ReplaceableItem repItem = new ReplaceableItem() { ItemName = post.ID.ToString() };
                repItem.Attribute.Add(attributesOne);
                repItem.Attribute.Add(attributesTwo);
                repItem.Attribute.Add(attributesThree);
                repItem.Attribute.Add(attributesFour);
                repItem.Attribute.Add(attributesFive);
                replacableItem.Add(repItem);
                t++;

            }

            SimpleDB.Client.BatchPutAttributes(request);
        }