public ActionResult Contact(ContactForm contactForm)
{
JsonNetResult jsonNetResult = new JsonNetResult();
jsonNetResult.Formatting = Formatting.Indented;
try
{
string subject = "Online Contact From " + contactForm.Name;
string message = contactForm.Message;
message += "\r\n\r\n " + contactForm.Name;
message += "\r\n " + contactForm.EmailAddress;
message += "\r\n " + contactForm.Number;
string sendto = Settings.Default.ContactEmail;
EmailMessage Message = new EmailMessage()
{
Message = message,
Subject = subject,
EmailAddressFrom = contactForm.EmailAddress,
ContactName = contactForm.Name,
EmailAddressTo = sendto
};
Message.SendMessage();
Message = null;
jsonNetResult.Data = new { Result = "success" };
}
catch (Exception ex)
{
jsonNetResult.Data = new { Result = "fail", Message = ex.Message };
}
return jsonNetResult;
}
public ContactForm SaveContactForm(ContactForm form)
{
using (var context = new Data.ContactFormsContext()) {
context.ContactForms.Add(form);
context.SaveChanges();
}
return form;
}
public IHttpActionResult PostEmail(ContactForm contactForm)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var message = _emailService.CreateMailMessage(contactForm);
_emailService.SendEmail(message);
return(Ok());
}
public ActionResult Contact([Bind(Include = "FirstName,LastName,Email,SubjectSelector,Body")] ContactForm contactForm)
{
if (ModelState.IsValid)
{
//ADD EMAIL LOGIC
SmtpMessageChunk.SendContactFormEmail(contactForm);
return(RedirectToAction("Index"));
}
ViewBag.SubjectSelector = contactForm.SubjectSelector;
return(View());
}
/// <summary>
/// Method returns SubmitContactForm view with greetings for the sender.
/// </summary>
/// <param name="contactForm"></param>
/// <returns></returns>
public ActionResult SubmitContactForm(ContactForm contactForm)
{
try
{
return(Content("Hi there!"));
}
catch
{
return(View(contactForm));
}
;
}
public ActionResult ProcessForm(ContactForm data)
{
string msg = "";
msg += data.Message + "\n\n";
msg += "--" + data.FirstName + " " + data.LastName + "\n\n";
SmtpClient client = new SmtpClient();
client.Send(data.Email, "*****@*****.**", data.Subject, msg);
return(View());
}
public ActionResult contactformDelete(int id, ContactForm Cf)
{
ViewBag.Group = "Admin";
try
{
objCF.CommitDelete(id);
return(RedirectToAction("contactformAdmin"));
}
catch
{
return(View());
}
}
public ActionResult HandleFormSubmit(ContactForm model)
{
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
MailMessage message = new MailMessage();
//The recipient's email
message.To.Add("*****@*****.**");
message.Subject = model.Subject;
message.From = new MailAddress(model.Email, model.Name);
message.Body = model.Message;
using (SmtpClient smtp = new SmtpClient())
{
smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
smtp.UseDefaultCredentials = false;
smtp.EnableSsl = true;
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
//Add your own credentials here, otherwise the form won't work
//Those are the credentials for the account that sends the email
smtp.Credentials = new System.Net.NetworkCredential("gmail", "app.password");
// send mail
smtp.Send(message);
TempData["success"] = true;
}
//Get the GuidUdi of the current page
GuidUdi currentPageUdi = new GuidUdi(CurrentPage.ContentType.ItemType.ToString(), CurrentPage.Key);
// Create the new content type
IContent msg = Services.ContentService.CreateContent(model.Subject, currentPageUdi, "message");
msg.SetValue("messageName", model.Name);
msg.SetValue("email", model.Email);
msg.SetValue("subject", model.Subject);
msg.SetValue("messageContent", model.Message);
msg.SetValue("umbracoNaviHide", true);
//Save
Services.ContentService.Save(msg);
return(RedirectToCurrentUmbracoPage());
}
public ActionResult Contact(ContactForm contactForm)
{
if (!ModelState.IsValid)
{
return(View(contactForm));
}
contactForm.Sender = unitOfWork.Users.GetUser(contactForm.SenderId);
unitOfWork.ContactForms.Add(contactForm);
unitOfWork.Complete();
return(View("SuccessContactForm", contactForm));
}
public OkObjectResult SendEmail([FromBody] ContactForm form)
{
string emailBody = string.Empty;
emailBody += "<p>Name: " + form.Name + "</p>";
emailBody += "<p>Email: " + form.Email + "</p>";
emailBody += "<p>Subject: " + form.Subject + "</p>";
emailBody += "<p>Message:" + "</p>";
emailBody += "<p>" + form.Message + "</p>";
SendEmail(emailBody);
return(Ok(new { response = "Email sent sucessful!" }));
}
public async Task <IActionResult> SubmitContactForm([Bind("ContactFormId,Name,UserEmailAddress,Subject,MessageBody")] ContactForm contactForm)
{
if (ModelState.IsValid)
{
bool success = await contactForm.Submit(_context.SystemConfigs.OrderBy(sc => sc.SystemConfigId).Last(), _logger);
if (success)
{
await _context.SaveChangesAsync();
}
}
return(RedirectToAction("Index"));
}
// GET: ContactForms/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ContactForm contactForm = db.form.Find(id);
if (contactForm == null)
{
return(HttpNotFound());
}
return(View(contactForm));
}
// GET: ContactForms/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ContactForm contactForm = _contactFromRepository.GetWhere(x => x.Id == id.Value).FirstOrDefault();
if (contactForm == null)
{
return(HttpNotFound());
}
return(View(contactForm));
}
private EmailQueue GetEmail(string catalog, ContactForm model)
{
var config = new Config(catalog);
return(new EmailQueue
{
AddedOn = DateTime.Now,
FromName = model.Name,
ReplyTo = model.Email,
Subject = model.Subject,
Message = this.GetMessage(catalog, model),
SendTo = config.FromEmail
});
}
public ActionResult Create([Bind(Include = "Id,Name,Email,Message,IsActive,CreationDate,CreateUserId,LastModifiedDate,IsDeleted,DeletionDate,DeleteUserId,Description")] ContactForm contactForm)
{
if (ModelState.IsValid)
{
contactForm.IsDeleted = false;
contactForm.CreationDate = DateTime.Now;
contactForm.Id = Guid.NewGuid();
db.ContactForms.Add(contactForm);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(contactForm));
}
public ActionResult Sales(ContactForm contactForm)
{
ViewBag.Message = "Contact us using the form below!";
if (ModelState.IsValid)
{
// yay, send a sales guy an email
return(RedirectToAction("Thanks"));
}
else
{
return(View("Contact"));
}
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ContactForm contactForm = _repo.Get(id.Value);
if (contactForm == null)
{
return(HttpNotFound());
}
return(PartialView(contactForm));
}
public MailMessage CreateMailMessage(ContactForm model)
{
var mailMessage = new MailMessage
{
Sender = new MailAddress("*****@*****.**"),
From = new MailAddress("*****@*****.**"),
To = { "*****@*****.**" },
Subject = model.Subject,
Body = model.Body,
IsBodyHtml = true
};
return(mailMessage);
}
public ActionResult HandleFormSubmit(ContactForm model)
{
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
TempData["success"] = true;
MailMessage message = new MailMessage();
message.To.Add("*****@*****.**");
message.Subject = model.Subject;
message.From = new MailAddress(model.Email, model.Name);
message.Body = model.Message;
//ensure there is no errors, otherwise display errors if there is
using (SmtpClient smtp = new SmtpClient())
{
smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
smtp.UseDefaultCredentials = false;
smtp.EnableSsl = true;
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.Credentials = new System.Net.NetworkCredential("*****@*****.**", "nxjhkegvwxunkvmo");
// send mail
smtp.Send(message);
}
//Get the GuildUdi of the current page
GuidUdi currentPageUdi = new GuidUdi(CurrentPage.ContentType.ItemType.ToString(), CurrentPage.Key);
//Create the new content type
IContent msg = Services.ContentService.CreateContent(model.Subject, currentPageUdi, "message");
msg.SetValue("messageName", model.Name);
msg.SetValue("email", model.Email);
msg.SetValue("subject", model.Subject);
msg.SetValue("messageContent", model.Message);
msg.SetValue("umbracoNaviHide", true);
//Save
Services.ContentService.Save(msg);
return(RedirectToCurrentUmbracoPage());
}
public ActionResult Contact(ContactFormViewModel vm)
{
var repo = RepositoryFactory.CreateRepository();
var form = new ContactForm
{
Name = vm.Name,
Email = vm.Email,
Message = vm.Message,
DateSent = DateTime.Now
};
repo.AddContactForm(form);
return(RedirectToAction("Index", "Home"));
}
public ActionResult Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ContactForm contactForm = db.ContactForms.Find(id);
if (contactForm == null)
{
return(HttpNotFound());
}
return(View(contactForm));
}
public MailMessage CreateMailMessage(ContactForm contactForm)
{
var mailMessage = new MailMessage
{
Sender = new MailAddress("*****@*****.**"),
From = new MailAddress("*****@*****.**"),
To = { contactForm.Email },
Subject = contactForm.Subject,
Body = contactForm.Body,
IsBodyHtml = true
};
return(mailMessage);
}
public ContactForm AddContactForm(ContactForm form)
{
using (SqlConnection connection = new SqlConnection(Settings.GetConnectionString()))
{
DynamicParameters param = new DynamicParameters();
param.Add("@ContactFormID", dbType: DbType.Int32, direction: ParameterDirection.Output);
param.Add("@Name", form.Name);
param.Add("@Email", form.Email);
param.Add("@Message", form.Message);
connection.Execute("ContactFormAdd", param, commandType: CommandType.StoredProcedure);
form.ContactFormID = param.Get <int>("@ContactFormID");
}
return(form);
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new StatusCodeResult(400));
}
ContactForm contactform = db.ContactForms.Find(id);
if (contactform == null)
{
return(NotFound());
}
return(View(contactform));
}
public IActionResult Get()
{
ContactForm nextQuestion = new ContactForm()
{
Name = "test", Email = "test2"
};
if (nextQuestion == null)
{
return(this.NotFound());
}
return(Ok(nextQuestion));
}
public ActionResult HandleFormSubmit(ContactForm model)
{
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
MailMessage message = new MailMessage();
message.To.Add("*****@*****.**");
message.Subject = model.Subject;
message.From = new MailAddress(model.Email, model.Name);
message.Body = model.Message;
using (SmtpClient smtp = new SmtpClient())
{
smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
smtp.UseDefaultCredentials = false;
smtp.EnableSsl = true;
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.Credentials = new System.Net.NetworkCredential("*****@*****.**", "yquqdmowgzpfkxpv");
smtp.EnableSsl = true;
// send mail
try
{
smtp.Send(message);
TempData["success"] = true;
}
catch (SmtpException ex)
{
var Message = ex.Message.ToString();
// ex.FailedRecipient and ex.GetBaseException() should give you enough info.
}
}
//saving the message
IContent comment = Services.ContentService.CreateContent(model.Subject, CurrentPage.Id, "messages");
comment.SetValue("vmname", model.Name);
comment.SetValue("email", model.Email);
comment.SetValue("subject", model.Subject);
comment.SetValue("message", model.Message);
//save
Services.ContentService.Save(comment);
return(RedirectToCurrentUmbracoPage());
}
public ActionResult HandleFormSubmit(ContactForm model)
{
if (!ModelState.IsValid)
{
return(CurrentUmbracoPage());
}
//Send email message
//The method data receives the data as an object of type ContactForm
MailMessage message = new MailMessage();
message.To.Add("*****@*****.**");
message.Subject = model.Subject;
message.From = new MailAddress(model.Email, model.Name);
message.Body = model.Message;
//Send the message as an email
using (SmtpClient smtp = new SmtpClient())
{
smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
smtp.UseDefaultCredentials = false;
smtp.EnableSsl = true; smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
//Removed Network credentials
smtp.Credentials = new System.Net.NetworkCredential("", "");
// send mail
smtp.Send(message);
}
//Display a message to the user in case of success
TempData["success"] = true;
//Get the GuildUdi of the current page
GuidUdi currentPageUdi = new GuidUdi(CurrentPage.ContentType.ItemType.ToString(), CurrentPage.Key);
//Create the new content type with parameters: string name, Udi parentId , string contentTypeAlias
IContent msg = Services.ContentService.CreateContent(model.Subject, currentPageUdi, "message");
msg.SetValue("messageName", model.Name);
msg.SetValue("email", model.Email);
msg.SetValue("subject", model.Subject);
msg.SetValue("messageContent", model.Message);
msg.SetValue("umbracoNaviHide", true);
//Save
Services.ContentService.Save(msg);
//declare a method that receives form input and send the page back to the client
return(RedirectToCurrentUmbracoPage());
}
public async Task CreateAsync(string name, string email, string title, string content)
{
var contactForm = new ContactForm
{
Name = name,
Email = email,
Title = title,
Content = content,
};
await this.contactFormRepository.AddAsync(contactForm);
await this.contactFormRepository.SaveChangesAsync();
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ContactForm contactForm = _contactFormRepository.GetById(id.Value);
if (contactForm == null)
{
return(HttpNotFound());
}
return(View(contactForm));
}
public ActionResult Create(ContactForm contactForm)
{
if (ModelState.IsValid)
{
contactForm.SendTime = DateTime.Now;
_contactFormRepository.Create(contactForm);
var message = _sendEmail.CreateMailMessage(contactForm);
_sendEmail.SendEmail(message);
message = _sendEmail.CreateMailMessage(contactForm, true);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(contactForm));
}
public IActionResult Contact(ContactForm c)
{
if (ModelState.IsValid)
{
// save to database
if (c.Name != null)
{
contactRepo.AddMessage(c);
}
// send to view
ViewBag.Message = c;
}
return(View());
}
/// <summary>
/// Insert new contact form to database
/// </summary>
/// <param name="contactForm"></param>
public void AddContactForm(ContactForm contactForm)
{
try
{
if (contactForm == null)
{
throw new ArgumentNullException($"Empty Contact form contents");
}
this._RepositoryContactformService.Add(contactForm);
}
catch (Exception ex)
{
throw new Exception($"Empty form: {ex.Message}");
}
}
public ContactForm Create(string name, string email, string subject, string message, string ip)
{
ContactForm dbContactForm = new ContactForm()
{
Name = name,
Email = email,
Subject = subject,
Message = message,
Ip = ip
};
this.contactFormRepos.Add(dbContactForm);
this.contactFormRepos.Save();
return dbContactForm;
}
public JsonResult ContactFormPost(ContactForm form)
{
string subject = "New Contact Form Notification";
string sendMessageTo = "*****@*****.**";
string messageFrom = "*****@*****.**";
string smtpCredential = "mail.domain.com";
string smtpCredentialLogin = "******";
string smtpPassword = "******";
var result = new JsonResult() { JsonRequestBehavior = JsonRequestBehavior.AllowGet };
// Check Captcha
if (Session["qaptcha_key"] != null)
{
var sb = new StringBuilder();
sb.Append("Name : " + form.name + "<br />");
sb.Append("Contact Email : " + form.contactEmail + "<br />");
sb.Append("Subject : " + form.subject + "<br /><br />");
sb.Append("Comments : " + form.message + "<br />");
// Send Form Data
try
{
var msg = new MailMessage();
msg.Body = sb.ToString();
msg.IsBodyHtml = true;
msg.From = new MailAddress(messageFrom);
msg.Subject = subject;
msg.To.Add(sendMessageTo);
var smtp = new SmtpClient(smtpCredential);
smtp.Credentials = new NetworkCredential(smtpCredentialLogin, smtpPassword);
smtp.Port = 25;
smtp.Send(msg);
}
catch (Exception e)
{
Log.Warn("Failed to send email", e);
}
}
return result;
}
public ActionResult HandleContactForm(ContactFormViewModel model)
{
//Check if data posted from form in model is valid
if (!ModelState.IsValid)
{
//Not valid return to the form with the values the user entered
return CurrentUmbracoPage();
}
//Get settings off current node (CWS-Contact-Form) node
var emailTo = CurrentPage.GetPropertyValue("emailAddressTo", "*****@*****.**").ToString();
var emailSubject = CurrentPage.GetPropertyValue("emailSubject", "CWS Contact Form Request").ToString();
//Send out email
EmailHelper.SendContactEmail(model, emailTo, emailSubject);
//Now let's add it to our DB table using the magical PetaPoco for a handy log
var db = ApplicationContext.DatabaseContext.Database;
//Create a new PetaPoco object representing our DB table
var logEntry = new ContactForm();
logEntry.Date = DateTime.Now;
logEntry.Name = model.Name;
logEntry.Email = model.Email;
logEntry.Message = model.Message;
try
{
//Insert the record into the DB
db.Insert(logEntry);
}
catch (Exception ex)
{
//Throw an exception if there is a problem adding the item to the DB table for logging with PetaPoco
throw ex;
}
//Update success flag (in a TempData key)
TempData["IsSuccessful"] = true;
//All done - lets redirect to the current page & show our thanks/success message
return RedirectToCurrentUmbracoPage();
}
private IDnaDataReader MockedSetCommentForumAsContactForm(ContactForm newContactFormDetails)
{
IDnaDataReader mockedDataReader = mocks.StrictMock<IDnaDataReader>();
mockedDataReader.Stub(x => x.AddParameter("forumid", newContactFormDetails.ForumID)).Return(mockedDataReader);
mockedDataReader.Stub(x => x.AddParameter("contactemail", newContactFormDetails.ContactEmail)).Return(mockedDataReader);
mockedDataReader.Stub(x => x.Execute()).Return(mockedDataReader);
mockedDataReader.Stub(x => x.Dispose());
return mockedDataReader;
}
private IDnaDataReader MockedCreateCommentForum(ContactForm newContactFormDetails, int expectedForumId)
{
IDnaDataReader mockedDataReader = mocks.StrictMock<IDnaDataReader>();
mockedDataReader.Stub(x => x.AddParameter("uid", newContactFormDetails.Id)).Return(mockedDataReader);
mockedDataReader.Stub(x => x.AddParameter("url", newContactFormDetails.ParentUri)).Return(mockedDataReader);
mockedDataReader.Stub(x => x.AddParameter("title", newContactFormDetails.Title)).Return(mockedDataReader);
mockedDataReader.Stub(x => x.AddParameter("sitename", newContactFormDetails.SiteName)).Return(mockedDataReader);
mockedDataReader.Stub(x => x.AddParameter("moderationstatus", (int)newContactFormDetails.ModerationServiceGroup)).Return(mockedDataReader);
mockedDataReader.Stub(x => x.Execute()).Return(mockedDataReader);
mockedDataReader.Stub(x => x.Read()).Return(true);
mockedDataReader.Stub(x => x.GetInt32NullAsZero("forumid")).Return(expectedForumId);
mockedDataReader.Stub(x => x.Dispose());
return mockedDataReader;
}
private IDnaDataReader MockedGetContactFormDetailFromFormID(ContactForm newContactFormDetails, bool exists)
{
IDnaDataReader mockedDataReader = mocks.StrictMock<IDnaDataReader>();
mockedDataReader.Stub(x => x.AddParameter("contactformid", newContactFormDetails.Id)).Return(mockedDataReader);
mockedDataReader.Stub(x => x.AddParameter("sitename", newContactFormDetails.SiteName)).Return(mockedDataReader);
mockedDataReader.Stub(x => x.Execute()).Return(mockedDataReader);
mockedDataReader.Stub(x => x.HasRows).Return(exists);
if (exists)
{
mockedDataReader.Stub(x => x.Read()).Return(true);
mockedDataReader.Stub(x => x.GetString("contactemail")).Return(newContactFormDetails.ContactEmail);
mockedDataReader.Stub(x => x.GetInt32("forumid")).Return(newContactFormDetails.ForumID);
mockedDataReader.Stub(x => x.GetString("contactformuid")).Return(newContactFormDetails.Id);
mockedDataReader.Stub(x => x.GetString("parenturi")).Return(newContactFormDetails.ParentUri);
mockedDataReader.Stub(x => x.GetString("title")).Return(newContactFormDetails.Title);
mockedDataReader.Stub(x => x.GetInt32("NotSignedInUserId")).Return(newContactFormDetails.NotSignedInUserId);
}
mockedDataReader.Stub(x => x.Dispose());
return mockedDataReader;
}
public void ShouldCreateNewContactFormWhenGivenValidContactFormDetails()
{
string expectedTitle = "testcontactform";
string expectedParentUri = "http://local.bbc.co.uk/dna/h2g2";
string expectedId = "newcontactform" + DateTime.Now.Ticks.ToString();
string expectedContactEmail = "*****@*****.**";
string expectedSiteName = "h2g2";
ModerationStatus.ForumStatus expectedModerationStatus = ModerationStatus.ForumStatus.Reactive;
ISite mockedSite = mocks.StrictMock<ISite>();
mockedSite.Stub(x => x.EditorsEmail).Return("*****@*****.**");
mockedSite.Stub(x => x.SiteName).Return(expectedSiteName);
ISiteList mockedSiteList = mocks.DynamicMock<ISiteList>();
mockedSiteList.Stub(x => x.GetSite(expectedSiteName)).Return(mockedSite);
ContactForm newContactFormDetails = new ContactForm();
newContactFormDetails.ContactEmail = expectedContactEmail;
newContactFormDetails.Title = expectedTitle;
newContactFormDetails.ParentUri = expectedParentUri;
newContactFormDetails.Id = expectedId;
newContactFormDetails.ModerationServiceGroup = expectedModerationStatus;
newContactFormDetails.SiteName = expectedSiteName;
newContactFormDetails.NotSignedInUserId = 0;
IDnaDataReader mockedDataReader1 = MockedGetContactFormDetailFromFormID(newContactFormDetails, false);
int expectedForumId = 789654123;
IDnaDataReader mockedDataReader2 = MockedCreateCommentForum(newContactFormDetails, expectedForumId);
newContactFormDetails.ForumID = expectedForumId;
IDnaDataReader mockedDataReader3 = MockedSetCommentForumAsContactForm(newContactFormDetails);
IDnaDataReader mockedDataReader4 = MockedGetContactFormDetailFromFormID(newContactFormDetails, true);
Queue<IDnaDataReader> mockedReaders = new Queue<IDnaDataReader>();
mockedReaders.Enqueue(mockedDataReader1);
mockedReaders.Enqueue(mockedDataReader4);
IDnaDataReaderCreator mockerDataReaderCreator = mocks.StrictMock<IDnaDataReaderCreator>();
mockerDataReaderCreator.Expect(x => x.CreateDnaDataReader("getcontactformdetailfromformid")).Return(mockedDataReader1);
mockerDataReaderCreator.Expect(x => x.CreateDnaDataReader("getcontactformdetailfromformid")).Return(mockedDataReader4);
mockerDataReaderCreator.Stub(x => x.CreateDnaDataReader("commentforumcreate")).Return(mockedDataReader2);
mockerDataReaderCreator.Stub(x => x.CreateDnaDataReader("setcommentforumascontactform")).Return(mockedDataReader3);
ICallingUser mockedUser = mocks.StrictMock<ICallingUser>();
mockedUser.Stub(x => x.IsUserA(UserTypes.Editor)).Return(true);
Contacts contacts = new Contacts(null, mockerDataReaderCreator, null, mockedSiteList);
contacts.CallingUser = mockedUser;
mocks.ReplayAll();
ContactForm createdContactForm = contacts.CreateContactForm(newContactFormDetails, mockedSiteList.GetSite("h2g2"));
Assert.AreEqual(expectedContactEmail, createdContactForm.ContactEmail);
Assert.AreEqual(expectedForumId, createdContactForm.ForumID);
Assert.AreEqual(expectedId, createdContactForm.Id);
Assert.AreEqual(expectedParentUri, createdContactForm.ParentUri);
Assert.AreEqual(expectedTitle, createdContactForm.Title);
Assert.AreEqual(expectedSiteName, createdContactForm.SiteName);
mocks.VerifyAll();
}
public void ShouldThrowInvalidContactEmailExceptionWhenCreatingANewFormGivenAnInvalidContactEmailAddress()
{
string sitename = "h2g2";
ISite mockedSite = mocks.StrictMock<ISite>();
mockedSite.Stub(x => x.SiteName).Return(sitename);
ContactForm form = new ContactForm() { Id = "doesnotexist", SiteName = sitename, ContactEmail = "invalid.email@crapemailaddress" };
IDnaDataReader mockedDataReader = MockedGetContactFormDetailFromFormID(form, false);
IDnaDataReaderCreator mockerDataReaderCreator = mocks.StrictMock<IDnaDataReaderCreator>();
mockerDataReaderCreator.Expect(x => x.CreateDnaDataReader("getcontactformdetailfromformid")).Return(mockedDataReader);
Contacts contacts = new Contacts(null, mockerDataReaderCreator, null, null);
ICallingUser mockedUser = mocks.StrictMock<ICallingUser>();
mockedUser.Stub(x => x.IsUserA(UserTypes.Editor)).Return(true);
contacts.CallingUser = mockedUser;
mocks.ReplayAll();
try
{
ContactForm createdContactForm = contacts.CreateContactForm(form, mockedSite);
}
catch (ApiException ex)
{
Assert.AreEqual(ApiException.GetError(ErrorType.InvalidContactEmail).Message, ex.Message);
throw ex;
}
}
public void ShouldThrowNotAuthorizedExceptionWhenCreatingANullCallingUser()
{
string sitename = "h2g2";
ISite mockedSite = mocks.StrictMock<ISite>();
mockedSite.Stub(x => x.SiteName).Return(sitename);
ContactForm form = new ContactForm() { Id = "doesnotexist", SiteName = sitename };
IDnaDataReader mockedDataReader = MockedGetContactFormDetailFromFormID(form, false);
IDnaDataReaderCreator mockerDataReaderCreator = mocks.StrictMock<IDnaDataReaderCreator>();
mockerDataReaderCreator.Expect(x => x.CreateDnaDataReader("getcontactformdetailfromformid")).Return(mockedDataReader);
Contacts contacts = new Contacts(null, mockerDataReaderCreator, null, null);
mocks.ReplayAll();
try
{
ContactForm createdContactForm = contacts.CreateContactForm(form, mockedSite);
}
catch (ApiException ex)
{
Assert.AreEqual(ApiException.GetError(ErrorType.NotAuthorized).Message, ex.Message);
throw ex;
}
}
public void ShouldDeserialiseToContactFormMessageString()
{
ContactForm contactForm = new ContactForm();
contactForm.Id = "FirstContactForm_111";
contactForm.ParentUri = "http://local.bbc.co.uk/dna/h2g2";
contactForm.Title = "FirstContactForm+1";
contactForm.contactDetailsList = new ContactDetailsList();
contactForm.contactDetailsList.contacts = new List<ContactDetails>();
ContactDetails contactDetail = new ContactDetails();
contactForm.contactDetailsList.contacts.Add(contactDetail);
ContactFormMessage msg = new ContactFormMessage();
msg.Subject = "testing Subject";
msg.Body = new Dictionary<string, string>();
msg.Body.Add("Your Email","*****@*****.**");
msg.Body.Add("Your Suggestions","Improve the contact form");
msg.Body.Add("Your Favourite Social Network","facebook");
msg.Body.Add("Favourite BBC site","sport");
msg.Body.Add("Gender","m");
contactDetail.text = StringUtils.SerializeToJsonReturnAsString(msg);
string stringContactForm = StringUtils.SerializeToJsonReturnAsString(contactForm);
string body = "";
ContactFormMessage message = (ContactFormMessage)StringUtils.DeserializeJSONObject(contactDetail.text, typeof(ContactFormMessage));
string subject = message.Subject;
foreach (KeyValuePair<string, string> content in message.Body.ToList<KeyValuePair<string, string>>())
{
string messageLine = content.Key + " : " + content.Value + "\n";
body += messageLine;
}
}
private void CreateForm()
{
var webForm = System.Web.HttpContext.Current.Request.Form;
Form = new ContactForm();
Form.ContactFormUId = Guid.NewGuid().ToString();
Form.CreateDate = DateTime.Now.ToUniversalTime();
Form.TargetEmail = TargetEmail;
Form.Subject = webForm["subject"];
Form.ContactEmail = webForm["contactEmail"];
Form.ContactName = webForm["contactName"];
Form.ContactPersonalId = webForm["contactPersonalId"];
Form.ContactPersonalId2 = webForm["contactPersonalId2"];
Form.ContactCountry = webForm["contactCountry"];
Form.ContactState = webForm["contactState"];
Form.ContactCity = webForm["contactCity"];
Form.Message = webForm["message"];
if (webForm["message"] != null && webForm["message"].Length > 150)
Form.ShortMessage = webForm["message"].Substring(0, 150);
else
Form.ShortMessage = webForm["message"];
}
