public async Task<IActionResult> Post(ContactRequest request)
{
await
_emailService.Send("*****@*****.**", "Message from vaerenberg.com",
JsonConvert.SerializeObject(request));
return Ok();
}
public void Send_InvalidRequest_PopulatesError()
{
var controller = new ContactController();
PrepareController(controller);
var invalidRequest = new ContactRequest();
controller.Index(invalidRequest);
Assert.NotNull(controller.PropertyBag["error"]);
}
public void Send_InvalidRequest_EmailIsNotSent()
{
var controller = new ContactController();
PrepareController(controller);
var invalidRequest = new ContactRequest();
controller.Index(invalidRequest);
Assert.Equal(0, ((StubEngineContext)Context).MessagesSent.Count);
}
public void Contact_WithoutEmail_IsInvalid()
{
// arrange
var request = new ContactRequest { Name = "a", Message = "aaa" };
// act
var results = ValidateModel(request);
// assert
Assert.Equal("Email", results[0].MemberNames.First());
}
public async Task Contact_WithValidRequest_SendsMessageThroughEmailService()
{
// arrange
var request = new ContactRequest { Name = "a", Email = "*****@*****.**", Message = "aaa" };
var emailService = new FakeEmailService();
var sut = new ContactController(emailService);
// act
await sut.Post(request);
// assert
Assert.Equal(1, emailService.SendCallCount);
}
public void Contact_WithNameTooLong_IsInvalid()
{
// arrange
var request = new ContactRequest
{
Name = new string('a', 1000),
Email = "*****@*****.**",
Message = "aaa"
};
// act
var results = ValidateModel(request);
// assert
Assert.Equal("Name", results[0].MemberNames.First());
}
public static EmailMessage CreateEmailMessageToNeal(ContactRequest contactRequest)
{
return(new EmailMessage
{
FromAddresses = new List <EmailAddress> {
new EmailAddress {
Address = "*****@*****.**", Name = "Neal Thomas"
}
},
ToAddresses = new List <EmailAddress> {
new EmailAddress {
Address = "*****@*****.**", Name = "Neal Thomas"
}
},
Subject = "Request Received",
BodyHtml = GetEmailTemplate(contactRequest)
});
}
public async Task <bool> SendContactNotification(ContactRequest request)
{
var contactEmail = _config["AppSettings:ContactEmail"];
var to = new List <string> {
contactEmail
};
var client = new TransactionalEmailClient(_config);
await client.SendEmail(
to,
"Contact Form: " + request.subject,
request.message,
"",
"Contact");
return(true);
}
public IActionResult Put(int id, ContactRequest contactRequest)
{
var existingContactRequest = _contactRequestRepository.Get(id);
if (existingContactRequest == null)
{
return(NotFound());
}
existingContactRequest.FirstName = contactRequest.FirstName;
existingContactRequest.LastName = contactRequest.LastName;
existingContactRequest.Mail = contactRequest.Mail;
existingContactRequest.Text = contactRequest.Text;
_contactRequestRepository.Update(existingContactRequest);
return(NoContent());
}
public void BlockUser(User blocker, User blocked)
{
// Validate
blocker.Should().NotBeNull();
blocked.Should().NotBeNull();
if (!IsUserBlocked(blocked, blocker))
{
DateTime now = DateTime.UtcNow;
if (_contactService.IsUserContact(blocker, blocked))
{
// The users are contacts so delete the connection
Contact contact = _contactService.GetUserContact(blocker, blocked);
_contactService.DeleteContact(contact);
}
else
{
// The users are not contacts but there may be an active request, so delete if necessary
if (_contactRequestService.HasActiveContactRequest(blocker, blocked))
{
ContactRequest contactRequest = _contactRequestService.GetContactRequestsFromUserToUser(blocker, blocked).Where(r => r.IsActive()).First();
_contactRequestService.CancelContactRequest(blocker, contactRequest);
}
else if (_contactRequestService.HasActiveContactRequest(blocked, blocker))
{
ContactRequest contactRequest = _contactRequestService.GetContactRequestsFromUserToUser(blocked, blocker).Where(r => r.IsActive()).First();
_contactRequestService.CancelContactRequest(blocker, contactRequest);
}
}
// Block and save
_context.BlockedUsers.Add(new BlockedUser
{
BlockerUID = blocker.Id,
BlockedUID = blocked.Id,
CreatedUID = blocker.Id,
CreatedDateUtc = now,
ModifiedUID = blocker.Id,
ModifiedDateUtc = now
});
_context.SaveChanges();
}
}
public async Task ReturnCreated()
{
// Arrange
var contact = new ContactRequest("John", "Doe");
// Act
var response = await Client.PostAsJsonAsync("/contacts", contact);
// Assert
response.StatusCode.ShouldBe(HttpStatusCode.Created);
response.Content.Headers.ContentType.MediaType.ShouldBe("application/json");
var contactResponse = await response.Content.ReadAsJsonAsync <ContactResponse>();
response.Headers.Location.ToString().ShouldBe($"/contacts/{contactResponse.Id}");
contactResponse.Id.ShouldNotBe(0);
contactResponse.FirstName.ShouldBe(contact.FirstName);
contactResponse.Surname.ShouldBe(contact.Surname);
}
public async Task <Response> Handle(Request request, CancellationToken cancellationToken)
{
var contactRequest = await _context.ContactRequests.FindAsync(request.ContactRequest.ContactRequestId);
if (contactRequest == null)
{
contactRequest = new ContactRequest();
_context.ContactRequests.Add(contactRequest);
}
contactRequest.Name = request.ContactRequest.Name;
await _context.SaveChangesAsync(cancellationToken);
return(new Response()
{
ContactRequestId = contactRequest.ContactRequestId
});
}
public async Task <IActionResult> Add([FromBody] ContactRequest request)
{
if (!ModelState.IsValid)
{
return(Ok(ModelState));
}
var response = new BaseResponse <Guid>();
if (!await GoogleRecaptchaHelper.IsReCaptchaPassedAsync(request.CaptchaToken, "6Ldt7KEUAAAAAL_gnq4ORX4NrKDK3qegm1TSyBAg"))
{
response.Message = "Lütfen robot olmadığınızı doğrulayın.";
return(Ok(response));
}
var item = new Contact
{
FullName = request.Name,
Email = request.Email,
PhoneNumber = request.PhoneNumber,
Message = request.Message
};
contactRepo.Add(item);
response.Message = "Kayıt başarıyla eklenmiştir.";
response.Data = item.Id;
var MailBody = "HepsiSef bize ulaşın" + "\n " + "isim:" + " " + item.FullName + "\n" + "email:" + " " + item.Email + "\n" + "telefon no:" + " " + item.PhoneNumber + "\n" + "mesaj:" + " " + item.Message;
List <AdminMailMM> Admins = new List <AdminMailMM>();
Admins = userRepo.GetBy(x => x.Role == Role.Admin).Select(x => new AdminMailMM
{
Email = x.Email
}).ToList();
foreach (var mail in Admins)
{
MailManager.Send(MailBody, mail.Email);
}
return(Ok(response));
}
public void InformAboutContactRequest(ContactRequest contactRequest, string url)
{
StringBuilder sb = new StringBuilder();
sb
.AppendLine("Hallo")
.AppendLine()
.AppendLine($"Auf pff19.ch ist eine neue Kontaktanfrage eingegangen von: {contactRequest.FirstName} {contactRequest.LastName} ({contactRequest.Mail})")
.AppendLine($"Link zur Anfrage: {url}")
.AppendLine()
.AppendLine("********************************************************************")
.AppendLine()
.AppendLine(contactRequest.Text)
.AppendLine()
.AppendLine("********************************************************************")
.AppendLine()
.AppendLine("Dieses Email wurde automatisch generiert, bitte antworte nicht darauf.");
SendMail(_configuration["Mail:ContactRequestReceiver"], "Pff19: Neue Kontaktanfrage", sb.ToString());
}
// PUT: api/Contact/5
public IHttpActionResult PutContact(int id, [FromBody] ContactRequest contact)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
int result = _repo.EditContact(id, contact);
if (result == 0)
{
return(NotFound());
}
else if (result == -1)
{
return(BadRequest("Duplicate data found."));
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task POST_Contact_Success()
{
string externalIdentifier = "postContactSuccess01";
ContactTestData testData = new ContactTestData
{
ExternalIdentifier = externalIdentifier,
AccountMasterExtId = "accountMasterExtId01"
};
//create an accountmaster first
AccountMasterRequest accountMasterRequest = new AccountMasterRequest
{
Identifier = testData.AccountMasterExtId,
CreateAccount = true,
IsWebEnabled = true,
CreatedBy = "post request 01",
Name = "temporal AM"
};
var accountMasterResponse = await Client.AccountMasters.Create(accountMasterRequest);
ContactRequest request = new ContactRequest
{
CreatedBy = "post request 01",
ExternalIdentifier = externalIdentifier,
AccountMasterExtId = accountMasterRequest.Identifier,
ContactEmail = "*****@*****.**",
FirstName = "john",
LastName = "doe",
PhoneNumber = "1234567890"
};
HttpResponseExtended <ContactResponse> response = await Client.Contacts.Create(request);
//validations
Assert.IsNotNull(response, "Response object should not be null");
Assert.AreEqual(200, response.StatusCode);
Assert.IsNotNull(response.Result, "Result object should not be null");
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task <IActionResult> Edit(short id, [Bind("RequestId,RequestDate,RequestText,Id")] ContactRequest contactRequest)
{
try
{
if (id != contactRequest.RequestId)
{
return(NotFound());
}
// Préparation de l'appel à l'API
string accessToken = await HttpContext.GetTokenAsync("access_token");
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
string content = await client.GetStringAsync(_configuration["URLAPI"] + $"api/ContactRequests/{id}");
ContactRequest oldContactRequest = JsonConvert.DeserializeObject <ContactRequest>(content);
if (oldContactRequest == null)
{
return(NotFound());
}
contactRequest.Id = oldContactRequest.Id;
contactRequest.RequestDate = oldContactRequest.RequestDate;
// Préparation de la requête update à l'API
StringContent httpContent = new StringContent(contactRequest.ToJson(), Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PutAsync(_configuration["URLAPI"] + $"api/UserContactRequests/{id}", httpContent);
if (response.StatusCode != HttpStatusCode.NoContent)
{
return(BadRequest());
}
return(RedirectToAction(nameof(Index)));
}
catch (HttpRequestException e)
{
return(Unauthorized());
}
}
// SEARCH
public static List <ContactRequest> Search(ContactRequestSearchRequest model, out int totalRows)
{
List <ContactRequest> list = null;
int r = 0;
DataProvider.ExecuteCmd(GetConnection, "dbo.ContactRequest_Search"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@SearchStr", model.SearchString);
paramCollection.AddWithValue("@CurrentPage", model.CurrentPage);
paramCollection.AddWithValue("@ItemsPerPage", model.ItemsPerPage);
}
, map : delegate(IDataReader reader, short set)
{
switch (set)
{
case 0: //first result set
ContactRequest p = new ContactRequest();
int startingIndex = 0; //startingOrdinal
p.Id = reader.GetInt32(startingIndex++);
p.Name = reader.GetSafeString(startingIndex++); //extension method
p.Email = reader.GetSafeString(startingIndex++);
p.Message = reader.GetSafeString(startingIndex++);
p.Notes = reader.GetSafeString(startingIndex++);
r = reader.GetSafeInt32(startingIndex++);
if (list == null)
{
list = new List <ContactRequest>();
}
list.Add(p);
break;
}
}
);
totalRows = r;
return(list);
}
public void Insert(ContactRequest request)
{
using (var cn = new SqlConnection())
{
cn.ConnectionString = Settings.GetConnectionString();
var parameters = new DynamicParameters();
parameters.Add("@ContactRequestId", dbType: DbType.Int32, direction: ParameterDirection.Output);
parameters.Add("@Name", request.Name);
parameters.Add("@Email", request.Email);
parameters.Add("@Phone", request.Phone);
parameters.Add("@Message", request.Message);
cn.Execute("InsertContactRequest",
parameters,
commandType: CommandType.StoredProcedure);
request.ContactRequestId = parameters.Get <int>("@ContactRequestId");
}
}
// POST: api/Contact
public IHttpActionResult PostContact([FromBody] ContactRequest contact)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
int contactId = _repo.AddContact(contact);
if (contactId == 0)
{
return(BadRequest("Recored not created"));
}
else if (contactId == -1)
{
return(BadRequest("Duplicate data found."));
}
return(CreatedAtRoute("DefaultApi", new { id = contactId }, contact));
}
public ActionResult GetByID(int entryid)
{
IDbConnection dbConn = new OrmliteConnection().openConn();
try
{
var data = ContactRequest.GetById(entryid, null, false);
var ref_Roles = CustomModel.GetActiveStatus();
return(Json(new
{
success = true,
data = data
}));
}
catch (Exception e)
{
return(Json(new { success = false, message = e.Message }));
}
finally { dbConn.Close(); }
}
public async Task ReturnOkGivenUpdatedFirstNameAndSurname()
{
// Arrange
var contact = contactService.Add("John", "Doe");
var contactToUpdate = new ContactRequest("Dane", "Kane");
// Act
var response = await Client.PutAsJsonAsync($"contacts/{contact.Id}", contactToUpdate);
// Assert
response.StatusCode.ShouldBe(HttpStatusCode.OK);
response.Content.Headers.ContentType.MediaType.ShouldBe("application/json");
var contactResponse = await response.Content.ReadAsJsonAsync <ContactResponse>();
contactResponse.Id.ShouldBe(contact.Id);
contactResponse.FirstName.ShouldBe(contactResponse.FirstName);
contactResponse.Surname.ShouldBe(contactResponse.Surname);
}
public void Update(ContactRequest value)
{
using (var scope = _dbContextScopeFactory.Create())
{
var dbContext = scope.DbContexts
.Get <ApplicationDbContext>();
var existed = dbContext.Set <ContactRequest>().SingleOrDefault(t => t.ID == value.ID);
existed.CreatedDate = value.CreatedDate;
existed.Company = value.Company;
existed.Email = value.Email;
existed.FirstName = value.FirstName;
existed.LastName = value.LastName;
existed.Message = value.Message;
existed.Phone = value.Phone;
scope.SaveChanges();
}
}
public void SendEmail(ContactRequest contactRequest)
{
ProcessStartInfo start = new ProcessStartInfo();
start.FileName = "C:/Python39/python.exe";
string cmd = "D:/Clients/FF/Website/firebirdfrankiefoundrywebsite/FirebirdFrankieFoundryAPI/Services/EmailSender.py";
string args = $"\"{contactRequest.Name}\" \"{contactRequest.Category}\" \"{contactRequest.Email}\" \"{contactRequest.PhoneNumber}\" \"{contactRequest.CompanyName}\" \"{contactRequest.Message}\"";
start.Arguments = string.Format("{0} {1}", cmd, args);
start.UseShellExecute = false;
start.RedirectStandardOutput = true;
using (Process process = Process.Start(start))
{
using (StreamReader reader = process.StandardOutput)
{
string result = reader.ReadToEnd();
Console.Write(result);
}
}
}
public void SortAndLimit()
{
using (var client = TestHelper.ClientGet())
{
var contactRequest = new ContactRequest
{
// Because of upstream issue CRM-15905, you cannot search contacts on 'id'.
// A workaround is writing 'contact_a.id'.
// https://issues.civicrm.org/jira/browse/CRM-15905
ApiOptions = new ApiOptions {
Sort = "contact_a.id DESC", Limit = 2
}
};
var result = client.ContactGet(TestHelper.ApiKey, TestHelper.SiteKey, contactRequest);
Assert.AreEqual(0, result.IsError);
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.Values.First().Id > result.Values.Last().Id);
}
}
public void ReturnOkGivenUpdatedFirstNameAndSurname()
{
// Arrange
var contactRequest = new ContactRequest("Dan", "Kane");
contactService
.Setup(mock => mock.Update(42, contactRequest.FirstName, contactRequest.Surname))
.Returns(new Contact(42, contactRequest.FirstName, contactRequest.Surname));
// Act
var result = controller.Put(42, contactRequest);
// Assert
var okResult = result.ShouldBeOfType <OkObjectResult>();
var contactResponse = okResult.Value.ShouldBeOfType <ContactResponse>();
contactResponse.Id.ShouldBe(42);
contactResponse.FirstName.ShouldBe(contactResponse.FirstName);
contactResponse.Surname.ShouldBe(contactResponse.Surname);
}
private ContactResponse Update(string uid, ContactModel model)
{
ContactResponse Contact = new ContactResponse();
string url = string.Format(GetUrl(UrlType.Contact, UrlSubType.ContactById), uid);
ContactRequest request = new ContactRequest()
{
Properties = model.ToProperties()
};
Synergy.Common.Request.WebClient client = new Synergy.Common.Request.WebClient();
HttpWebResponse response = client.Post(JsonConvert.SerializeObject(request), url, AuthorizationHeader.GetAuthorizationToken(_AccessToken.Accesstoken), EnumUtilities.GetDescriptionFromEnumValue(ContentTypes.JSON));
if (response.StatusCode == HttpStatusCode.OK)
{
var responseStream = response.GetResponseStream();
StreamReader streamReader = new StreamReader(responseStream);
string rawResponse = streamReader.ReadToEnd();
Contact = JsonConvert.DeserializeObject <ContactResponse>(rawResponse);
}
return(Contact);
}
public async Task <IActionResult> UpdateContact(int id, [FromBody] ContactRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var contact = await _contactRepository.Get(id);
if (contact == null)
{
return(NotFound());
}
_mapper.Map <ContactRequest, Contact>(request, contact);
await _unitOfWork.Complete();
var result = _mapper.Map <Contact, ContactResponse>(contact);
return(Ok(result));
}
public async Task <bool> AddContactRequest(ProductListingData productListing, Users user)
{
try
{
ContactRequest contactRequest = await(from req in _ApnaAaharContext.ContactRequest where req.ProductListingId == productListing.ProductListingId && req.BuyerId == user.UserId select req).FirstOrDefaultAsync();
if (contactRequest == null)
{
await _ApnaAaharContext.ContactRequest.AddAsync(new ContactRequest()
{
BuyerId = user.UserId, ProductListingId = productListing.ProductListingId
});
}
}
catch (Exception)
{
throw new DataNotSavedException();
}
int results = await _ApnaAaharContext.SaveChangesAsync();
return((results > 0) ? true : false);
}
public ActionResult Create(ContactRequest item)
{
IDbConnection db = new OrmliteConnection().openConn();
try
{
item.entryname = item.entryname ?? "";
item.entrycode = item.entrycode ?? "";
item.address = item.address ?? "";
//if (string.IsNullOrEmpty(item.entryname) || string.IsNullOrEmpty(item.entrycode)) return Json(new { success = false, message = tw_Lang.Common_ActionResult_MissingInfo });
var isExist = ContactRequest.GetById(item.entryid, null, false);
//Validate
//insert / update
if (item.entryid == 0)
{
//insert
item.createdat = DateTime.Now;
item.createdby = currentUser.entryid;
item.updatedat = DateTime.Now;
item.updatedby = currentUser.entryid;
item.isactive = true;
}
else
{
//update
item.createdby = isExist.createdby;
item.updatedat = DateTime.Now;
item.updatedby = currentUser.entryid;
}
item.AddOrUpdate(currentUser.entryid, null, false);
return(Json(new { success = true, data = item }));
}
catch (Exception e)
{
return(Json(new { success = false, message = e.Message }));
}
finally { db.Close(); }
}
public async Task <IActionResult> AddContact([FromBody] ContactRequest request)
{
string accessToken = await HttpContext.GetToken();
var session = await sessionService.GetSession(accessToken);
if (session == null)
{
return(Unauthorized(new { message = "Session expired. Please login again." }));
}
var newContact = await userRepository.FindUser(request.UserName);
if (newContact == null)
{
return(BadRequest(new { message = $"Contact doesn't exist: {request.UserName}" }));
}
var contactList = await userRepository.GetContacts(session.UserId);
if (contactList.Contains(newContact.UserName))
{
return(BadRequest(new { message = $"Contact already in contact list: {request.UserName}" }));
}
try
{
var added = await userRepository.AddContact(session.UserId, newContact.UserName);
await log.InfoAsync($"New Contact Added: [{newContact.UserName}]", context : session.UserId);
return(Ok(true));
}
catch (Exception ex)
{
await log.ErrorAsync("Error in userRepository.AddContact()", ex);
return(BadRequest(new { title = ex.GetType().ToString(), details = ex.StackTrace, message = ex.Message }));
}
}
public async Task <ContactResponse> SendContactMessageAsync(ContactRequest request)
{
ContactResponse response = new ContactResponse();
// E-mail validation
Email email = new Email(request.Email);
EmailValidator emailValidator = new EmailValidator();
ValidationResult emailResult = await emailValidator.ValidateAsync(email);
if (!emailResult.IsValid)
{
response.AddErrorValidationResult(emailResult);
}
if (string.IsNullOrEmpty(request.Name))
{
response.SetError(new ErrorResponse("Name", string.Format(Msg.RequiredFieldX, "Nome")));
}
if (string.IsNullOrEmpty(request.Subject))
{
response.SetError(new ErrorResponse("Subject", string.Format(Msg.RequiredFieldX, "Assunto")));
}
if (string.IsNullOrEmpty(request.Message))
{
response.SetError(new ErrorResponse("Message", string.Format(Msg.RequiredFieldX, "Mensagem")));
}
if (!response.IsValid())
{
return(response);
}
// Sending Email
await _emailService.SendContactEmailAsync(request.Name, request.Email.Trim().ToLower(), request.Subject, request.Message);
return(response);
}
public IActionResult AddContact(ContactRequest request)
{
if (ModelState.IsValid)
{
SingleResponse <int> response = new SingleResponse <int>();
try
{
_xbService.AddContact(request.Contact);
response.ResultCode = ResultCodes.normal;
}
catch
{
response.ResultCode = ResultCodes.failed;
}
response.Result = 0;
return(ResponseExtensions.ToHttpResponse(response));
}
else
{
return(ValidationError.GetValidationErrorResponse(ModelState));
}
}
public CreateContactRequest ToCreateContact(ContactRequest contactRequest)
{
return(new CreateContactRequest
{
Body = new EnvelopeBody
{
CreateContact = new CreateContact
{
AuthenticationParameters = new AuthenticationParameters
{
Reseller = _reseller,
Username = _username,
Password = _password
},
CommandParameters = new CommandParameters
{
LaunchPhase = contactRequest.LaunchPhase,
TLD = contactRequest.TLD,
Contact = new CreateContactCommandParametersContact
{
City = contactRequest.Contact.City,
CountryCode = contactRequest.Contact.CountryCode,
Email = contactRequest.Contact.Email,
Fax = contactRequest.Contact.Fax,
Name = contactRequest.Contact.Name,
Organisation = contactRequest.Contact.Organisation,
Postcode = contactRequest.Contact.Postcode,
State = contactRequest.Contact.State,
Street1 = contactRequest.Contact.Street1,
Street2 = contactRequest.Contact.Street2,
Street3 = contactRequest.Contact.Street3,
Telephone = contactRequest.Contact.Telephone,
TelephoneExtension = contactRequest.Contact.TelephoneExtension
}
}
}
}
});
}
public async Task Post()
{
var request = new ContactRequest()
{
Name = "leo",
Email = "*****@*****.**",
Phone = "66666"
};
var content = JsonConvert.SerializeObject(request);
var stringContent = new StringContent(content, Encoding.UTF8, "application/json");
var response = await _client.PostAsync("/api/contacts", stringContent);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var contact = JsonConvert.DeserializeObject <ContactResponse>(responseString);
Assert.Equal(4, contact.Id);
Assert.Equal("leo", contact.Name);
}
public JsonResult AcceptRequest(int requestId)
{
GenericResponse result = new GenericResponse()
{
IsSuccessful = false
};
try
{
if (requestId <= 0)
{
result.ErrorMessage = "Bad request.";
return(new JsonResult(result));
}
// Retrieve the requested user
ContactRequest request = _contactRequestService.GetContactRequest(requestId);
if (request != null && ContactRequestPermissionHelper.CanModifyContactRequest(_context.CurrentUser, request))
{
// Confirm the request
_contactRequestService.ConfirmContactRequest(_context.CurrentUser, request);
// If we got this far we're successful
result.IsSuccessful = true;
}
else
{
result.ErrorMessage = "You do not have permission to modify this contact request.";
}
}
catch (Exception e)
{
result.ErrorMessage = "An exception occured.";
_exceptionService.ReportException(e);
}
return(new JsonResult(result));
}
protected void LinkButtonSend_Click(object sender, EventArgs e)
{
if (Page.IsValid)
{
var contactRequest = new ContactRequest {
Name = TextBoxName.Text,
Email = TextBoxEmail.Text,
Phone = TextBoxPhone.Text,
Message = TextBoxMessage.Text,
Interests = String.Join(", ", CheckBoxListInterests.Items.Cast<ListItem>().Where(item => item.Selected).Select(item => item.Value).ToArray()) };
contactRequest.Save();
var emailService = new EmailService(EmailService.form.contact);
var notificationMessage = emailService.mailMessage;
notificationMessage.Subject = "New contact request";
notificationMessage.Body = String.Format("Name: {0}\n\nEmail: {1}\n\nPhone: {2}\n\nMessage:\n{3}\n\nInterests: {4}\n\n",
TextBoxName.Text,
TextBoxEmail.Text,
TextBoxPhone.Text,
TextBoxMessage.Text,
String.Join(", ", CheckBoxListInterests.Items.Cast<ListItem>().Where(item => item.Selected).Select(item => item.Value).ToArray()));
emailService.sendMessage(notificationMessage);
MultiViewContactRequest.SetActiveView(ViewResponse);
}
}
