/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='contactMeViewModel'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <bool?> PostAsync(this IEmail operations, ContactMeViewModel contactMeViewModel, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.PostWithHttpMessagesAsync(contactMeViewModel, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public JsonResult Sendgrid(ContactMeViewModel viewModel)
{
try
{
var receiver = ConfigurationManager.AppSettings["mailconfig.receiver"];
var url = ConfigurationManager.AppSettings["mailconfig.sender"];
var apiKey = ConfigurationManager.AppSettings["sendgrid.key"];
var client = new SendGridClient(apiKey);
var from = new EmailAddress(url);
var subject = $"Consulta recibida en web";
var to = new EmailAddress(receiver);
var plainTextContent = string.Empty;
var content = GetHtmlContent(viewModel);
var msg = MailHelper.CreateSingleEmail(from, to, subject, plainTextContent, content);
var response = client.SendEmailAsync(msg).Result;
var result = response.Body.ReadAsStringAsync().Result;
return(Json("OK", JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(e.Message + " " + e.InnerException, JsonRequestBehavior.AllowGet));
}
}
private string GetHtmlContent(ContactMeViewModel viewModel)
{
var content = "<!DOCTYPE html>" +
"<html>" +
"<body>" +
"<h3> Consulta recibida </h3>" +
"Se realizo una consulta vía web" +
"<br/>" +
"<strong> Asunto</strong>: ##Asunto##" +
"<br/>" +
"<strong> Nombre</strong>: ##Nombre##" +
"<br/>" +
"<strong> Email</strong>: ##Email##" +
"<br/>" +
"<strong> Mensaje</strong>: ##Mensaje##" +
"<br/>" +
"Saludos!" +
"<br/>" +
"</body>" +
"</html>";
content = content
.Replace("##Asunto##", viewModel.Subject)
.Replace("##Nombre##", viewModel.Name)
.Replace("##Email##", viewModel.Email)
.Replace("##Mensaje##", viewModel.Message);
return(content); // llevar a template externo
}
public async Task <bool> ContactMe(ContactMeViewModel contact)
{
try
{
var customer = new Customer
{
CreationDate = DateTime.Now,
PhoneNumber = contact.Phone,
Email = contact.Email,
Name = contact.Name,
Content = contact.Content,
EditDate = DateTime.Now,
};
var tasksList = new List <Task>();
_customerRepository.Add(customer);
SendNewCustomerEmail(customer);
_customerRepository.SaveChanges();
return(true);
}
catch (Exception e)
{
Debug.WriteLine(e);
return(true);
}
}
public ActionResult Index(ContactMeViewModel contactMeViewModel)
{
if (!ModelState.IsValid)
{
return(View(contactMeViewModel));
}
bool isSuccess = _emailService.Send(contactMeViewModel.FromEmail, contactMeViewModel.Subject,
contactMeViewModel.Message);
return(View(contactMeViewModel));
}
public JsonResult ContactMe(ContactMeViewModel viewModel)
{
try
{
LoggingUtils.Instance.Information($"Sending mail: {JsonConvert.SerializeObject(viewModel)}");
//SendMail(viewModel);
Sendgrid(viewModel);
return(Json("ok"));
}
catch (Exception e)
{
LoggingUtils.Instance.Information(e, "Error while sending mail");
//Response.StatusCode = 400;
return(Json(e.Message + " " + e.InnerException));
}
}
public IHttpActionResult Post(ContactMeViewModel contactMeViewModel)
{
if (contactMeViewModel == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
bool isSuccess = _emailService.Send(contactMeViewModel.FromEmail, contactMeViewModel.Subject, contactMeViewModel.Message);
//return StatusCode(HttpStatusCode.NoContent);
return(Ok(isSuccess));
}
public IActionResult Create(ContactMeViewModel model)
{
if (ModelState.IsValid)
{
ContactMe contactMe = new ContactMe
{
Fullname = model.Fullname,
Email = model.Email,
Phone = model.Phone,
Message = model.Message
};
_contactMe.Entity.Insert(contactMe);
_contactMe.Save();
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public ContactMeViewModel GetInformationBy(long id)
{
var info = _serviceContext.ContactMe.FirstOrDefault(x => x.Id == id);
if (info == null)
{
return(new ContactMeViewModel());
}
var information = new ContactMeViewModel
{
Id = info.Id,
FullName = info.FullName,
Email = info.Email,
Mobile = info.Mobile,
Message = info.Message
};
return(information);
}
public ActionResult SendEmail(ContactMeViewModel model)
{
string messageFormat = @"derricklogsdon.com Contact Request from
Name is : {0}
Phone Number is : {1}
Email Address is : {2}
Message :
{3}";
string message = string.Format(messageFormat, model.Name, model.PhoneNumber, model.EmailAddress, model.Message);
try {
string emailAddress = _config.GetValue <string>("EmailAddress");
Task.WaitAll(_emailSender.SendEmailAsync(emailAddress, "derricklogsdon.com Contact Form", message));
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
return(StatusCode(StatusCodes.Status200OK));
}
public ActionResult Edit(Guid id, ContactMeViewModel model)
{
if (id != model.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
ContactMe contactMe = new ContactMe
{
Id = model.Id,
Fullname = model.Fullname,
Email = model.Email,
Phone = model.Phone,
Message = model.Message
};
_contactMe.Entity.Update(contactMe);
_contactMe.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!ContactMeExists(model.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
// GET: ContactMes/Edit/5
public IActionResult Edit(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var contactMe = _contactMe.Entity.GetById(id);
if (contactMe == null)
{
return(NotFound());
}
ContactMeViewModel contactMeViewModel = new ContactMeViewModel
{
Id = contactMe.Id,
Fullname = contactMe.Fullname,
Email = contactMe.Email,
Phone = contactMe.Phone,
Message = contactMe.Message
};
return(View(contactMe));
}
public JsonResult ContactMe([FromBody] ContactMeViewModel contact)
{
_emailService.ContactMe(contact);
return(Json(new { Error = false, contact }));
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='contactMeViewModel'>
/// </param>
public static bool?Post(this IEmail operations, ContactMeViewModel contactMeViewModel)
{
return(Task.Factory.StartNew(s => ((IEmail)s).PostAsync(contactMeViewModel), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
/// <param name='contactMeViewModel'>
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse <bool?> > PostWithHttpMessagesAsync(ContactMeViewModel contactMeViewModel, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (contactMeViewModel == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "contactMeViewModel");
}
if (contactMeViewModel != null)
{
contactMeViewModel.Validate();
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("contactMeViewModel", contactMeViewModel);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "Post", tracingParameters);
}
// Construct URL
var _baseUrl = this.Client.BaseUri.AbsoluteUri;
var _url = new Uri(new Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/Email").ToString();
// Create HTTP transport objects
HttpRequestMessage _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (contactMeViewModel != null)
{
_requestContent = SafeJsonConvert.SerializeObject(contactMeViewModel, this.Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (this.Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await this.Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await this.Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <bool?>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <bool?>(_responseContent, this.Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
