public bool ReestablecerClave(FormularioReestablecerClave formulario)
{
try
{
RepositorioUsuario repoUsuario = new RepositorioUsuario();
if (repoUsuario.PorDocumento(formulario.Documento) is Usuario usuario)
{
if (usuario.Expedicion == formulario.FechaExpedicion)
{
usuario.Clave = formulario.NuevaClave;
if (repoUsuario.Editar(usuario))
{
var correspondencia = new Correspondence();
correspondencia.SendPasswordChange(usuario);
return(true);
}
}
}
return(false);
}
catch
{
return(false);
}
}
public void Test_Indexer_Get()
{
Correspondence actual = correspondences[2];
Correspondence expected = correspondenceList[2];
Assert.AreEqual(expected, actual);
}
public async Task <IActionResult> Send([FromBody] MessageToSend message)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
int messageId = await SaveMessage(message.Subject, message.Body);
IEnumerable <Recipient> recipients = await SaveRecipients(message.Recipients);
foreach (Recipient recipient in recipients)
{
Correspondence correspondence =
await SendMessage(
new EmailAddress(_emailSender.Address, _emailSender.Name),
new EmailAddress(recipient.Email),
message.Subject,
message.Body);
correspondence.MessageId = messageId;
correspondence.RecipientId = recipient.Id;
_correspondenceRepository.Add(correspondence);
}
await _correspondenceRepository.UnitOfWork.SaveChangesAsync();
return(CreatedAtAction(nameof(Show), new { messageId }, await GetSentMessageById(messageId)));
}
public async void UpdateAsync()
{
//Preparación
Exception expectedException = null;
DbContextOptions <ALPHADataContext> options = new DbContextOptions <ALPHADataContext>();
CorrespondenceRepository messageRep = new CorrespondenceRepository(null);
Correspondence model = new Correspondence();
model.Id = 2;
model.Id = 0;
model.Consecutive = "CI00000001";
model.SenderId = 1;
model.AddresseeId = 2;
model.Subject = "Hola";
model.Body = "Mundo";
//Prueba
try
{
await messageRep.UpdateAsync(model);
Assert.Fail("Se debe actualizar el registro");
}
catch (Exception ex)
{
expectedException = ex;
}
//Verificación
Assert.IsTrue(expectedException is ApplicationException);
Assert.AreEqual("El registro debió ser actualizado", expectedException.Message);
}
private void MultiplierTb_TextChanged(object sender, EventArgs e)
{
TextBox tb = sender as TextBox;
Correspondence.TryGetValue(tb, out CurrentSelected);
Double.TryParse(tb.Text, out externalWeights[CurrentSelected.X, CurrentSelected.Y]);
}
public async void InsertAsync()
{
//Preparación
Exception expectedException = null;
IConnectionFactory connectionFactory;
CorrespondenceRepository messageRep = new CorrespondenceRepository(null);
Correspondence model = new Correspondence();
model.Id = 0;
model.Consecutive = string.Empty;
model.SenderId = 1;
model.AddresseeId = 2;
model.Subject = "Hola";
model.Body = "Mundo";
//Prueba
try
{
await messageRep.InsertAsync(model);
Assert.Fail("Se debe insertar el registro");
}
catch (Exception ex)
{
expectedException = ex;
}
//Verificación
Assert.IsTrue(expectedException is ApplicationException);
Assert.AreEqual("El registro debió ser insertado", expectedException.Message);
}
public async Task <IHttpActionResult> GetCorrespondence(int id)
{
Correspondence corres = await db.Correspondences.FindAsync(id);
if (corres == null)
{
ModelState.AddModelError("Message", "Correspondence not found!");
return(BadRequest(ModelState));
}
PersonalDetailsDTO personalDetailsSender = ((OkNegotiatedContentResult <PersonalDetailsDTO>)pdctr.GetPersonalDetailsByTraderId(corres.traderIdSender)).Content;
PersonalDetailsDTO personalDetailsReciever = ((OkNegotiatedContentResult <PersonalDetailsDTO>)pdctr.GetPersonalDetailsByTraderId(corres.traderIdReceiver)).Content;
CorrespondenceDTO mesdto = new CorrespondenceDTO();
mesdto.id = corres.id;
mesdto.subject = db.Trades.First(tro => tro.tradeId == corres.tradeId).name;
mesdto.message = corres.message;
mesdto.content = corres.content;
mesdto.statusSender = corres.statusSender;
mesdto.statusReceiver = corres.statusReceiver;
mesdto.dateSent = corres.dateSent;
mesdto.tradeId = corres.tradeId;
mesdto.traderIdSender = corres.traderIdSender;
mesdto.traderIdReceiver = corres.traderIdReceiver;
mesdto.sender = personalDetailsSender.firstName + " " + personalDetailsSender.middleName + " " + personalDetailsSender.lastName;
mesdto.receiver = personalDetailsReciever.firstName + " " + personalDetailsReciever.middleName + " " + personalDetailsReciever.lastName;
return(Ok(mesdto));
}
public ActionResult Index(ContactEmailViewModel contactMessage)
{
//Validate contact message input
if (contactMessage == null)
{
ModelState.AddModelError("", "No Message has been provided!");
return(View());
}
if (string.IsNullOrWhiteSpace(contactMessage.Name) ||
string.IsNullOrWhiteSpace(contactMessage.Email) ||
string.IsNullOrWhiteSpace(contactMessage.Message))
{
ModelState.AddModelError("", "All fields are required!");
return(View());
}
//Create an email message object
System.Net.Mail.MailMessage email = new System.Net.Mail.MailMessage();
//Populate the object
email.To.Add("*****@*****.**");
email.From = new System.Net.Mail.MailAddress(contactMessage.Email);
email.Subject = "This is our email to you!";
email.Body = string.Format(
"Name: {0}\r\nMessage: {1}",
contactMessage.Name,
contactMessage.Message
);
email.IsBodyHtml = false;
//Setup an SMTP client to send the messages
System.Net.Mail.SmtpClient smptClient = new System.Net.Mail.SmtpClient();
smptClient.Host = "smtp.fuse.net";
//Send the message
smptClient.Send(email);
//Create an instance on our DbContext
using (wsadDbContext context = new wsadDbContext())
{
//Create Correspondence DTO
Correspondence newCorrespondenceDTO = new Correspondence()
{
Name = contactMessage.Name,
Email = contactMessage.Email,
Message = contactMessage.Message
};
//Add to DbContext
context.Correspondences.Add(newCorrespondenceDTO);
//Save Changes
context.SaveChanges();
}
//Notify the user that the message was sent
return(View("emailConfirmation"));
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="TestableCorrespondence00" /> class.
/// </summary>
TestableCorrespondence00() : base(
correspondence: Correspondence.Analyze(
data),
rowProfiles: TestableRowProfiles00.Get(),
columnProfiles: TestableColumnProfiles00.Get()
)
{
}
/// <summary>Initializes a new instance of the
/// <see cref="TestableCorrespondence"/>
/// class.</summary>
/// <param name="correspondence">The correspondence to test.</param>
/// <param name="rowProfiles">The expected row profiles.</param>
/// <param name="columnProfiles">The expected column profiles.</param>
public TestableCorrespondence(
Correspondence correspondence,
TestablePrincipalProjections rowProfiles,
TestablePrincipalProjections columnProfiles
)
{
this.Correspondence = correspondence;
this.RowProfiles = rowProfiles;
this.ColumnProfiles = columnProfiles;
}
public IHttpActionResult DeleteInformedCorrespondence(int id)
{
Correspondence corres = db.Correspondences.Find(id);
if (corres == null)
{
return(NotFound());
}
db.Correspondences.Remove(corres);
db.SaveChanges();
return(Ok(corres));
}
public Int64 SaveCorrespondence(CorrespondenceVM model, long RequestId)
{
var correspondence = new Correspondence()
{
CorrespondenceTypeId = model.CorrespondenceTypeId,
RequestId = RequestId,
Body = model.Body,
Date = DateTime.Now
};
_context.Correspondences.Add(correspondence);
_context.SaveChanges();
return(correspondence.CorrespondenceId);
}
private void TestGetPoint_InvalidEnum_Helper()
{
Point staticPoint = Auxilaries.RandomPoint();
Point modelPoint = Auxilaries.RandomPoint();
Correspondence correspondence = new Correspondence(
staticPoint: staticPoint,
modelPoint: modelPoint
);
Fragment.ICPFragmentType type = (Fragment.ICPFragmentType) 99;
correspondence.GetPoint(type);
}
private void DrawCorrespondence(Correspondence correspondence)
{
GL.Color(correspondence.Color);
GL.Vertex3(
correspondence.StaticPoint.Position.x,
correspondence.StaticPoint.Position.y,
correspondence.StaticPoint.Position.z
);
GL.Vertex3(
correspondence.ModelPoint.Position.x,
correspondence.ModelPoint.Position.y,
correspondence.ModelPoint.Position.z
);
}
public async Task <IHttpActionResult> DeleteCorrespondence(int id)
{
Correspondence correspondence = await db.Correspondences.FindAsync(id);
if (correspondence == null)
{
ModelState.AddModelError("Message", "Correspondence not found!");
return(BadRequest(ModelState));
}
db.Correspondences.Remove(correspondence);
await db.SaveChangesAsync();
return(Ok(correspondence));
}
public void TestEquals_ModelPointNotEqual()
{
Correspondence thisCorrespondence = new Correspondence(
new Point(new Vector3(1.0f, 2.0f, 2.0f)),
new Point(new Vector3(3.0f, 4.0f, 5.0f))
);
Correspondence otherCorrespondence = new Correspondence(
new Point(new Vector3(1.0f, 2.0f, 2.0f)),
new Point(new Vector3(3.0f, 7.0f, 5.0f))
);
bool expected = false;
bool actual = thisCorrespondence.Equals(otherCorrespondence);
Assert.That(actual, Is.EqualTo(expected));
}
public void TestGetPoint_StaticPoint()
{
Point staticPoint = Auxilaries.RandomPoint();
Point modelPoint = Auxilaries.RandomPoint();
Correspondence correspondence = new Correspondence(
staticPoint: staticPoint,
modelPoint: modelPoint
);
Fragment.ICPFragmentType type = Fragment.ICPFragmentType.Static;
Point actual = correspondence.GetPoint(type);
Assert.AreEqual(staticPoint, actual);
}
public async Task <ActionResult> Search([Bind(Include = "Email,Closeness")] Correspondence associate)
{
string eMail = associate.Email.Trim().TrimStart('@');
IEnumerable <Correspondence> result = await GetResults(eMail);
ViewBag.SearchEmail = (eMail.Contains('@')? "" : "people in ") + eMail;
if (result == null || result.Count() == 0)
{
return(View("NoResults"));
}
else
{
return(View("SearchResults", result));
}
}
public async Task <IHttpActionResult> GetCorrespondenceByTradeIdAndId(string loggedOnTrader, int id)
{
Correspondence corres = await db.Correspondences.FindAsync(id);
if (corres == null)
{
ModelState.AddModelError("Message", "Correspondence not found!");
return(BadRequest(ModelState));
}
PersonalDetailsDTO personalDetailsSender = ((OkNegotiatedContentResult <PersonalDetailsDTO>)pdctr.GetPersonalDetailsByTraderId(corres.traderIdSender)).Content;
PersonalDetailsDTO personalDetailsReciever = ((OkNegotiatedContentResult <PersonalDetailsDTO>)pdctr.GetPersonalDetailsByTraderId(corres.traderIdReceiver)).Content;
// TODO do this if the status is not already read!!!!
if (loggedOnTrader == corres.traderIdSender)
{
corres.statusSender = "Sent";
}
else if (corres.statusReceiver == "New")
{
corres.statusReceiver = "Read";
}
db.SaveChanges();
CorrespondenceDTO mesdto = new CorrespondenceDTO();
mesdto.id = corres.id;
mesdto.subject = db.Trades.First(tro => tro.tradeId == corres.tradeId).name;
mesdto.message = corres.message;
mesdto.content = corres.content;
mesdto.statusSender = corres.statusSender;
mesdto.statusReceiver = corres.statusReceiver;
mesdto.dateSent = corres.dateSent;
mesdto.tradeId = corres.tradeId;
mesdto.traderIdSender = corres.traderIdSender;
mesdto.traderIdReceiver = corres.traderIdReceiver;
mesdto.sender = personalDetailsSender.firstName + " " + personalDetailsSender.middleName + " " + personalDetailsSender.lastName;
mesdto.receiver = personalDetailsReciever.firstName + " " + personalDetailsReciever.middleName + " " + personalDetailsReciever.lastName;
return(Ok(mesdto));
}
public async Task <string> InsertAsync(Correspondence model)
{
using (var connection = _connectionFactory.GetConnection)
{
var query = "uspCorrespondencesInsert";
var parameters = new DynamicParameters();
parameters.Add("Type", model.Type);
parameters.Add("SenderId", model.SenderId);
parameters.Add("AddresseeId", model.AddresseeId);
parameters.Add("Subject", model.Subject);
parameters.Add("Body", model.Body);
parameters.Add("UserId", model.UserId);
var result = await connection.QuerySingleAsync <string>(query, param : parameters, commandType : CommandType.StoredProcedure);
return(result);
}
}
private void MultiplierTb_Enter(object sender, EventArgs e)
{
Correspondence.TryGetValue(sender as TextBox, out Point p);
CurrentSelected = p;
switch (wt[p.X, p.Y])
{
case WeightType.Add:
AddRb.Checked = true;
break;
case WeightType.Times:
MultiplyRb.Checked = true;
break;
case WeightType.Exp:
ExpRb.Checked = true;
break;
}
}
public bool Registrar(Cliente cliente)
{
RepositorioCliente repoCliente = new RepositorioCliente();
// valores por defecto
cliente.Activo = false;
cliente.Actualizado = DateTime.Now;
cliente.Creado = DateTime.Now;
if (repoCliente.Insertar(cliente))
{
var correspondencia = new Correspondence();
correspondencia.SendMessageClient(cliente);
return(true);
}
return(false);
}
public void saveCorrespondence(ContactEmailViewModel contactMessage)
{
//Create DBContext instance
using (WSADDbContext context = new WSADDbContext())
{
//Create correspondenceDTO
Correspondence correspondenceDTO = new Correspondence()
{
Name = contactMessage.Name,
Email = contactMessage.Email,
Message = contactMessage.Message
};
//Add to DbContext
correspondenceDTO = context.Correspondences.Add(correspondenceDTO);
//Save changes
context.SaveChanges();
}
}
/// <summary>
/// Sends message to the recipient and process result of operation.
/// </summary>
/// <param name="sender"></param>
/// <param name="recipient"></param>
/// <param name="subject"></param>
/// <param name="body"></param>
/// <returns></returns>
private async Task <Correspondence> SendMessage(EmailAddress sender, EmailAddress recipient, string subject, string body)
{
var correspondence = new Correspondence();
try
{
correspondence.SendDate = DateTime.Now;
await _emailService.SendAsync(new EmailMessage(sender, recipient, subject, body));
correspondence.Result = CorrespondenceResult.Ok;
}
catch (Exception ex)
{
correspondence.Result = CorrespondenceResult.Failed;
correspondence.ErrorMessage = ex.Message;
}
return(correspondence);
}
/// <summary>
/// Возвращает список переписок постранично
/// </summary>
/// <param name="page">номер страницы</param>
/// <param name="countCorrespondence">количество переписок на странице (до 50) </param>
/// <returns>Cписок переписок</returns>
public async Task <List <Correspondence> > GetCorrespondenceAsync(int page, int countCorrespondence = 10)
{
if (page < 0)
{
throw new InvalidParameterException("индекс страницы не может быть отрицательным");
}
if (countCorrespondence > 50)
{
throw new InvalidParameterException("Параметр countCorrespondence должен быть меньше 50");
}
var response = await webService.CreateResponse($"https://api.freelancehunt.com/threads?page={page}&per_page={countCorrespondence}", "GET", HttpMethod.Get, default(string));
string responseAsString = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new FreelanceHuntApiExeption(JObject.Parse(responseAsString));
}
return(Correspondence.ListCorrespondenceFromJson(responseAsString));
}
public void Test_Add_Correspondence()
{
Correspondence correspondence = Auxilaries.RandomCorrespondence();
CorrespondenceCollection actual = new CorrespondenceCollection();
actual.Add(correspondence);
List <Correspondence> expected_correspondences = new List <Correspondence> {
correspondence
};
List <Point> expected_modelpoints = new List <Point> {
correspondence.ModelPoint
};
List <Point> expected_staticpoints = new List <Point> {
correspondence.StaticPoint
};
Assert.That(actual.Correspondences, Is.EquivalentTo(expected_correspondences));
Assert.That(actual.ModelPoints, Is.EquivalentTo(expected_modelpoints));
Assert.That(actual.StaticPoints, Is.EquivalentTo(expected_staticpoints));
}
public bool CambiarClave(FormularioCambiarClave formulario)
{
RepositorioUsuario repositorio = new RepositorioUsuario();
if (repositorio.PorId(formulario.Usuario) is Usuario entidad)
{
if (entidad.Clave == formulario.ClaveAnterior)
{
entidad.Clave = formulario.NuevaClave;
if (repositorio.Editar(entidad))
{
var correspondencia = new Correspondence();
correspondencia.SendPasswordChange(entidad);
return(true);
}
}
}
return(false);
}
public async Task <IHttpActionResult> PutCorrespondence(int id, Correspondence correspondence)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("Message", "The correspondence details are not valid!");
return(BadRequest(ModelState));
}
if (id != correspondence.id)
{
ModelState.AddModelError("Message", "The correspondence id is not valid!");
return(BadRequest(ModelState));
}
db.Entry(correspondence).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CorrespondenceExists(id))
{
ModelState.AddModelError("Message", "Correspondence not found!");
return(BadRequest(ModelState));
}
else
{
throw;
}
}
Correspondence corres = await db.Correspondences.Where(cor => cor.id == id).FirstAsync();
return(Ok <Correspondence>(corres));
}
public async Task <IHttpActionResult> PostCorrespondence([FromBody] Correspondence correspondence)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("Message", "The correspondence details are not valid!");
return(BadRequest(ModelState));
}
try
{
correspondence.dateSent = TimeZone.CurrentTimeZone.ToLocalTime(correspondence.dateSent);
db.Correspondences.Add(correspondence);
await db.SaveChangesAsync();
//TODO do we need to return the DTO here???
Correspondence trdhis = await db.Correspondences.OrderByDescending(trhis => trhis.id).FirstAsync();
return(Ok <Correspondence>(trdhis));
}
catch (Exception)
{
ModelState.AddModelError("Message", "An unexpected error has occured during storing the trade history!");
return(BadRequest(ModelState));
}
}
public async Task <string> UpdateAsync(Correspondence model)
{
return(await _Repository.UpdateAsync(model));
}
