/// <summary>
/// Past een Sms aan in de database.
/// </summary>
/// <param name="smsDTO">de aan te passen sms</param>
public async Task RequestEditSms(SmsDTO smsDTO)
{
using (ISendSMSHostContext db = new SendSMSHostContext())
{
Sms sms = Sms.FindSmsById(smsDTO.Id, db);
Debug.Print(sms.Status.Name);
sms.CopyFromSmsDTO(smsDTO, db);
Debug.Print(sms.Status.Name);
//db.Set<Sms>().Attach(sms);
//db.Entry(sms).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
await UpdateLog(db, smsDTO, "PUT");
NotifyEditSms(smsDTO, Clients);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
public IHttpActionResult Get(string param)
{
TelnetData.Crypto tn = new TelnetData.Crypto();
NegocioSQL.Facturacion facturacion = new NegocioSQL.Facturacion();
SmsDTO smsDTO = new SmsDTO();
try
{
string idComprobanteDesencriptado = tn.Decrypt(param.Replace("SLASH", "/").Replace("PLUS", "+"), "Un5e_223f12").Trim();
string tipoTexto = idComprobanteDesencriptado.Substring(idComprobanteDesencriptado.LastIndexOf("TEXTO"));
idComprobanteDesencriptado = idComprobanteDesencriptado.Substring(0, idComprobanteDesencriptado.IndexOf("TEXTO"));
smsDTO.IdComprobante = idComprobanteDesencriptado;
string template = tipoTexto.Substring(tipoTexto.Length - 1);
string descripcion = facturacion.GetTemplateSmsbyTemplate(template);
smsDTO.Template = descripcion;
}
catch (Exception ex)
{
Logger.Logueo("SMS Error en el proceso " + param + " " + ex.Message, Level.ErrorLog);
smsDTO.IdComprobante = "0";
}
return(this.Json(smsDTO));
}
/// <summary>
/// Algemene methode om clients te verwittigen van wijzigingen
/// Zorgt voor volledige herinladen lijst
/// Voor gebruik door server
/// </summary>
/// <param name="hubContext"></param>
/// <param name="smsDTO"></param>
/// <param name="operation"></param>
public static async Task NotifyChange(IHubContext hubContext, SmsDTO smsDTO, string operation)
{
using (ISendSMSHostContext db = new SendSMSHostContext())
{
await UpdateLog(db, smsDTO, operation);
}
switch (operation)
{
case "POST":
hubContext.Clients.All.notifyCreateSms(smsDTO);
break;
case "PUT":
hubContext.Clients.All.notifyEditSms(smsDTO);
break;
case "DELETE":
hubContext.Clients.All.notifyDeleteSms(smsDTO);
break;
default:
hubContext.Clients.All.notifyChangeToSmsList();
break;
}
hubContext.Clients.All.notifyChangeToCharts();
}
/// <summary>
/// update a user info
/// </summary>
/// <param name="smsDTO"></param>
public void UpdateSms(SmsDTO smsDTO)
{
if (smsDTO == null || smsDTO.Id == Guid.Empty)
{
throw new ArgumentException(Messages.warning_CannotUpdateSmsWithEmptyInformation);
}
//get persisted item
var persisted = _smsRepository.Get(smsDTO.Id);
if (persisted != null) //if customer exist
{
//materialize from customer dto
var current = MaterializeSmsFromDto(smsDTO);
//Merge changes
_smsRepository.Merge(persisted, current);
//commit unit of work
_smsRepository.UnitOfWork.Commit();
}
else
{
LoggerFactory.CreateLog().LogWarning(Messages.warning_CannotUpdateNonExistingSms);
}
}
/// <summary>
/// Geeft aan telefoon de opdracht om een sms te zenden, ongeacht de huidige status
/// </summary>
/// <param name="smsID">Id van de sms</param>
public async Task SendSelectedSms(Guid smsId)
{
using (ISendSMSHostContext db = new SendSMSHostContext())
{
var smsDTO = new SmsDTO(await db.Sms.SingleOrDefaultAsync(x => x.Id == smsId));
Clients.Others.sendSelectedSms(smsDTO);
}
}
public static SmsDTO SmsToDTO(this Sms sms)
{
var dto = new SmsDTO
{
Sender = sms.Sender,
Body = sms.Body
};
return dto;
}
Sms MaterializeSmsFromDto(SmsDTO smsDTO)
{
var current = SmsFactory.CreateSms(smsDTO.Code, smsDTO.Mobile, smsDTO.Type, smsDTO.IP, smsDTO.ValidateState);
current.ChangeCurrentIdentity(smsDTO.Id);
return(current);
}
/// <summary>
/// Brengt andere clients op de hoogte dat een bepaalde SmsDTO aangepast is
/// Zorgt voor volledige herinladen lijst
/// </summary>
/// <param name="smsDTOWithClient">de aangepaste SmsDTO met bewerkingsgegevens</param>
public async void NotifyChange(SmsDTO smsDTO, string operation)
{
using (ISendSMSHostContext db = new SendSMSHostContext())
{
Clients.Others.notifyChangeToSmsList();
Clients.All.notifyChangeToCharts();
await UpdateLog(db, smsDTO, operation);
}
}
public async void Enqueue(int batchsize)
{
// nieuwe dbContext opvragen
using (SendSMSHostContext db = new SendSMSHostContext())
{
// De lijst van sms'en met de status Queued of Pending aanvullen tot batchSize
// aanpassen in database + clients verwittigen
Status statusQueued = db.Status.FirstOrDefault(x => x.Name == "Queued");
Status statusPending = db.Status.FirstOrDefault(x => x.Name == "Pending");
Status statusCreated = db.Status.FirstOrDefault(x => x.Name == "Created");
int queuedCount = statusQueued.Sms.Count();
int createdCount = statusCreated.Sms.Count();
int amountToChange = 0;
if (batchsize > queuedCount)
{
amountToChange = Math.Min(batchsize - queuedCount, createdCount);
}
if (amountToChange > 0)
{
Debug.WriteLine($"[{DateTime.Now}] Enqueuing {amountToChange} sms");
var changeToQueuedSmsList = statusCreated.Sms
.OrderBy(z => z.TimeStamp)
.Take(amountToChange)
.ToList();
var queuedSmsDTOList = new List <SmsDTO>();
foreach (var sms in changeToQueuedSmsList)
{
sms.Status = statusQueued;
sms.TimeStamp = DateTime.Now;
SmsDTO smsDTO = new SmsDTO(sms);
try
{
await db.SaveChangesAsync();
await ServerSentEventsHub.NotifyChange(_signalRContext,
smsDTO : smsDTO,
operation : "PUT");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
}
public static async Task UpdateLog(ISendSMSHostContext db, SmsDTO smsDTO, string operation)
{
db.Log.Add(new Log
{
SmsId = smsDTO.Id,
Operation = operation,
Timestamp = DateTime.Now,
StatusName = smsDTO.StatusName
});
await db.SaveChangesAsync();
}
public async Task <IActionResult> SendSms([FromBody] SmsDTO smsDTO)
{
await _smsService.SendSmsAsync(smsDTO.From, smsDTO.To, smsDTO.Text);
_context.Messages.Add(new Models.Message
{
To = smsDTO.To,
From = smsDTO.From,
Text = smsDTO.Text,
SendDate = DateTime.Now
});
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> SignIn([FromBody] SmsDTO sms)
{
if (sms == null || !TryValidateModel(sms))
{
return(BadRequest(ModelState));
}
Worker worker = await workerService.SignInAsync(sms);
if (worker != null)
{
return(Ok(worker.ApiKey));
}
return(NotFound());
}
/// <summary>
/// news a account
/// </summary>
/// <param name="praiseDTO"></param>
/// <returns></returns>
public SmsDTO AddNewSms(SmsDTO smsDTO)
{
//check preconditions
if (smsDTO == null)
{
throw new ArgumentException(Messages.warning_CannotAddSmsWithEmptyInformation);
}
//Create the entity and the required associated data
var sms = SmsFactory.CreateSms(smsDTO.Code, smsDTO.Mobile, smsDTO.Type, smsDTO.IP, smsDTO.ValidateState);
//save entity
SaveSms(sms);
//return the data with id and assigned default values
return(sms.ProjectedAs <SmsDTO>());
}
public async Task <Worker> SignInAsync(SmsDTO smsInfo)
{
SMSCode sms = await db.SMSCodes.FirstOrDefaultAsync(s => s.Phone == smsInfo.Phone && s.Code == smsInfo.Code);
Worker worker = await db.Workers.FirstOrDefaultAsync(c => c.Phone == smsInfo.Phone);
if (sms == null || worker == null)
{
return(null);
}
await db.SMSCodes.RemoveAsync(sms);
worker.ApiKey = encryptService.GenerateHash(sms.Phone, sms.Code.ToString());
await db.Workers.UpdateAsync(worker);
return(worker);
}
public async Task <Client> SignInAsync(SmsDTO smsInfo)
{
SMSCode sms = await db.SMSCodes.FirstOrDefaultAsync(s => s.Phone == smsInfo.Phone && s.Code == smsInfo.Code);
Client client = await db.Clients.FirstOrDefaultAsync(c => c.Phone == smsInfo.Phone);
if (sms == null || client == null)
{
return(null);
}
await db.SMSCodes.RemoveAsync(sms);
client.ApiKey = encrypt.GenerateHash(sms.Phone, sms.Code.ToString());
await db.Clients.UpdateAsync(client);
return(client);
}
public async Task <IActionResult> SignIn([FromBody] SmsDTO sms)
{
if (sms == null || !TryValidateModel(sms))
{
return(BadRequest(ModelState));
}
Client client = await clientService.SignInAsync(sms);
if (client != null)
{
return(Json(new
{
api_key = client.ApiKey,
car_model = client.CarModel,
car_colour = client.CarColour
}));
}
return(NotFound());
}
public async Task <ApiResponse <bool> > EditSMS(SmsDTO model)
{
ApiResponse <bool> result = new ApiResponse <bool>();
try
{
var smsResult = await unitOfWork.SMSManager.GetAsync();
List <SMS> smsList = smsResult.ToList();
SMS smsToUpdate = smsList[0];
smsToUpdate.Body = model.Body;
var res = await unitOfWork.SMSManager.UpdateAsync(smsToUpdate);
await unitOfWork.SaveChangesAsync();
if (res == true)
{
result.Data = true;
result.Succeeded = true;
return(result);
}
else
{
result.Succeeded = false;
result.Errors.Add("Failed to edit SMS !");
return(result);
}
}
catch (Exception ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
return(result);
}
}
/// <summary>
/// Verwijdert een Sms in de database.
/// </summary>
/// <param name="smsDTO">de te verwijderen sms</param>
public async Task RequestDeleteSms(SmsDTO smsDTO)
{
using (ISendSMSHostContext db = new SendSMSHostContext())
{
Sms sms = await db.Sms.FindAsync(Guid.Parse(smsDTO.Id));
if (sms != null)
{
db.Sms.Remove(sms);
try
{
await db.SaveChangesAsync();
await UpdateLog(db, smsDTO, "DELETE");
NotifyDeleteSms(smsDTO, Clients);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
}
/// <summary>
/// Maakt een Sms in de database.
/// </summary>
/// <param name="smsDTO">de te maken sms</param>
public async Task RequestCreateSms(SmsDTO smsDTO)
{
using (ISendSMSHostContext db = new SendSMSHostContext())
{
// Indien ContactId == null dan opzoeken of nieuw contact voorzien
if (String.IsNullOrWhiteSpace(smsDTO.ContactId))
{
// kijken of nummer al in gebruik is
Contact contact = db.Contacts
.SingleOrDefault(x => x.Number == smsDTO.ContactNumber);
if (contact == null) // nieuw contact maken
{
contact = new Contact
{
Id = Guid.NewGuid(),
FirstName = "",
LastName = "",
Number = smsDTO.ContactNumber,
IsAnonymous = true
};
db.Contacts.Add(contact);
try
{
await db.SaveChangesAsync();
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw;
}
}
smsDTO.ContactId = contact.Id.ToString();
smsDTO.ContactFirstName = contact.FirstName;
smsDTO.ContactLastName = contact.LastName;
}
Status statusCreated = db.Status.FirstOrDefault(x => x.Name == "Created");
Sms sms = new Sms(smsDTO, db)
{
TimeStamp = DateTime.Now,
Status = statusCreated
};
db.Sms.Add(sms);
try
{
await db.SaveChangesAsync();
smsDTO = new SmsDTO(await db.Sms
.SingleOrDefaultAsync(x => x.Id == sms.Id));
await UpdateLog(db, smsDTO, "POST");
NotifyCreateSms(smsDTO, Clients);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
public async Task<IActionResult> EditSMS(SmsDTO model)
{
return await EditItemResponseHandler(async () => await service.EditSMS(model));
}
public async void Import()
{
// nieuwe context opvragen
using (var db = new SendSMSHostContext())
{
int importSmsCount = db.ImportSms.Count();
if (importSmsCount > 0)
{
Debug.WriteLine($"[{DateTime.Now}] Importing {importSmsCount} sms");
Status statusCreated = db.Status.FirstOrDefault(x => x.Name == "Created");
// eerst alle bestaande contacten zonder contactgegevens updaten waar mogelijk
var contactUpdateList = db.ImportSms
.Where(x => !((x.ContactFirstName == null || x.ContactFirstName == "") &&
(x.ContactLastName == null || x.ContactLastName == "")))
.Select(x => new
{
Number = x.ContactNumber,
FirstName = x.ContactFirstName ?? String.Empty,
LastName = x.ContactLastName ?? String.Empty
})
.GroupBy(k => k.Number)
.Select(g => g.FirstOrDefault())
.Where(x => db.Contacts
.Where(y => y.IsAnonymous)
.Select(z => z.Number)
.Contains(x.Number))
.AsEnumerable()
.Select(x => new Contact
{
Id = Guid.NewGuid(),
Number = x.Number,
IsAnonymous = false,
FirstName = x.FirstName,
LastName = x.LastName
});
foreach (var contact in contactUpdateList)
{
var oldContact = db.Contacts.Single(x => x.Number == contact.Number);
oldContact.FirstName = contact.FirstName;
oldContact.LastName = contact.LastName;
oldContact.IsAnonymous = contact.IsAnonymous;
}
int contactUpdateListCount = contactUpdateList.Count();
// dan alle nieuwe contacten met contactgegevens aanmaken
var contactNameList = db.ImportSms
.Where(x => !((x.ContactFirstName == null || x.ContactFirstName == "") &&
(x.ContactLastName == null || x.ContactLastName == "")))
.Select(x => new
{
Number = x.ContactNumber,
FirstName = x.ContactFirstName ?? String.Empty,
LastName = x.ContactLastName ?? String.Empty
})
.GroupBy(k => k.Number)
.Select(g => g.FirstOrDefault())
.Where(x => !db.Contacts
.Select(y => y.Number)
.Contains(x.Number))
.AsEnumerable()
.Select(x => new Contact
{
Id = Guid.NewGuid(),
Number = x.Number,
IsAnonymous = false,
FirstName = x.FirstName,
LastName = x.LastName
});
db.Contacts.AddRange(contactNameList);
int contactNameListCount = contactNameList.Count();
// dan alle nieuwe contacten zonder contactgegevens aanmaken
var contactNumberList = db.ImportSms
.Where(x => (x.ContactFirstName == null || x.ContactFirstName == "") &&
(x.ContactLastName == null || x.ContactLastName == ""))
.Select(x => x.ContactNumber)
.Distinct()
.Where(x => !db.Contacts
.Select(y => y.Number)
.Contains(x))
.AsEnumerable()
.Select(x => new Contact
{
Id = Guid.NewGuid(),
Number = x,
IsAnonymous = true
});
db.Contacts.AddRange(contactNumberList);
int contactNumberListCount = contactNumberList.Count();
try
{
await db.SaveChangesAsync();
Debug.WriteLine($"[{DateTime.Now}] Updated {contactUpdateListCount} anonymous contacts");
Debug.WriteLine($"[{DateTime.Now}] Created {contactNameListCount} new contacts");
Debug.WriteLine($"[{DateTime.Now}] Created {contactNumberListCount} new anonymous contacts");
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw ex;
}
// dan alle sms'en aanmaken
var smsToImport = db.ImportSms
.AsEnumerable()
.Select(x => new Sms
{
Id = Guid.NewGuid(),
Contact = db.Contacts
.SingleOrDefault(y => y.Number == x.ContactNumber),
Message = x.Message,
Status = statusCreated,
TimeStamp = DateTime.Now,
})
.ToList();
db.Sms.AddRange(smsToImport);
// dan ImportSms leeg maken
db.ImportSms.RemoveRange(db.ImportSms);
try
{
await db.SaveChangesAsync();
Debug.WriteLine($"[{DateTime.Now}] Created {importSmsCount} new sms");
foreach (Sms s in smsToImport)
{
SmsDTO smsDTO = new SmsDTO(s);
await ServerSentEventsHub.NotifyChange(_signalRContext,
smsDTO : smsDTO,
operation : "POST");
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw ex;
}
}
}
}
public IHttpActionResult Post(SmsViewModel value)
{
if (!Pool <MobileRegex> .Instance.IsMatch(value.UserName))
{
return(Ok <string>(Messages.error_ValidateMobileFormat));
}
var accountDTO = this._accountAppService.FindAccount(value.UserName);
if (value.Action == "Login" || value.Action == "ForgotPwd" || value.Action == "ModifyMobile")
{
if (accountDTO == null)
{
return(Ok <string>(Messages.error_ValidateMobileNotReisterExisting));
}
if (!accountDTO.IsEnabled)
{
return(Ok <string>(Messages.error_ValidateMobileFreeze));
}
}
else if (value.Action == "Register")
{
if (accountDTO != null)
{
return(Ok <string>(Messages.error_ValidateMobileReisterExisting));
}
}
else
{
throw new ArgumentNullException();
}
SmsDTO smsDTO = this._smsAppService.FindSms(value.UserName);
if (smsDTO != null && (DateTime.Now - smsDTO.CreateDate).TotalMinutes < 1)
{
return(Ok <string>(Messages.error_ValidateSmsTimeCount));
}
var smsCode = CharHelper.GetRandomSmsCode(6);
//向指定的用户发送短信
var codeTag = value.Action == "Login" ? 30351 : value.Action == "ModifyPwd" ? 8412 : value.Action == "ModifyMobile" ? 8413 : 8411;
CodeSms codeSms = new DistributedServices.Seedwork.Sms.CodeSms(value.UserName, codeTag, string.Format("#app#={0}&#code#={0}&#hour#={0}", "来运吧物流", smsCode, 1));
SmsSendServer.SendSmsResult result = codeSms.Send();
if (result.ToString().Equals("Fail"))
{
return(Ok <string>(codeSms.ErrorMsg));
}
var ip = UrlHelper.GetClientIP();
var resultSmsDTO = this._smsAppService.AddNewSms(new Application.MainBoundedContext.DTO.SmsDTO()
{
Code = smsCode,
CreateDate = DateTime.Now,
IP = ip,
Mobile = value.UserName,
ValidateState = 0,
Type = value.SmsType
});
return(Json <dynamic>(new { data = resultSmsDTO, total = 1 }));
}
public void NotifyDeleteSms(SmsDTO smsDTO, IHubCallerConnectionContext <dynamic> clients)
{
clients.All.notifyDeleteSms(smsDTO);
clients.All.notifyChangeToCharts();
}
