public ICollection <object> ParseData(MySqlDataReader dataReader)
{
var entities = new List <object>();
while (dataReader.Read())
{
var entity = new EmailResponse
{
ID = (int)dataReader["ID"],
OwnerName = dataReader["OwnerName"] as string,
Name = dataReader["Name"] as string,
Description = dataReader["Description"] as string,
Email = dataReader["Email"] as string,
Status = dataReader["Status"] as string,
Subject = dataReader["Subject"] as string,
MessageDate = dataReader["MessageDate"] as string
};
if (int.TryParse((dataReader["EnquiryID"] as int?)?.ToString(), out int enquiryID))
{
entity.Enquiry = new Enquiry {
ID = enquiryID
};
}
entities.Add(entity);
}
return(entities);
}
public ICollection <object> ParseDataMin(MySqlDataReader dataReader)
{
var entities = new List <object>();
while (dataReader.Read())
{
var entity = new EmailResponse
{
ID = (int)dataReader["ID"],
Email = dataReader["Email"] as string,
Status = dataReader["Status"] as string,
Subject = dataReader["Subject"] as string,
};
if (int.TryParse((dataReader["EnquiryID"] as int?)?.ToString(), out int enquiryID))
{
entity.Enquiry = new Enquiry {
ID = enquiryID
};
}
entities.Add(entity);
}
return(entities);
}
public void MAdapter_ItemClick(object sender, int position)
{
try
{
List <EmailResponse> emailListResponse = mAdapter.GetData();
EmailResponse emailResponseObj = emailListResponse[position];
if (emailResponseObj.Unread)
{
emailResponseObj.Unread = false;
emailListResponse[position] = emailResponseObj;
mAdapter.emailList = emailListResponse;
mAdapter.NotifyItemChanged(position);
// Call webservice for update read flag
WebServiceMethods.MarkReadEmail(emailResponseObj.MailId);
}
string emailResponseString = JsonConvert.SerializeObject(emailResponseObj);
Intent intent = new Intent(mActivity, typeof(EmailDetailActivity));
intent.PutExtra("emailResponseString", emailResponseString);
intent.PutExtra("emailTypeId", emailTypeId);
StartActivityForResult(intent, ConstantsDroid.EMAIL_DETAIL_REQUEST_CODE);
}
catch (Exception)
{
}
}
// POST: api/Email
public IHttpActionResult Post(EmailRequest emailRequest)
{
try
{
//Build the request model for the service to send the email
PigeonRequest pigeonRequest = EmailFactory.CreatePigeonRequest(emailRequest);
PigeonResponse pigeonResponse = _emailProvider.SendAFitPigeon(pigeonRequest);
if (pigeonResponse.Success)
{
//Create the Api response for the successful post request
EmailResponse emailResponse = EmailFactory.CreateEmailResponse(pigeonResponse);
//Save to database if the email is sent successfully
_emailSavingService = new EmailSavingService(_commonProvider, _databaseRepoProvider,
emailRequest, emailResponse);
//request = CommonUtility.SerializeObject(emailRequest);
//response = CommonUtility.SerializeObject(emailResponse);
//var isSaved = databaseStuff.SaveaSomethingAwesome(request, response, 1, 2);
return(Ok(emailResponse));
}
else
{
return(BadRequest("Response was not a success: " + pigeonResponse.Message));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task <EmailResponse> SendEmailWithTemplate(EmailTemplateRequest emailWithTemplateRequest)
{
EmailResponse emailResponse = new EmailResponse();
using var client = new AmazonSimpleEmailServiceClient(EmailConfiguration.AccessKeyId, EmailConfiguration.AccessSecretKey, RegionEndpoint.USEast1);
var sendRequest = new SendTemplatedEmailRequest
{
Source = EmailConfiguration.SenderAddress,
Destination = new Destination
{
ToAddresses = emailWithTemplateRequest.Receivers
},
Template = emailWithTemplateRequest.Template,
TemplateData = JsonSerializer.Serialize(emailWithTemplateRequest.Data)
};
try
{
await client.SendTemplatedEmailAsync(sendRequest);
emailResponse.Success = true;
}
catch (Exception ex)
{
Console.WriteLine("The email was not sent.");
Console.WriteLine("Error message: " + ex.Message);
emailResponse.Success = false;
}
client.Dispose();
return(emailResponse);
}
public EmailSavingService(ICommon commonUtility, IRepo databaseRepo, EmailRequest emailRequest, EmailResponse emailResponse)
{
_commonUtility = commonUtility;
_databaseRepo = databaseRepo;
_emailRequest = emailRequest;
_emailResponse = emailResponse;
}
public EmailResponse Send(IEnumerable <Email> emails, bool priorityRequired = false)
{
try
{
EmailResponse response = new EmailResponse();
if (priorityRequired)
{
emails = emails.OrderByDescending(x => x.Priority);
}
foreach (var email in emails)
{
//Here should be creation of MailMessage from e.g. System.Net.Mail
//Assing data: email object to MailMessage object
//Here should be implementation of sending email using SMTP account
//Something Like:
//string smtipServer = ...
//using (SmtpClient client = new SmtpClient(smtipServer))
//{
// client.Send(message);
//}
}
response.Success = true;
return(response);
}
catch (Exception)
{
throw;
}
}
public void EmailResponse_WithMessages_Constructor()
{
// Arrange
var model = new EmailResponseModel()
{
TransactionId = Guid.NewGuid(),
Messages = new List <MessageResponseModel>()
{
new MessageResponseModel()
{
MessageId = Guid.NewGuid(),
Tag = "tag"
}
}
};
// Act
var response = new EmailResponse(model);
// Assert
response.TransactionId.Should().Be(model.TransactionId);
response.Messages.Count().Should().Be(1);
response.Messages.First().MessageId.Should().Be(model.Messages.First().MessageId);
response.Messages.First().Tag.Should().Be(model.Messages.First().Tag);
}
public static async Task <EmailResponse> SendCancellationEmail(Attendee _Attendee, HtmlTag html)
{
var message = new PostmarkMessage()
{
To = _Attendee.EmailAddress,
From = "*****@*****.**",
TrackOpens = true,
Subject = "Windforce Developer Conference Cancellation",
HtmlBody = html.Text,
Tag = "Windforce Developer Conference Cancellation",
};
var client = new PostmarkClient(_EmailAPIKey);
var sendResult = await client.SendMessageAsync(message);
EmailResponse EmailSendResponse = EmailResponse.Failure;
if (sendResult.Status == PostmarkStatus.Success)
{
EmailSendResponse = EmailResponse.Success;
}
else
{
EmailSendResponse = EmailResponse.Failure;
}
return(EmailSendResponse);
}
public async Task <ActionResult <ItemResponse <int> > > CreateAsyncV2(UserAddRequestV2 userAddRequest)
{
ObjectResult result = null;
try
{
Guid token = Guid.NewGuid();
int userId = _userService.CreateV2(userAddRequest, token);
if (userId != 0)
{
EmailResponse item = await _emailService.ConfirmEmail(userAddRequest.Email, token);
ItemResponse <int> response = new ItemResponse <int> {
Item = userId
};
result = Created201(response);
}
}
catch (Exception ex)
{
base.Logger.LogError(ex.ToString());
ErrorResponse response = new ErrorResponse(ex.Message);
result = StatusCode(500, response);
}
return(result);
}
public async Task <EmailResponse> EmailOTPRequest(EmailRequest emailRequest)
{
EmailResponse emailResponse = new EmailResponse();
string EmailToken = "12451";
string message = "Hi Dude ! Here is your Token" + EmailToken;
MailMessage msg = new MailMessage();
msg.Sender = new MailAddress(_configuration.GetSection("EmailInfo:Email").Value);
msg.From = new MailAddress("*****@*****.**", "Crack-Interview");
msg.To.Add(emailRequest.ValueType);
msg.Subject = "OTP";
msg.Body = message;
msg.IsBodyHtml = true;
SmtpClient client = new SmtpClient();
client.Host = "mail.o365am.aig.com";
System.Net.NetworkCredential NetworkCred = new System.Net.NetworkCredential();
NetworkCred.UserName = _configuration.GetSection("EmailInfo:Email").Value;
NetworkCred.Password = _configuration.GetSection("EmailInfo:Password").Value;
client.UseDefaultCredentials = true;
client.Credentials = NetworkCred;
client.Port = 25;
client.EnableSsl = true;
client.Send(msg);
emailResponse.OTPNumber.message = EmailToken;
emailResponse.StatusCode = 200;
emailResponse.ValueType = emailRequest.ValueType;
emailResponse.Message = message;
return(emailResponse);
}
public override EmailResponse Notify(EmailRequest request)
{
EmailResponse response = new EmailResponse();
MailMessage mailMessage = this.PrepareMailBody(request);
_client.Send(mailMessage);
response.Status = (NotificationStatus.Pending);
return(response);
}
public override async Task <EmailResponse> NotifyAsync(EmailRequest request)
{
EmailResponse response = new EmailResponse();
MailMessage mailMessage = this.PrepareMailBody(request);
await _client.SendMailAsync(mailMessage);
response.Status = (NotificationStatus.Sent);
return(response);
}
private async Task <EmailResponse> Retrieve(CommunicationVault vault, String id)
{
EmailResponse retrieved = await vault.Email.Retrieve(id);
Console.WriteLine("//// EmailExample.retrieve:");
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(retrieved));
return(retrieved);
}
public override EmailResponse Notify(EmailRequest request)
{
var mail = this.PrepareMail(request);
var response = this._sendGridClient.SendEmailAsync(mail);
var emailResponse = new EmailResponse();
emailResponse.RawResponse = response;
emailResponse.Status = NotificationStatus.Pending;
return(emailResponse);
}
public void EmailResponse_Default_Constructor()
{
// Arrange
// Act
var response = new EmailResponse();
// Assert
response.TransactionId.Should().Be(Guid.Empty);
response.Messages.Should().BeEmpty();
}
public override EmailResponse Notify(EmailRequest request)
{
var mailBody = this.PrepareMailBody(request);
var rawResponse = this._client.SendEmailAsync(mailBody);
var response = new EmailResponse();
response.RawResponse = rawResponse;
response.Status = NotificationStatus.Pending;
return(response);
}
public override Response.EmailResponse SendEmail(Email email)
{
var response = new EmailResponse()
{
Success = Success,
Message = (Success ? "Email successfully sent" : "Undefined Error")
};
return(response);
}
public async static Task <List <EmailResponse> > InboxEmails(string userId, int mailTypeId)
{
List <EmailResponse> emailList = new List <EmailResponse>();
try
{
InboxEmailApiParams param = new InboxEmailApiParams
{
mailCount = 10,
mailTypeId = mailTypeId,
filterIndex = 0,
filterEmail = "",
blnShowblank = false,
intUserID = userId,
connectionName = WebserviceConstants.CONNECTION_NAME
};
var response = await WebServiceHandler.GetWebserviceResult(WebserviceConstants.SHOW_INBOX_EMAILS_URL,
HttpMethod.Post, param) as FinalResponse;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
DataSet resultIds = response.ResultDs;
foreach (DataTable dt in resultIds.Tables)
{
foreach (DataRow dr in dt.Rows)
{
EmailResponse emailResponse = new EmailResponse();
emailResponse.MailId = dr["MailId"] != DBNull.Value ? dr["MailId"].ToString() : "";
emailResponse.DisplayDate = dr["DisplayDate"] != DBNull.Value ? dr["DisplayDate"].ToString() : "";
emailResponse.myGroup = dr["myGroup"] != DBNull.Value ? dr["myGroup"].ToString() : "";
emailResponse.Received = dr["Received"] != DBNull.Value ? dr["Received"].ToString() : "";
emailResponse.FolderName = dr["FolderName"] != DBNull.Value ? dr["FolderName"].ToString() : "";
emailResponse.AccountCode = dr["AccountCode"] != DBNull.Value ? dr["AccountCode"].ToString() : "";
emailResponse.Sender = dr["Sender"] != DBNull.Value ? dr["Sender"].ToString() : "";
emailResponse.SenderName = dr["SenderName"] != DBNull.Value ? dr["SenderName"].ToString() : "";
emailResponse.Subject = dr["Subject"] != DBNull.Value ? dr["Subject"].ToString() : "";
emailResponse.eMailTypeId = dr["eMailTypeId"] != DBNull.Value ? Convert.ToInt32(dr["eMailTypeId"]) : 0;
emailResponse.Unread = dr["Unread"] != DBNull.Value ? Convert.ToBoolean(dr["Unread"]) : false;
emailResponse.Important = dr["Important"] != DBNull.Value ? Convert.ToBoolean(dr["Important"]) : false;
emailResponse.Attachment = dr["Attachment"] != DBNull.Value ? Convert.ToInt32(dr["Attachment"]) : 0;
emailResponse.SenderEmail = dr["SenderEmail"] != DBNull.Value ? dr["SenderEmail"].ToString() : "";
emailList.Add(emailResponse);
}
}
}
return(emailList);
}
catch (Exception ex)
{
return(emailList);
}
}
public void Can_Get_to_retrieve_email()
{
var restClient = this.CreateRestClient();
EmailResponse response = restClient.Get(new Email {
Id = "2012112622230791-a8"
});
Assert.That(response, Is.Not.Null);
Assert.That(response.From, Is.Not.Null, "'From' property was null");
}
public static bool IsValid(EmailResponse emailResponse, out Dictionary <string, string> validationResult)
{
validationResult = new Dictionary <string, string>();
if (string.IsNullOrWhiteSpace(emailResponse.Name))
{
validationResult.Add("Record.Name", ValidationMessages.REQUIRED);
}
return(!validationResult.Any());
}
public CompanyResponse(int id, DocumentResponse document, EmailResponse email,
AddressResponse address, string companyName, string fantasyName,
List <EmployeeResponse> employees)
{
Id = id;
Email = email;
Address = address;
Document = document;
Employees = employees;
FantasyName = fantasyName;
CompanyName = companyName;
}
public override EmailResponse Execute(dynamic connectionModel, string sql)
{
var response = new EmailResponse();
using (var data = new SqlDataAdapter(sql, (SqlConnection)connectionModel))
{
response.ResultSet = new System.Data.DataTable();
data.Fill(response.ResultSet);
}
return response;
}
private void btnGerarHistorico_Click(object sender, EventArgs e)
{
try
{
ISaldoDevedor serv = Ativador.Get <ISaldoDevedor>();
EnviarEmailRequest request = new EnviarEmailRequest();
EmailResponse dadosEmail = serv.ObterDetalheEmail(IDEMAIL_RISCO);
request.DadosEmail = dadosEmail.Lista[IDEMAIL_RISCO];
var listaSelecionados =
from InformacoesClienteInfo lstcli in ListaDevedores
orderby lstcli.CodigoAssessor, lstcli.CodigoCliente ascending
where lstcli.Selecionado == true
select lstcli;
request.ListaClientes = listaSelecionados.ToList();
if (request.ListaClientes.Count > 0)
{
if (!EmailTestePara.Equals(""))
{
request.DadosEmail.EmailPara = EmailTestePara;
}
if (!EmailTesteCopia.Equals(""))
{
request.DadosEmail.EmailCopia = EmailTesteCopia;
}
if (!EmailTesteCopiaOculta.Equals(""))
{
request.DadosEmail.EmailCopiaOculta = EmailTesteCopiaOculta;
}
EnviarEmailResponse resp = serv.EnviarEmailRisco(request);
if (resp.Retorno == EnviarEmailResponse.RETORNO_OK)
{
MessageBox.Show("E-mail enviado com sucesso!", "Histórico Movimento",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("FALHA NO ENVIO DO E-MAIL!", "Histórico Movimento",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
catch (Exception ex)
{
string msg = "Enviar E-Mail: " + ex.Message;
MessageBox.Show(msg, "Histórico Movimento", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void btnEnviarEmail_Click(object sender, EventArgs e)
{
try
{
EnviarEmailRequest request = new EnviarEmailRequest();
ISaldoDevedor serv = Ativador.Get <ISaldoDevedor>();
EmailResponse dadosEmail = serv.ObterDetalheEmail(IDEMAIL_TESOURARIA);
request.DadosEmail = dadosEmail.Lista[IDEMAIL_TESOURARIA];
var listaSelecionados =
from InformacoesClienteInfo lstcli in ListaDevedoresFiltrada
orderby lstcli.CodigoAssessor, lstcli.CodigoCliente ascending
where lstcli.Selecionado == true
select lstcli;
request.ListaClientes = listaSelecionados.ToList();
if (request.ListaClientes.Count > 0)
{
if (!EmailTestePara.Equals(""))
{
request.DadosEmail.EmailPara = EmailTestePara;
}
if (!EmailTesteCopia.Equals(""))
{
request.DadosEmail.EmailCopia = EmailTesteCopia;
}
if (!EmailTesteCopiaOculta.Equals(""))
{
request.DadosEmail.EmailCopiaOculta = EmailTesteCopiaOculta;
}
EnviarEmailResponse resp = serv.EnviarEmailTesouraria(request);
if (resp.Retorno == EnviarEmailResponse.RETORNO_OK)
{
MessageBox.Show("Notificação enviada com sucesso!", "Notificar Tesouraria",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("FALHA NO ENVIO DA NOTIFICAÇÃO!", "Notificar Tesouraria",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
catch (Exception ex)
{
string msg = "Enviar E-Mail: " + ex.Message;
MessageBox.Show(msg, "Notificar Tesouraria", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
} //not in doc
public Email CreateFromResponse(EmailResponse response)
{
return(new Email()
{
Body = response.Body,
Id = response.Id,
CreateAt = response.CreateAt,
Subject = response.Subject,
ScheduledAt = response.ScheduledAt,
Contacts = new List <Contact>()
});
}
private async Task <EmailResponse> Create(CommunicationVault vault)
{
String name = "*****@*****.**";
EmailResponse created = await vault.Email.Create(name);
Console.WriteLine("//// EmailExample.create:");
Console.WriteLine("/// Name: " + name);
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(created));
return(created);
}
public ViewResult Contact(EmailResponse emailResponse)
{
if (ModelState.IsValid)
{
// TODO: Email response to the party organizer
return(View("Thankyou", emailResponse));//Thank you, we will respond asap.
}
else
{
// there is a validation error
return(View());
}
}
public static EmailResponse CreateEmailResponse(PigeonResponse pigeonResponse)
{
EmailResponse emailResponse = new EmailResponse();
emailResponse.Body = pigeonResponse.Body;
emailResponse.From = pigeonResponse.From;
emailResponse.Message = pigeonResponse.Message;
emailResponse.SubmittedDateTime = pigeonResponse.SubmittedDateTime;
emailResponse.Success = pigeonResponse.Success;
emailResponse.To = pigeonResponse.To;
return(emailResponse);
}
public async Task Run()
{
// Creating a new Email
EmailResponse created = await Create(communicationVault);
// Retrieving a existent Email
EmailResponse retrieved = await Retrieve(communicationVault, created.Id);
await RetrieveFromRealData(communicationVault, created.Email);
// Deleting a existent Email
await Delete(communicationVault, retrieved.Id);
}
public EmployeeResponse(int id, NameResponse name, DocumentResponse document, EmailResponse email,
AddressResponse address, string registerCode, CompanyResponse company,
EmployeePositionResponse employeePositionResponse)
{
Id = id;
Name = name;
Email = email;
Company = company;
Address = address;
Document = document;
RegisterCode = registerCode;
EmployeePosition = employeePositionResponse;
}
public override EmailResponse OpenCon(string sqlCon)
{
var response = new EmailResponse();
try
{
var connection = new SqlConnection(sqlCon);
if (connection.State == System.Data.ConnectionState.Closed)
{
connection.Open();
}
response.ConnectionModel = connection;
}
catch (System.Exception ex)
{
response.ResponseCode = ResponseCode.SQL_ERROR;
response.Message = ex.Message;
}
return response;
}
public override EmailResponse OpenCon(string sqlCon)
{
var response = new EmailResponse();
return response;
}
public override EmailResponse Execute(dynamic connectionModel, string sql)
{
var response = new EmailResponse();
return response;
}
