public async Task <IActionResult> Edit(int id, [Bind("Id,ContactName,Email,Message,Location")] ContactUsMessage contactUsMessage)
{
if (id != contactUsMessage.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(contactUsMessage);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContactUsMessageExists(contactUsMessage.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(contactUsMessage));
}
public void MessageService_Test_GetMessageById()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("MessageService_Test_GetMessageById")
.Options;
var messageEntity = new ContactUsMessage()
{
Id = Guid.NewGuid(), Name = "Message 1"
};
using (var context = new ApplicationDbContext(options))
{
context.ContactUsMessage.Add(messageEntity);
context.SaveChanges();
}
using (var context = new ApplicationDbContext(options))
{
var service = new Service(context);
//assert
Assert.NotNull(service.ContactUsService.GetMessageById(messageEntity.Id));
}
}
public void MessageService_Test_InsertMessage()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("MessageService_Test_InsertMessage")
.Options;
var messageEntity = new ContactUsMessage()
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
Title = "Title",
Message = "Message",
Read = false,
SendDate = DateTime.Now
};
using (var context = new ApplicationDbContext(options))
{
var service = new Service(context);
//act
service.ContactUsService.InsertMessage(messageEntity);
//assert
Assert.Equal(
1,
service.ContactUsService.GetAllMessages().Count);
}
}
public void MessageService_Test_MarkAsRead()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("MessageService_Test_MarkAsRead")
.Options;
var testId = Guid.NewGuid();
var messageEntity = new ContactUsMessage()
{
Id = testId,
Email = "*****@*****.**",
Title = "Title",
Message = "Message",
Read = false,
SendDate = DateTime.Now
};
using (var context = new ApplicationDbContext(options))
{
context.ContactUsMessage.Add(messageEntity);
context.SaveChanges();
}
using (var context = new ApplicationDbContext(options))
{
var service = new Service(context);
//act
service.ContactUsService.MarkAsRead(testId);
//assert
Assert.True(service.ContactUsService.GetMessageById(testId).Read);
}
}
public void MessageService_Test_UpdateMessage()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("MessageService_Test_UpdateMessage")
.Options;
var testId = Guid.NewGuid();
var messageEntity = new ContactUsMessage()
{
Id = testId,
Email = "*****@*****.**",
Title = "Title",
Message = "Message",
Read = false,
SendDate = DateTime.Now
};
using (var context = new ApplicationDbContext(options))
{
var service = new Service(context);
service.ContactUsService.InsertMessage(messageEntity);
//act
messageEntity.Message = "Message Updated";
service.ContactUsService.UpdateMessage(messageEntity);
//assert
Assert.Equal(
"Message Updated",
service.ContactUsService.GetMessageById(testId).Message);
}
}
public void ContactUsService_Test_GetMessageById()
{
// arrange
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "ContactUsService_Test_GetMessageById")
.Options;
var testId = Guid.NewGuid();
var contactUsMessage = new ContactUsMessage {
Id = testId, Email = "*****@*****.**", Title = "Title", Message = "Message", Read = false, SendDate = DateTime.Now
};
using (var context = new ApplicationDbContext(options))
{
context.ContactUsMessage.Add(contactUsMessage);
context.SaveChanges();
}
using (var context = new ApplicationDbContext(options))
{
var service = new Service(context);
// assert
Assert.NotNull(service.ContactUsService.GetMessageById(testId));
}
}
public async Task AddContactUsMessageAsync(ContactUsMessage contactUsMessage)
{
_contactUsMessageRepository.Add(contactUsMessage);
await _unitOfWork.CompleteAsync();
await _emailService.SendEmailAsync(contactUsMessage.Email, "Contact us message", BuildMessage(contactUsMessage));
}
public IHttpActionResult AddMessageQueue(ContactUsMessage ContactUsMessage)
{
try
{
ContactUsMessage.State = BaseState.Added;
Mgr.AddUpdate(ContactUsMessage);
Unit.SaveChanges();
//if (MessagingQueue.MessageType == SharedEnums.MessageType.Email)
//{
// Manager<User> UserManager = new Manager<User>(Unit);
// var email = UserManager.FindById(MessagingQueue.ToUserId).Email;
// var MsgTitle = "";
// if (UnitOfWork.Language == LanguageEnum.Arabic)
// MsgTitle = ConfigurationManager.AppSettings["EmailSubjectAr"].ToString();
// else
// MsgTitle = ConfigurationManager.AppSettings["EmailSubjectEn"].ToString();
// MailSender.SendEmail(MsgTitle, MessagingQueue.Message, email);
//}
return(Ok(ContactUsMessage));
}
catch (Exception ex)
{
Unit.LogError(ex, this.ToString(), this.ActionContext.ActionArguments.ToList());
return(InternalServerError(ex));
}
}
public ActionResult CommentEdite(int id)
{
ContactUsMessage model = db.ContactUsMessages.Find(id);
model.Vaziaat = Vaziaat.Reade;
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
return(PartialView(model));
}
public IHttpActionResult AddContactUsMessage([FromBody] ContactUsMessage value)
{
ContactUsMessage contactusmessage = new ContactUsMessage();
var contactusservice = new ContactUsService();
contactusservice.AddContactUsMessage(value);
return(Ok(contactusmessage));
}
/// <summary>
/// Insert ContactUsMessage
/// </summary>
/// <param name="message">ContactUsMessage entity</param>
public void InsertMessage(ContactUsMessage message)
{
if (message == null)
{
throw new ArgumentException("message");
}
_contactUsRepository.Insert(message);
_contactUsRepository.SaveChanges();
}
public void UpdateMessage(ContactUsMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
_contactUsRepository.Update(message);
_contactUsRepository.SaveChanges();
}
public async Task <IActionResult> Create([Bind("Id,ContactName,Email,Message,Location")] ContactUsMessage contactUsMessage)
{
if (ModelState.IsValid)
{
_context.Add(contactUsMessage);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(contactUsMessage));
}
public void AddContactUsMessage(ContactUsMessage contactusmessage)
{
ContactUsData contactusData = new ContactUsData();
try
{
contactusData.AddContactUsMessage(contactusmessage);
}
catch (Exception ex)
{
throw ex;
}
}
public JsonResult SendMessage(string fullName, string email, string subject, string message)
{
var jsonSuccessResult = new JsonSuccessResult();
try
{
ContactUsMessage msg = new ContactUsMessage
{
Subject = subject,
FullName = fullName,
Email = email,
Message = message,
LastUpdate = DateTime.Now,
ContactUsMessageStatus = ContactUsMessageStatus.NotChecked,
Key = Guid.NewGuid().ToString()
};
ContactUsMessages.Insert(msg);
// اطلاع رسانی به مدیر
#region Apprise Admin
string body = "مدیریت محترم، در بخش تماس با ما، پیام جدیدی ثبت شد:";
body += "<br/>";
body += String.Format("ایمیل: {0} <br/> موضوع: {1} <br/> پیام: {2}", email, subject, message);
EmailServices.NotifyAdminsByEmail(AdminEmailType.NewContactMessage, body, null);
#endregion Apprise Admin
EmailServices.DeliveryContactUsMessage(email, fullName, UserID);
jsonSuccessResult.Success = true;
}
catch (DbException ex)
{
jsonSuccessResult.Errors = ex.Errors.ToArray();
jsonSuccessResult.Success = false;
}
catch (Exception ex)
{
jsonSuccessResult.Errors = new string[] { ex.Message };
jsonSuccessResult.Success = false;
}
return(new JsonResult()
{
Data = jsonSuccessResult
});
}
//Sends an email to admin from the contact us form
public async Task ContactUsEmail(ContactUsMessage userMessage)
{
//AdminEmail set to [email protected]
string email = _appKeys.EvidentIdCredentials.AdminEmail;
SendGridMessage message = new SendGridMessage()
{
From = new EmailAddress(userMessage.Email),
Subject = $"Contact Us Message from {userMessage.Name}",
PlainTextContent = userMessage.Message,
};
message.AddTo(email);
await SendEmail(message);
}
private string BuildMessage(ContactUsMessage contactUsMessage)
{
var message = new StringBuilder();
if (!string.IsNullOrEmpty(contactUsMessage.Name))
{
message.Append($"Name: { contactUsMessage.Name } <br>");
}
message.Append($"Email: { contactUsMessage.Email } <br>");
if (!string.IsNullOrEmpty(contactUsMessage.PhoneNumber))
{
message.Append($"Phone Number: { contactUsMessage.PhoneNumber } <br>");
}
message.Append($"<br> <div style='font-size: 14px;'> { contactUsMessage.Message } </div>");
return(message.ToString());
}
public async Task <AddResultStatus> InsertAContactUsMessageAsync(ContactUsMessage contactUsMessage)
{
AddResultStatus status = AddResultStatus.Error;
try
{
var contacts = _ContactRepo.GetAll();
Contact contact = contacts.FirstOrDefault(x => x.Firstname.Trim().ToUpper().Equals(contactUsMessage.FirstName.Trim().ToUpper()) &&
x.Lastname.Trim().ToUpper().Equals(contactUsMessage.LastName.Trim().ToUpper()) &&
x.Email.Trim().ToUpper().Equals(contactUsMessage.Email.Trim().ToUpper()));
//if contact was not found create a new
if (contact == null)
{
contact = new Contact()
{
Firstname = contactUsMessage.FirstName,
Lastname = contactUsMessage.LastName,
Email = contactUsMessage.Email
};
_ContactRepo.Insert(contact);
await _ContactRepo.SaveChangesAsync();
}
var request = new Request()
{
ContactId = contact.Id,
RequestBody = contactUsMessage.MessageDetail,
RequestTypeId = CONTACT_US_MESSAGE_ID,
Status = (int)RequestStatus.Requested,
Subject = "Contact Message",
Receivedon = DateTime.Now
};
_RequestRepo.Insert(request);
await _RequestRepo.SaveChangesAsync();
status = AddResultStatus.Added;
}
catch (DbException)
{
status = AddResultStatus.Error;
}
return(status);
}
public ContactUsMessageModel AddContactUs(ContactUsMessageModel contactUsMessageModel)
{
ContactUsMessage contactUsMessage = new ContactUsMessage
{
FirstName = contactUsMessageModel.firstName,
LastName = contactUsMessageModel.lastName,
Email = contactUsMessageModel.email,
Phone = contactUsMessageModel.phone,
Message = contactUsMessageModel.message,
Subject = contactUsMessageModel.subject,
};
DB.ContactUsMessages.Add(contactUsMessage);
DB.SaveChanges();
//Email.Send("*****@*****.**", "Hi", "This is a test email...");
return(GetOneContactUsMessage(contactUsMessage.ContactUsID));
}
public async Task <ActionResult <ContactusEmailContent> > ContactUsPost([FromForm] ContactusEmailContent emailContent)
{
var files = Request.Form.Files.Any() ? Request.Form.Files : new FormFileCollection();
if (!files.Any())
{
files = null;
}
var email = emailContent.Email;
var request = emailContent.RequestType;
var messageBody = emailContent.Message;
var name = emailContent.Name;
var message = new ContactUsMessage(new[] { "*****@*****.**" }, request, name, email, messageBody, files);
await _emailSender.SendMailAsync(message);
return(Ok());
}
public async Task <IActionResult> SendContactUsMessage([FromBody] ContactUsMessage ContactUsMessage)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.ContactUsMessage.Add(ContactUsMessage);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
throw;
}
return(CreatedAtAction("GetContactUsMessage", new { id = ContactUsMessage.Email }, ContactUsMessage));
}
public ActionResult SaveContactUsMessageInDatabase(FormCollection form)
{
var ContactMessage = new ContactUsMessage
{
Message = form["Message"],
Name = form["Name"],
Email = form["Email"],
MobileNo = form["MobileNo"]
};
try
{
context.ContactUsMessages.Add(ContactMessage);
context.SaveChanges();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> AddContactusMessage(ContactUsMessage contactUs)
{
var ok = _context.contactUsMessages.ToList();
if (ModelState.IsValid)
{
try
{
contactUs.CreateAt = DateTime.Now;
await _context.contactUsMessages.AddAsync(contactUs);
_context.SaveChanges();
return(Json(new { status = "1", message = " نظر شما با موفقیت ثبت شده است." }));
}
catch (Exception ex)
{
return(Json(new { status = "0", message = ex.Message }));
}
}
return(Json(new { status = "0", message = "خطایی رخ داده است لطفا مجددا امتحان کنید." }));
}
public void AddContactUsMessage(ContactUsMessage value)
{
System.Data.SqlClient.SqlCommand cmdSQL = null;
System.Data.SqlClient.SqlConnection cnSQL = null;
string ConnString = System.Configuration.ConfigurationManager.ConnectionStrings["SteppingStoneDB"].ConnectionString;
try
{
cnSQL = new System.Data.SqlClient.SqlConnection(ConnString);
cnSQL.Open();
cmdSQL = new System.Data.SqlClient.SqlCommand();
cmdSQL.Connection = cnSQL;
cmdSQL.CommandType = CommandType.Text;
cmdSQL.CommandText = String.Format("INSERT INTO ContactUsMessage (FirstName, Lastname, Email, Message) VALUES ('{0}', '{1}', N'{2}', '{3}')", value.FirstName, value.LastName, value.Email, value.Message);
cmdSQL.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult CreateMessage(ContactUsViewModel model)
{
bool err = true;
if (ModelState.IsValid)
{
var messageEntity = new ContactUsMessage
{
Name = model.Name,
Email = model.Email,
Title = model.Title,
Message = model.Message,
Read = false,
SendDate = DateTime.Now
};
_contactUsService.InsertMessage(messageEntity);
err = false;
}
TempData["ContactUsErr"] = err;
return(RedirectToAction("Index"));
}
public ActionResult Edit(ContactUsMessage msg, string sendEmail)
{
try
{
var old = ContactUsMessages.GetByID(msg.ID);
if (!String.IsNullOrWhiteSpace(msg.Answer) && sendEmail == "on")
{
EmailServices.ContactUsMessage(old.Email, old.Subject, old.Message, msg.Answer, UserID);
}
msg.LastUpdate = DateTime.Now;
ViewBag.Success = true;
ContactUsMessages.Update(msg);
}
catch (Exception ex)
{
SetErrors(ex);
}
return(RedirectToAction("Index"));
}
public void Remove(ContactUsMessage ContactUsMessage)
{
context.Remove(ContactUsMessage);
}
public void Add(ContactUsMessage ContactUsMessage)
{
context.ContactUsMessages.Add(ContactUsMessage);
}
