public async Task <CommunicationResponse> Handle(SendSMSRequest Request, CancellationToken cancellationToken)
{
try
{
var Message = new MessagingQueue()
{
MobileNo = Request.MobileNo,
SMSText = Request.Message,
SMSSendBy = 0,
Status = Convert.ToInt16(MessageStatusType.Initialize),
CreatedBy = 1,
CreatedDate = DateTime.UtcNow
};
_MessageRepository.Add(Message);
Message.InQueueMessage();
_MessageRepository.Update(Message);
IQueryable Result = await _MessageConfiguration.GetAPIConfigurationAsync(1, 1);
foreach (CommunicationProviderList g in Result)
{
await _MessageService.SendSMSAsync(Message.MobileNo, Message.SMSText, g.SMSSendURL, g.SenderID, g.UserID, g.Password);
}
return(await Task.FromResult(new CommunicationResponse { ErrorCode = 101, ReturnMsg = "Message sent." }));
}
catch (Exception ex)
{
return(await Task.FromResult(new CommunicationResponse { ErrorCode = 99, ReturnMsg = "Message not sent." }));
}
}
public string Post(MessagingQueue message)
{
string Url = "http://localhost/MessagingQueues.WebApi/api/messagingqueues/senddata";
string result = "";
Random rnd = new Random();
var webrequest = WebRequest.Create(Url);
var enc = new UTF8Encoding(false);
var serializedJson = JsonConvert.SerializeObject(message);
var data = enc.GetBytes(serializedJson);
webrequest.Method = "POST";
webrequest.ContentType = "application/json";
webrequest.ContentLength = data.Length;
webrequest.Timeout = 500000000;
using (var sr = webrequest.GetRequestStream())
{
sr.Write(data, 0, data.Length);
}
var res = webrequest.GetResponse();
// ReSharper disable once AssignNullToNotNullAttribute
result = new StreamReader(res.GetResponseStream()).ReadToEnd();
return(result);
}
public static void SendMessage(int taskId)
{
var connection = new BaseHttpRequest.Connection();
MessagingQueue messagingQueue = new MessagingQueue();
connection.Post(messagingQueue);
Console.WriteLine("Generating a sample for task id {0}", taskId);
}
public static bool SendMessageQueueImplementation(DicomDataSet ds, string command, string sopInstanceUid, string path)
{
if (ds != null)
{
if (ds.IsHangingProtocolDataSet())
{
// Filter out the hanging protocol datasets because there is no cache for these
return(true);
}
}
bool messageQueueSuccess = true;
{
try
{
int width = 0;
int height = 0;
if (ds != null)
{
width = ds.GetValue <int>(DicomTag.Columns, 0);
height = ds.GetValue <int>(DicomTag.Rows, 0);
if (string.IsNullOrEmpty(sopInstanceUid))
{
sopInstanceUid = ds.GetValue <string>(DicomTag.SOPInstanceUID, string.Empty);
}
}
MessagingQueue.Send("storageserver", "19", command, new MessagingDicomFile()
{
FileName = path, Width = width, Height = height, SopInstanceUID = sopInstanceUid
});
}
catch (Exception ex)
{
Logger.Global.Log(string.Empty,
string.Empty,
0,
string.Empty,
string.Empty,
0,
DicomCommandType.Undefined,
DateTime.Now,
LogType.Warning,
MessageDirection.None,
"Message Queue Error': " + ex.Message, null, null);
messageQueueSuccess = false;
}
}
return(messageQueueSuccess);
}
public Task <SendSMSResponse> Handle(SendSMSRequest Request, CancellationToken cancellationToken)
{
var Message = new MessagingQueue()
{
MobileNo = Request.MobileNo,
SMSText = Request.Message,
SMSSendBy = 0,
Status = 0,
CreatedBy = 1,
CreatedDate = DateTime.UtcNow
};
_MessageRepository.Add(Message);
return(Task.FromResult(new SendSMSResponse {
ResponseCode = 101, ResponseMessage = "Message sent."
}));
}
public async Task <CommunicationResponse> Handle(SendSMSRequest Request, CancellationToken cancellationToken)
{
try
{
var Message = new MessagingQueue()
{
MobileNo = Request.MobileNo,
SMSText = Request.Message,
SMSSendBy = 0,
Status = Convert.ToInt16(enMessageService.Init),
CreatedBy = 1,
CreatedDate = DateTime.UtcNow
};
_MessageRepository.Add(Message);
Message.InQueueMessage();
_MessageRepository.Update(Message);
IQueryable Result = await _MessageConfiguration.GetAPIConfigurationAsync(1, 1);
foreach (CommunicationProviderList Provider in Result)
{
string Response = await _MessageService.SendSMSAsync(Message.MobileNo, Message.SMSText, Provider.SendURL, Provider.SenderID, Provider.UserID, Provider.Password);
//string Response = " GUID:2387354506261631296 , responseTime:2018-10-05 16:00:46";
CopyClass.CopyObject(Provider, ref _GetDataForParsingAPI);
_GenerateResponse = _WebApiParseResponse.ParseResponseViaRegex(Response, _GetDataForParsingAPI);
if (_GenerateResponse.Status == enTransactionStatus.Success)
{
Message.SentMessage();
Message.RespText = Response;
_MessageRepository.Update(Message);
return(await Task.FromResult(new CommunicationResponse { ReturnCode = enResponseCode.Success, ReturnMsg = EnResponseMessage.SMSSuccessMessage }));
}
else
{
continue;
}
}
Message.FailMessage();
_MessageRepository.Update(Message);
return(await Task.FromResult(new CommunicationResponse { ReturnCode = enResponseCode.Fail, ReturnMsg = EnResponseMessage.SMSFailMessage }));
}
catch (Exception ex)
{
return(await Task.FromResult(new CommunicationResponse { ReturnCode = enResponseCode.InternalError, ReturnMsg = EnResponseMessage.SMSExceptionMessage }));
}
}
public IHttpActionResult AddMessageQueue(MessagingQueue MessagingQueue)
{
try
{
MessagingQueue.FromUserId = this.ActiveUser.Id;
MessagingQueue.State = BaseState.Added;
Mgr.AddUpdate(MessagingQueue);
Unit.SaveChanges();
if (MessagingQueue.MessageType == SharedEnums.MessageType.Email)
{
Manager <User> UserManager = new Manager <User>(Unit);
var email = UserManager.FindById(MessagingQueue.ToUserId).Email;
var sender = UserManager.FindById(MessagingQueue.FromUserId);
SendUserCommunicationEmail(sender.FullName, MessagingQueue.Message, email);
}
if (MessagingQueue.MessageType == SharedEnums.MessageType.SystemMessgae)
{
Manager <Notification> NotMgr = new Manager <Notification>(Unit);
Notification not = new Notification()
{
State = BaseState.Added,
ToUserId = MessagingQueue.ToUserId,
FromUserId = MessagingQueue.FromUserId,
TextAr = MessagingQueue.Message,
TextEn = MessagingQueue.Message,
Type = SharedEnums.NotificationType.UserMessage,
MessagingQueueId = MessagingQueue.Id
};
NotMgr.AddUpdate(not);
Unit.SaveChanges();
}
return(Ok(MessagingQueue));
}
catch (Exception ex)
{
Unit.LogError(ex, this.ToString(), this.ActionContext.ActionArguments.ToList());
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> SendData(MessagingQueue model)
{
_queueManager.SendMessage(model.Message);
return(await Task.FromResult <IHttpActionResult>(Ok()));
}
