/// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
        {
            DeleteTemplateResponse response = new DeleteTemplateResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.IsStartElement)
                {
                    if (context.TestExpression("DeleteTemplateResult", 2))
                    {
                        UnmarshallResult(context, response);
                        continue;
                    }

                    if (context.TestExpression("ResponseMetadata", 2))
                    {
                        response.ResponseMetadata = ResponseMetadataUnmarshaller.Instance.Unmarshall(context);
                    }
                }
            }

            return(response);
        }
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            DeleteTemplateResponse response = new DeleteTemplateResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("Arn", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.Arn = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("RequestId", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.RequestId = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("TemplateId", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.TemplateId = unmarshaller.Unmarshall(context);
                    continue;
                }
            }
            response.Status = (int)context.ResponseData.StatusCode;

            return(response);
        }
Exemple #3
0
        public static DeleteTemplateResponse Unmarshall(UnmarshallerContext context)
        {
            DeleteTemplateResponse deleteTemplateResponse = new DeleteTemplateResponse();

            deleteTemplateResponse.HttpResponse = context.HttpResponse;
            deleteTemplateResponse.RequestId    = context.StringValue("DeleteTemplate.RequestId");

            return(deleteTemplateResponse);
        }
Exemple #4
0
        public async Task <bool> DeleteTemplate(string templatename)
        {
            _deletetemprequest = new DeleteTemplateRequest()
            {
                TemplateName = templatename
            };
            _deletetempresponse = await _Client.DeleteTemplateAsync(_deletetemprequest);

            if (_deletetempresponse.HttpStatusCode.ToString() == "OK")
            {
                return(true);
            }
            return(false);
            //throw new NotImplementedException();
        }
        private static void UnmarshallResult(XmlUnmarshallerContext context, DeleteTemplateResponse response)
        {
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.ReadAtDepth(originalDepth))
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                }
            }

            return;
        }
 public void DeleteEmailTemplate(string templateName)
 {
     using (AmazonSimpleEmailServiceClient client = new AmazonSimpleEmailServiceClient(_regionEndpoint))
     {
         try
         {
             _logger.LogInformation($"DeleteEmailTemplate | TemplateName = {templateName}");
             DeleteTemplateResponse result = client.DeleteTemplateAsync(new DeleteTemplateRequest {
                 TemplateName = templateName
             }).Result;
             _logger.LogInformation($"DeleteTemplateResponse.StatusCode = {result.HttpStatusCode}");
             _logger.LogInformation($"DeleteTemplateResponse.RequestId = {result.ResponseMetadata.RequestId}");
             _logger.LogInformation($"DeleteTemplateResponse.Metadata = {string.Join("; ", result.ResponseMetadata.Metadata)}");
         }
         catch (Exception ex)
         {
             _logger.LogError("Failure in DeleteEmailTemplate. Error message: " + ex.Message);
             throw ex;
         }
     }
 }
Exemple #7
0
        public async Task <ActionResult <DeleteTemplateResponse> > Delete([FromRoute] string clientID, [FromRoute] int id)
        {
            DeleteTemplateResponse response = new DeleteTemplateResponse();
            string responseMessage          = $"DELETE_{clientID}_TEMPLATE_{id}";

            try
            {
                var factory = Factory.Instance.GetTemplate(_configuration);
                await factory.Delete(clientID, id);

                response.StatusCode = "200";
                response.Data       = $"Template {id} deleted with success";
                return(Ok(response));
            }
            catch (Exception ex)
            {
                response.StatusCode = "500";
                response.Messages.Add(ResponseMessage.Create(ex, responseMessage));
                return(StatusCode(500, response));
            }
        }