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))); }