public IActionResult OnGet()
{
ContactUsDto = new ContactUsDto {
EmailAddress = User.Identity.Name
};
return(Page());
}
public ResultMessage ContactUs(ContactUsDto contactUsDto)
{
var validationResult = _validator.Validate(contactUsDto);
if (!validationResult.IsValid)
{
return new ResultMessage
{
Status = HttpStatusCode.BadRequest,
ValidationMessages = validationResult.GetErrorsList()
}
}
;
try
{
var replacements = SetContactUsMailReplacements(contactUsDto.Name, contactUsDto.Email, contactUsDto.PhoneNumber, contactUsDto.Details);
_emailService.SendEmailAsync(_settings.EmailSettings.AdminMail, _settings.EmailSettings.ContactUsEmail.Subject, EmailTemplatesEnum.ContactUs, replacements);
return(new ResultMessage
{
Status = HttpStatusCode.OK
});
}
catch (Exception ex)
{
_logger.LogError(ex, string.Empty);
return(new ResultMessage()
{
ErrorCode = (int)HomeErrorsCodeEnum.ContactUs,
Status = HttpStatusCode.InternalServerError
});
}
}
public async Task <IHttpActionResult> PutContactUs(int id, ContactUsDto contactUsDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != contactUsDto.ID)
{
return(BadRequest());
}
var contactUs = DtoToEntityIMapper.Map <ContactUsDto, ContactUs>(contactUsDto); ////
UoW.GetRepository <ContactUs>().ModifyEntityState(contactUs);
try
{
await UoW.SaveAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContactUsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
// GET: api/GetContactUs
public IHttpActionResult GetContactUss()
{
List <ContactUs> ContactUs = db.contactus.ToList();
// list object holds dtos
List <ContactUsDto> ContactUsDtos = new List <ContactUsDto> {
};
// Convert ContactUs into a ContactUsDto
foreach (var XContactUs in ContactUs)
{
ContactUsDto NewContactUs = new ContactUsDto
{
// Set the dto properties.
ContactUsId = XContactUs.ContactUsId,
FirstName = XContactUs.FirstName,
LastName = XContactUs.LastName,
Email = XContactUs.Email,
Message = XContactUs.Message,
Reply = XContactUs.Reply,
Status = XContactUs.Status
};
// Add the dto to the list.
ContactUsDtos.Add(NewContactUs);
}
return(Ok(ContactUsDtos));
}
public async Task <IActionResult> ContactAdmins(ContactUsDto model)
{
var user = _authService.GetCurrentUser(HttpContext.User);
var admins = _userService.GetUsersByRole("Admin");
var emailBody = $"New request from <a href='mailto:{user.Email}?subject=re:{model.Type}'>{user.Email}</a> : <br />{model.Description}. ";
try
{
foreach (var admin in admins)
{
await _emailService.SendEmailAsync(new EmailDTO
{
Subject = model.Type,
RecepientEmail = admin.Email,
MessageText = emailBody
});
}
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task SaveRequestAsync(ContactUsDto contactUsDto)
{
var contactUs = Mapper.Map <ContactUs>(contactUsDto);
await _unitOfWorkEf.Repository <ContactUs>().AddAsync(contactUs);
await _unitOfWorkEf.CommitAsync();
}
public async Task <bool> CreateContactUsAsync(ContactUsDto input)
{
var contact = new ContactUs(input.Name, input.Email, input.Message);
var id = await _contactUsRepository.InsertAndGetIdAsync(contact);
await CurrentUnitOfWork.SaveChangesAsync();
return(id > 0);
}
public static ContactUsViewModel ToViewModel(this ContactUsDto source)
{
return(new ContactUsViewModel
{
FullName = source.FullName,
Id = source.Id,
PhoneNumber = source.PhoneNumber,
Text = source.Text
});
}
public static ContactUSViewModel ToViewModel(this ContactUsDto source)
{
return(new ContactUSViewModel
{
Description = source.Description,
UserId = source.UserId,
Id = source.Id,
Date = source.Date.ToFriendlyPersianDateTextify(),
User = source.User?.ToViewModel()
});
}
/// <summary>
/// Default contact us page view.
/// </summary>
/// <returns></returns>
// GET: /<controller>/
public async Task <IActionResult> Index()
{
var model = new ContactUsDto();
model.UserName = _userManager.GetUserName(User);
if (model.UserName == null)
{
model.UserName = "******";
}
return(await Task.FromResult <IActionResult>(View(model)));
}
public ContactUsDto MapToContactUsDto(SqlDataReader sqlDataReader)
{
ContactUsDto contactUsDto = new ContactUsDto();
contactUsDto.Id = sqlDataReader["Id"].ToInteger();
contactUsDto.Subject = sqlDataReader["Subject"].ToString();
contactUsDto.Message = sqlDataReader["Message"].ToString();
contactUsDto.EmailAddress = sqlDataReader["EmailAddress"].ToString();
contactUsDto.CrudStatus = CrudStatus.UPDATE;
return(contactUsDto);
}
public Result Save(ContactUsDto dto)
{
var result = new Result();
var entity = Mapper.Map <ContactUsInquiry>(dto);
_contactUsInquiryRepository.Insert(entity);
_unitOfWork.Commit();
result.Data = dto.Email;
result.SetSuccess("Thank you for contacting us. We will get back to you soon.");
return(result);
}
public IActionResult SendEditProjectRequest([FromBody] ContactUsDto contactUsDto, string projectName)
{
try
{
_userService.SendEditProjectRequest(contactUsDto.Name, contactUsDto.Email, contactUsDto.Message, projectName);
return(Ok());
}
catch (Exception ex)
{
Logger.LogException(Log, ex, MethodBase.GetCurrentMethod());
return(new StatusCodeResult(503));
}
}
public async Task <IHttpActionResult> PostContactUs(ContactUsDto contactUsDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var contactUs = DtoToEntityIMapper.Map <ContactUsDto, ContactUs>(contactUsDto); ////
UoW.GetRepository <ContactUs>().Insert(contactUs);
await UoW.SaveAsync();
return(CreatedAtRoute("DefaultApi", new { id = contactUs.ID }, contactUs));
}
public IActionResult SendMessageFromContactUs([FromBody] ContactUsDto contactUsDto)
{
try
{
_userService.SendMessageFromContactUs(contactUsDto.Name, contactUsDto.Email, contactUsDto.Message);
return(Ok());
}
catch (Exception ex)
{
Logger.LogException(Log, ex, MethodBase.GetCurrentMethod());
return(new StatusCodeResult(503));
}
}
public async Task <ActionResult <ContactUsDto> > PostContactUs([FromBody] ContactUsDto contactUsDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ContactUs contactUs = DtoToEntityIMapper.Map <ContactUsDto, ContactUs>(contactUsDto);
repository.Add(contactUs);
await uoW.SaveAsync();
return(CreatedAtAction("GetContactUs", new { id = contactUs.ID }, contactUsDto));
}
public Response <ContactUsDto> Save(ContactUsDto contactUsDto)
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
Response <ContactUsDto> response = unitOfWork.ContactUs.Save(contactUsDto, ContactUsMappers.Instance.MapToContactUsDto);
if (contactUsDto.CrudStatus == CrudStatus.CREATE)
{
SendContactUsEmail(contactUsDto);
}
return(response);
}
}
public ActionResult DeleteConfirm(int id)
{
string url = "ContactUsData/GetContactUs/" + id;
HttpResponseMessage response = client.GetAsync(url).Result;
if (response.IsSuccessStatusCode)
{
ContactUsDto SelectedContactUs = response.Content.ReadAsAsync <ContactUsDto>().Result;
return(View(SelectedContactUs));
}
else
{
return(RedirectToAction("Error"));
}
}
// GET: ContactUs/Details/5
public ActionResult Details(int id)
{
// browser url
string url = "ContactUsData/GetContactUs/" + id;
// send and recieve http request and action
HttpResponseMessage response = client.GetAsync(url).Result;
// http call successful
if (response.IsSuccessStatusCode)
{
ContactUsDto ContactUsDto = response.Content.ReadAsAsync <ContactUsDto>().Result;
return(View(ContactUsDto));
}
return(RedirectToAction("Error"));
}
// GET: api/ContactUsData/5
public IHttpActionResult GetContactUs(int id)
{
ContactUs ContactUs = db.contactus.Find(id);
ContactUsDto ContactUsDto = new ContactUsDto
{
ContactUsId = ContactUs.ContactUsId,
FirstName = ContactUs.FirstName,
LastName = ContactUs.LastName,
Email = ContactUs.Email,
Message = ContactUs.Message,
Reply = ContactUs.Reply,
Status = ContactUs.Status
};
return(Ok(ContactUsDto));
}
public async Task <ActionResult <ContactUsDto> > GetContactUs([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var contactUs = await repository.GetAsync(a => a.ID == id);
if (contactUs == null)
{
return(NotFound());
}
ContactUsDto contactUsDto = EntityToDtoIMapper.Map <ContactUs, ContactUsDto>(contactUs);
return(Ok(contactUsDto));
}
private void SendContactUsEmail(ContactUsDto contactUsDto)
{
string smtpServerAddress = ConfigurationManager.AppSettings["LiveSMTPAddress"];
int smtpPortNumber = Convert.ToInt32(ConfigurationManager.AppSettings["LiveSMTPPortNumber"]);
string fromAddress = ConfigurationManager.AppSettings["LiveEmailFrom"];
string toAddress = ConfigurationManager.AppSettings["LiveEmailReciever"];
string accountUserName = ConfigurationManager.AppSettings["LiveAccountUsername"];
string accountPassword = ConfigurationManager.AppSettings["LiveAccountPassword"];
string subject = string.Format("{0} Email notification ... {0}!", contactUsDto.Subject);
StringBuilder sb = new StringBuilder();
// Add email heading
sb.Append(string.Format("{0}.", contactUsDto.Message));
EmailHandler.SendEmailUsingExternalMailBox(smtpServerAddress, smtpPortNumber, accountUserName, accountPassword, fromAddress, toAddress, null, subject, sb.ToString());
}
public IActionResult Index(ContactUsDto model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
model.UserName = _userManager.GetUserName(User);
string message = "User " + model.UserName + " is contacting us. " + model.Content;
_emailSender.SendEmailAsync(model.Subject, message);
// Read the reason
var reason = _resourcesService.GetString(this.Culture, Lines.THANK_YOU_FOR_CONTACTING);
return(RedirectToAction("Index", "Home", new { reason = reason }));
}
public void SendMailToAdminForContactUs(ContactUsDto model)
{
var emailTemplate = _emailTemplateService.GetEmailTemplateBySlug("contact-us-admin");
new MailHelper()
.To(_adminEmail)
.Subject(emailTemplate.Subject)
.Body(emailTemplate.Content)
.Variables(new Dictionary <string, object>
{
{ "Name", model.Name },
{ "Email", model.Email },
{ "Phone", model.Phone },
{ "Message", model.Details },
{ "WebsiteUrl", _appSettings.WebsiteUrl },
{ "WebsiteName", _appSettings.WebsiteName },
{ "Year", DateTime.Today.Year }
})
.Send();
}
public JsonNetResult Index(ContactUsDto dto)
{
var result = _contactUsService.SaveValidation(dto);
if (_appSettings.RecaptchaEnable)
{
if (string.IsNullOrEmpty(dto.gRecaptchaResponse))
{
result.Errors.Add("gRecaptchaResponse", "The captcha verification required.");
result.Success = false;
}
else if (ReCaptcha.Validate(dto.gRecaptchaResponse, _appSettings.RecaptchaSecretKey) != "true")
{
result.Errors.Add("gRecaptchaResponse", "Invalid captcha verification. Please try again or refresh page.");
result.Success = false;
}
}
if (!result.Success)
{
return(new JsonNetResult(result));
}
result = _contactUsService.Save(dto);
if (!result.Success)
{
return(new JsonNetResult(result));
}
var emailService = new EmailService(_emailTemplateService, _appSettings);
emailService.SendMailToAdminForContactUs(dto);
emailService.SendMailToEndUserForContactUs(dto.Email, dto.Name);
result.Data = null;
return(new JsonNetResult(result));
}
public IActionResult Contact(ContactUsDto dto)
{
if (ModelState.IsValid)
{
var contactUs = _mapper.Map <ContactUs>(dto);
bool a = _contactUsRepo.CreateEntity(contactUs);
if (a)
{
HttpContext.Session.SetString("resultCodeCreateContact", _localizer["Your message has been sent. Thank you."].ToString());
HttpContext.Session.SetObject("contactMessageInfo", dto);
EmailToAdminForContactMessage();
return(LocalRedirect("/"));
}
else
{
return(View("Contact", dto));
}
}
else
{
return(View("Contact", dto));
}
}
public async Task <int> InsertContactus(ContactUsDto model)
{
try
{
using (connection = Get_Connection())
{
var param = new DynamicParameters();
param.Add("id", model.id, DbType.Int32, ParameterDirection.Input);
param.Add("firstname", model.firstname, DbType.String, ParameterDirection.Input);
param.Add("lastname", model.lastname, DbType.String, ParameterDirection.Input);
param.Add("Email", model.Email, DbType.String, ParameterDirection.Input);
param.Add("phonenumber", model.phonenumber, DbType.String, ParameterDirection.Input);
param.Add("message", model.message, DbType.String, ParameterDirection.Input);
var userid = await connection.ExecuteScalarAsync <int>("sp_InsertContactUs", param, commandType : CommandType.StoredProcedure);
return(userid);
}
}
catch (Exception ex)
{
throw;
}
}
public async Task <ActionResult> ContactUsDetails(ContactUsDto contactus)
{
var insetedContact = await dataAccess.InsertContactus(contactus);
return(Json("Ok"));
}
public Result SaveValidation(ContactUsDto dto)
{
return(_contactUsValidator.ValidateResult(dto));
}
public ActionResult ContactUs([FromBody] ContactUsDto contactUsDto)
{
return(GetStatusCodeResult(_homeService.ContactUs(contactUsDto)));
}
