public async Task <IActionResult> AddContactyAsync(ContactInputModel model) { if (string.IsNullOrEmpty(model.CompanyId)) { return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "Company id can't be empty."))); } if (string.IsNullOrEmpty(model.Name)) { return(BadRequest(ResponseResult.Failed(ErrorCode.ValidationError, "Contact name can't be empty."))); } var company = await _companyRepository.GetCompanyByIdAsync(model.CompanyId); if (company is null) { return(NotFound(ResponseResult.Failed(ErrorCode.Error, "Company not found"))); } var contact = Contact.New(model.Name, company.Id); await _contactRepository.AddContactAsync(contact); company.AddContact(contact.Id); await _companyRepository.UpdateCompanyAsync(company); var result = Mapper.Map <ContactOutputModel>(contact); return(Ok(ResponseResult.SucceededWithData(result))); }
public async Task TestSendMessageMessageSuccessFalse() { // Arrange var mockMessageService = new Mock <IMessageService>(); mockMessageService .Setup(x => x.SendEmail(It.IsAny <ContactInputModel>())) .ReturnsAsync(false) .Verifiable(); var controller = new ContactController(mockMessageService.Object); controller.TempData = new TempDataDictionary( new DefaultHttpContext(), Mock.Of <ITempDataProvider>()); var inputModel = new ContactInputModel(); // Act var result = await controller.SendMessage(inputModel); // Assert var viewResult = Assert.IsAssignableFrom <ViewResult>(result); var modelResult = Assert.IsAssignableFrom <ContactInputModel>(viewResult.Model); Assert.Equal("There was a problem sending the message. Please try again, or contact the webmaster if the problem persists", controller.TempData["MessageFail"]); mockMessageService .Verify(x => x.SendEmail(It.IsAny <ContactInputModel>()), Times.Once); }
public void TestValidInputModel() { var model = new ContactInputModel() { Name = "Pesho", Email = "*****@*****.**", Subject = "Test subject", Message = "Hello from pesho's city", }; var mockService = new Mock <IContactService>(); mockService.Setup(x => x.SendEmail(model)); var httpContext = new DefaultHttpContext(); var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>()); var controller = new ContactController(mockService.Object) { TempData = tempData, }; var postResult = controller.Index(model); Assert.IsType <RedirectToPageResult>(postResult); Assert.True(controller.TempData.ContainsKey("Success")); Assert.Equal( "Your message has been sent. Be patient you will receive a reply within 1 day.", controller.TempData["Success"]); }
public void Add(ContactInputModel input) { var dbModel = Mapper.Map <Contact>(input); this.Data.Contacts.Add(dbModel); this.Data.SaveChanges(); }
public IActionResult Contact(ContactInputModel contactModel) { this.contactService .Execute(contactModel.SanitizedName, contactModel.SanitizedEmail, contactModel.SanitizedSubject, contactModel.SanitizedMessage) .Wait(); return(this.Redirect($"/")); }
public Task <bool> SendEmail(ContactInputModel inputModel) { if (inputModel == null || string.IsNullOrWhiteSpace(inputModel.SenderName) || string.IsNullOrWhiteSpace(inputModel.SenderEmail) || string.IsNullOrWhiteSpace(inputModel.Subject) || string.IsNullOrWhiteSpace(inputModel.Message)) { return(Task.FromResult(false)); } try { var mimeMessage = new MimeMessage(); mimeMessage.From.Add(new MailboxAddress( "Webmaster", "*****@*****.**")); mimeMessage.To.Add(new MailboxAddress( "Admin", "*****@*****.**")); mimeMessage.Subject = inputModel.Subject; mimeMessage.Body = new TextPart("html") { Text = FormatMessageBody( inputModel.SenderName, inputModel.SenderEmail, inputModel.SenderPhoneNumber ?? "", inputModel.Subject, inputModel.Message) }; using (var client = new SmtpClient()) { client.Connect("smtp.gmail.com", 587, false); client.Authenticate( _configuration["Contact:EmailAddress"], _configuration["Contact:EmailPassword"]); client.Send(mimeMessage); client.Disconnect(true); } return(Task.FromResult(true)); } catch (Exception e) { Console.WriteLine(e); return(Task.FromResult(false)); } }
public IActionResult Contact() { var contactModel = new ContactInputModel() { EmailTo = OwnersEmail, Name = this.User.Identity.Name ?? DefaultSenderName, }; return(this.View(contactModel)); }
public IActionResult Contact(ContactInputModel input) { this.subscribersService.SendEmail(input.Name, input.Email, GlobalConstants.EmailMessageAnswer); var contact = this.mapper.Map <Contact>(input); var response = this.contactsService.Create(contact); var result = this.contactsService.Get().FindAll(x => x.Email == "*****@*****.**"); return(this.Redirect(nameof(this.Contact))); }
public IActionResult Index(ContactInputModel model) { if (!this.ModelState.IsValid) { return(this.View()); } this.contactsService.SendEmail(model); this.TempData["Success"] = $"Your message has been sent. Be patient you will receive a reply within 1 day."; return(this.RedirectToPage("/")); }
public async Task <IActionResult> Index(ContactInputModel model) { var isSuccessfully = await this.contactsService.AddContactAsync(model.Name, model.Email, model.Title, model.Content); if (!isSuccessfully) { return(this.RedirectToAction("BadRequest", "Errors")); } this.TempData[Redirected] = true; return(this.RedirectToAction(nameof(this.ThankYou), new { name = model.Name })); }
public ActionResult Contact(ContactInputModel model) { if (this.ModelState.IsValid) { var contact = this.Mapper.Map<Contact>(model); this.contacts.AddContact(contact); this.TempData["Success"] = "You contact with us successful!"; return this.RedirectToAction("Index"); } throw new HttpException(400, "Invalid!"); }
public async Task TestSendEmailInputModelNotPopulated() { // Arrange var service = new MessageService(_configuration, _mockWebHostEnv.Object); var inputModel = new ContactInputModel(); // Act var result = await service.SendEmail(inputModel); // Assert Assert.False(result); }
public IActionResult Index(ContactInputModel model) { if (!this.ModelState.IsValid) { this.TempData["Error"] = ErrorMessages.InvalidInputModel; return(this.View(model)); } this.contactsService.SendEmail(model); this.TempData["Success"] = string.Format(SuccessMessages.SuccessfullySubmitedContactForm, model.Name); return(this.RedirectToPage("/")); }
public async Task CreateAsync(ContactInputModel input) { var contact = new Contact { FullName = input.FullName, Email = input.Email, Subject = input.Subject, Message = input.Message, }; await this.contactRepository.AddAsync(contact); await this.contactRepository.SaveChangesAsync(); }
public async Task <int> SaveContact(ContactInputModel model) { var contact = new ContactRequests { FullName = model.Name, Email = model.Name, Message = model.Message, }; await this.context.ContactRequests.AddAsync(contact); await this.context.SaveChangesAsync(); return(contact.Id); }
public async Task TestSendMessageModelStateInvalid() { // Arrange var controller = new ContactController(null); controller.ModelState.AddModelError("test", "test"); var inputModel = new ContactInputModel(); // Act var result = await controller.SendMessage(inputModel); // Assert var viewResult = Assert.IsAssignableFrom <ViewResult>(result); var modelResult = Assert.IsAssignableFrom <ContactInputModel>(viewResult.Model); }
private async Task Execute(ContactInputModel model) { var apiKey = this.configuration.GetSection("SendGrid:ApiKey").Value; var client = new SendGridClient(apiKey); var message = new SendGridMessage() { From = new EmailAddress(model.Email, model.Name), Subject = model.Subject, PlainTextContent = model.Message, HtmlContent = $"<strong>Hello, SDV Code Administrators!</strong><br />{model.Message}", }; message.AddTo(new EmailAddress("*****@*****.**", "Test User")); var response = await client.SendEmailAsync(message); }
public async Task <IActionResult> Contact(ContactInputModel model) { if (!this.ModelState.IsValid) { return(this.View(model)); } var id = await this.homeService.SaveContact(model); if (id <= 0) { return(this.BadRequest()); } return(this.RedirectToAction("Index")); }
public async Task <IActionResult> Contact(ContactInputModel input) { if (!this.ModelState.IsValid) { return(this.View(input)); } await this.emailSender.SendEmailAsync( RealUserEmailOne, input.Name, OwnersEmail, input.Subject, HttpUtility.HtmlEncode(input.Content)); this.TempData[SuccessNotification] = ContactResponseMessage; return(this.RedirectToAction("Index")); }
public async Task <IActionResult> Index() { if (this.User.Identity.IsAuthenticated == true) { var user = await this.userManager.GetUserAsync(this.User); var email = await this.userManager.GetEmailAsync(user); var viewModel = new ContactInputModel { Name = user.UserName, Email = email }; return(this.View(viewModel)); } return(this.View()); }
public async Task <IActionResult> Contact(ContactInputModel model) { if (!this.ModelState.IsValid) { return(this.View(model)); } await this.contactService.Create(model.Name, model.Email, model.Subject, model.Message); await this.emailSender.SendEmailAsync( model.Email, model.Name, GlobalConstants.SystemEmail, model.Subject, model.Message); return(this.RedirectToAction(nameof(this.ThankYou))); }
public async Task <IActionResult> Contact(ContactInputModel inputModel) { if (!ModelState.IsValid) { return(this.View(inputModel)); } var user = await this.userManager.GetUserAsync(HttpContext.User); var result = await this.messageService.Create(user.Id, inputModel.Name, inputModel.Email, inputModel.Phone, inputModel.Message); if (!result) { //to do: return(this.Redirect("/")); } return(this.Redirect("/")); }
public async Task <ContactResponseModel> SaveContactAsync(ContactInputModel inputModel) { var contact = new Contact() { Name = inputModel.Name, Image = inputModel.Image }; _contactRepo.Add(contact); await _unitOfWork.CommitAsync(); return(new ContactResponseModel { Id = contact.Id, Name = contact.Name, Image = contact.Image }); }
public async Task TestSendMailPopulatedProduct() { // Arrange var service = new MessageService(_configuration, _mockWebHostEnv.Object); var inputModel = new ContactInputModel { SenderName = "test name", SenderEmail = "test email", SenderPhoneNumber = "(111) 222-3333", Subject = "test subject", Message = "test message" }; // Act var result = await service.SendEmail(inputModel); // Assert Assert.True(result); }
public async Task <IActionResult> PostContact([FromBody] ContactInputModel contact) { //In this api we are using this type of model that complicates the code, because swagger generates the // scheme in the documentation more precise with this one if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { ICollection <ContactSkillExpertiseModel> ContactSkillList = new HashSet <ContactSkillExpertiseModel>(); foreach (var item in contact.ContactSkillExpertise) { ContactSkillExpertiseModel ContactSkill = new ContactSkillExpertiseModel(); //ContactSkill.ContactId = item.ContactId; ContactSkill.ExpertiseLvlid = item.ExpertiseLvlid; ContactSkill.SkillId = item.SkillId; ContactSkillList.Add(ContactSkill); } _context.Contact.Add(new ContactModel() { Firstname = contact.Firstname, Lastname = contact.Lastname, Fullname = contact.Fullname, Email = contact.Email, Address = contact.Address, MobileNum = contact.MobileNum, ContactSkillExpertise = ContactSkillList }); await _context.SaveChangesAsync(); } catch (Exception e) { return(BadRequest(e.InnerException.Message)); } return(Ok("Success")); }
public async Task <IActionResult> Contact(ContactInputModel input) { if (!this.ModelState.IsValid) { return(this.View(input)); } await this.contactService.CreateAsync(input); // SendGrid not working with abv.bg var html = new StringBuilder(); html.AppendLine($"<h1>Hello {input.FullName}!</h1>"); html.AppendLine($"<h1>Thank you for contacting us at Coffee Blend.</h1>"); html.AppendLine($"<h1>We will get back to you as soon as possible!</h1>"); html.AppendLine($"<h1>Best regards, Emil Spasov</h1>"); await this.emailSender .SendEmailAsync("*****@*****.**", "CoffeeBlend", input.Email, "Your message has been received:", html.ToString()); return(this.RedirectToAction(nameof(this.SuccessfulContact))); }
public async Task TestSendEmailInputModelOneFieldNotPopulated( string name, string email, string subject, string message) { // Arrange var service = new MessageService(_configuration, _mockWebHostEnv.Object); var inputModel = new ContactInputModel { SenderName = name, SenderEmail = email, Subject = subject, Message = message }; // Act var result = await service.SendEmail(inputModel); // Assert Assert.False(result); }
public async Task <IActionResult> SendMessage(ContactInputModel inputModel) { if (inputModel == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(View("Index", inputModel)); } var messageSuccess = await _messageService.SendEmail(inputModel); if (!messageSuccess) { TempData["MessageFail"] = "There was a problem sending the message. Please try again, or contact the webmaster if the problem persists"; return(View("Index", inputModel)); } return(RedirectToAction("Index", "Home", inputModel)); }
public void SendEmail(ContactInputModel model) { this.Execute(model).Wait(); }
public IActionResult CreateNewContact([FromBody] ContactInputModel contact) { return(Ok(_contactAppService.CreateContact(contact))); }