public void SendCurrentWeather()
{
UserList userList = new UserList();
List <string> users = userList.getUsers();
WSResponce respObject = new WSResponce();
current response = new current();
response = respObject.CurrentWeatherResponse(CurrentUrl);
ComposeMessage newMessage = new ComposeMessage();
string message = newMessage.CreateMessage(response);
ChromeOptions options = new ChromeOptions();
options.AddArgument(cache);
driver = new ChromeDriver(options);
StartPage startPage = new StartPage(driver);
startPage.GoToUrl();
foreach (string user in users)
{
startPage.OpenChat(user);
startPage.SendMesage(message);
}
driver.Quit();
}
public Result SendOTP(ComposeMessage model)
{
try
{
Log.Info("Sending OTP to " + model.Contact);
var AccountSid = ConfigurationManager.AppSettings["TwilioAccountSid"];
var AuthToken = ConfigurationManager.AppSettings["TwilioAuthToken"];
TwilioClient.Init(AccountSid, AuthToken);
var message = MessageResource.Create(
to: new PhoneNumber("+918288871108"),
from: new PhoneNumber("+17814104343"),
body: model.Message);
Dal.SaveOTP(model);
Log.Info("OTP sent to " + model.Contact);
return(new Result()
{
Status = 1, Message = "Success"
});
}
catch (Twilio.Exceptions.TwilioException e)
{
Log.Error(e.Message);
throw e;
}
catch (Exception e)
{
throw e;
}
}
public ComposeMessage GetOTP(ComposeMessage model, string ApiKey)
{
if (new BAL().CheckApiKeyValidity(ApiKey))
{
return(new BAL().GetOTPMessage(model));
}
else
{
return(null);
}
}
public ActionResult Add(ComposeMessage model)
{
if (ModelState.IsValid)
{
var transaction = new Transaction(IsolationLevel.ReadCommitted, "add message");
try
{
// add the message
var message = new MessageEntity
{
MessageType = model.Type,
Title = model.Title,
Body = model.Body,
CreateTime = DateTime.UtcNow,
StartTime = model.StartTime.ToUniversalTime(),
EndTime = model.EndTime.HasValue ? model.EndTime.Value.ToUniversalTime() : new DateTime?()
};
transaction.Add(message);
message.Save();
// add the devicemessage entities for all the tos
foreach (var device in model.Tos)
{
var dm = new DeviceMessageEntity
{
DeviceId = device.DeviceId,
MessageId = message.MessageId
};
transaction.Add(dm);
dm.Save();
}
transaction.Commit();
return(new EmptyResult());
}
catch (Exception ex)
{
transaction.Rollback();
throw new HttpException(417, Message.AddError);
}
finally
{
transaction.Dispose();
}
}
Response.StatusCode = 417;
Response.TrySkipIisCustomErrors = true;
return(PartialView("Edit", model));
}
static void Main(string[] args)
{
WSResponce respObject = new WSResponce();
string response = respObject.GetFormattedXml(CurrentUrl);
Console.WriteLine(response);
Console.WriteLine("__________________________");
ComposeMessage newMessage = new ComposeMessage();
MessageSending messageTemplate = new MessageSending();
messageTemplate.SendMessage(newMessage.CreateMessage(response));
Console.ReadLine();
}
public Result SendOTP(ComposeMessage model, string ApiKey)
{
if (new BAL().CheckApiKeyValidity(ApiKey))
{
return(new BAL().SendOTP(model));
}
else
{
return new Result()
{
Status = 0, Err_Message = "Invalid User Id"
}
};
}
public ActionResult Compose(string Contact)
{
try
{
Log.Info("Composing new message for " + Contact);
ComposeMessage model = new ComposeMessage();
model.Contact = Contact;
var response = JsonConvert.DeserializeObject <ComposeMessage>(Client.PostAsJsonAsync("GetOTP/" + Session["Auth"].ToString(), model).Result.Content.ReadAsStringAsync().Result);
return(View(response));
}
catch (Exception e)
{
Log.Error(e.Message);
ViewBag.ErrorMessage = e.Message;
return(View("Error"));
}
}
public ActionResult Send(ComposeMessage model)
{
try
{
Log.Info("Sending OTP to " + model.Contact);
var response = JsonConvert.DeserializeObject <Result>(Client.PostAsJsonAsync("SendOTP/" + Session["Auth"].ToString(), model).Result.Content.ReadAsStringAsync().Result);
if (response.Status == 1)
{
return(Redirect("/Account/SentMessages"));
}
return(View());
}
catch (Exception e)
{
Log.Error(e.Message);
ViewBag.ErrorMessage = e.Message;
return(View("Error"));
}
}
public ComposeMessage GetOTPMessage(ComposeMessage model)
{
Log.Info("GetOTP message called");
model.Message = "Hi. Your OTP is:";
Random rand = new Random();
for (int i = 0; i < 6; i++)
{
model.Message += rand.Next(0, 9);
}
Contacts model1 = new Contacts();
model1.Contact = model.Contact;
model1 = Dal.RetrieveCustomer(model1);
model.FirstName = model1.FirstName;
model.LastName = model1.LastName;
Log.Info("OTP sent to presentation");
return(model);
}
static void Main(string[] args)
{
string userInput = "";
TCP_Connection tcpConnection = new TCP_Connection();
bool connected = tcpConnection.ConnectTCP();
if (connected)
{
Console.WriteLine("Connected to server. Type \"Help\" for a list of commands.");
}
while (userInput != "quit" && connected)
{
userInput = Console.ReadLine().ToLower();
if (userInput == "help")
{
Console.WriteLine("Commands:");
Console.WriteLine("Compose Message");
Console.WriteLine("Query Topics");
Console.WriteLine("Create Topic");
Console.WriteLine("Delete Topic");
}
else if (userInput == "compose message")
{
ComposeMessage.Compose();
}
else if (userInput == "query topics")
{
QueryTopics.Query();
}
else if (userInput == "create topic")
{
ModifyTopics.CreateTopic();
}
else if (userInput == "delete topic")
{
ModifyTopics.DeleteTopic();
}
}
}
/// <summary>
/// Writes data to a file as Json.
/// </summary>
/// <param name="model"></param>
/// <returns>
/// int 1 if Success
/// int 0 if failure
/// </returns>
private int WriteJsonToFile(ComposeMessage model)
{
try
{
List <ComposeMessage> List = ReadAllJsonFromFile();
if (List == null)
{
List = new List <ComposeMessage>();
}
List.Add(model);
var serializer = new JsonSerializer();
using (StreamWriter file = File.CreateText(FilePath + @"\" + MessagesFileName))
using (JsonTextWriter writer = new JsonTextWriter(file))
serializer.Serialize(writer, List);
return(1);
}
catch (Exception e)
{
Log.Error(e.Message);
return(0);
}
}
public ActionResult ComposeMessage(ComposeMessage model)
{
if (!ModelState.IsValid)
{
SaveErrorsToTempData();
return(RedirectToAction("Messages"));
}
var contract = model.ToContract(LoggedUserId);
try {
Service.SendMessage(contract, AppConfig.HostAddress + Url.Action("Messages", "User"));
} catch (UserNotFoundException x) {
ModelState.AddModelError("ReceiverName", x.Message);
SaveErrorsToTempData();
return(RedirectToAction("Messages"));
}
TempData.SetStatusMessage(ViewRes.User.MessagesStrings.MessageSent);
return(RedirectToAction("Messages"));
}
public ActionResult ComposeMessage(ComposeMessage model)
{
if (!ModelState.IsValid)
{
SaveErrorsToTempData();
return(RedirectToAction("Messages"));
}
var contract = model.ToContract(LoggedUserId);
var mySettingsUrl = VocaUriBuilder.CreateAbsolute(Url.Action("MySettings", "User")).ToString();
var messagesUrl = VocaUriBuilder.CreateAbsolute(Url.Action("Messages", "User")).ToString();
try {
Service.SendMessage(contract, mySettingsUrl, messagesUrl);
} catch (UserNotFoundException x) {
ModelState.AddModelError("ReceiverName", x.Message);
SaveErrorsToTempData();
return(RedirectToAction("Messages"));
}
TempData.SetStatusMessage(ViewRes.User.MessagesStrings.MessageSent);
return(RedirectToAction("Messages"));
}
private void ComposeMessage_Click(object sender, RoutedEventArgs e)
{
ComposeMessage composeMessageWindow = new ComposeMessage();
composeMessageWindow.Show();
}
public ActionResult Edit(long messageId, ComposeMessage model)
{
var message = new MessageEntity(messageId);
if (message.IsNew)
{
throw new HttpException(404, SharedRes.Error.NotFound_Message);
}
if (ModelState.IsValid)
{
var transaction = new Transaction(IsolationLevel.ReadCommitted, "edit message");
try
{
// if the device list has missing devices create a new message and remove the intersecting devices from the old message
// only if the message has been delivered, otherwise remove the device message normally below
if (message.DeviceMessages.Where(x => x.DeliveryTime != null).Select(x => x.Device).Except(model.Tos).Any())
{
// remove the devices from the old message that are included in the new model
foreach (var device in message.DeviceMessages.Select(x => x.Device).Intersect(model.Tos))
{
var deviceMessage = new DeviceMessageEntity(device.DeviceId, message.MessageId);
transaction.Add(deviceMessage);
deviceMessage.Delete();
}
// create a new message for the model leaving the old message Already Delivered
message = new MessageEntity
{
MessageType = model.Type,
Title = model.Title,
Body = model.Body,
CreateTime = DateTime.UtcNow,
StartTime = model.StartTime.ToUniversalTime(),
EndTime =
model.EndTime.HasValue
? model.EndTime.Value.ToUniversalTime()
: new DateTime?()
};
transaction.Add(message);
}
else
{
// devices are only added to the message, none removed, so update the existing message
message.MessageType = model.Type;
message.Title = model.Title;
message.Body = model.Body;
message.CreateTime = DateTime.UtcNow;
message.StartTime = model.StartTime.ToUniversalTime();
message.EndTime =
model.EndTime.HasValue
? model.EndTime.Value.ToUniversalTime()
: new DateTime?();
transaction.Add(message);
}
message.Save();
// remove any removed device IDs,
// if messages have already been delivered a new message will be created above and nothing more will be done here
foreach (var device in message.DeviceMessages.Select(x => x.Device).Except(model.Tos))
{
var deviceMessage = new DeviceMessageEntity(device.DeviceId, message.MessageId);
transaction.Add(deviceMessage);
deviceMessage.Delete();
}
// add the devicemessage entities for all the tos
foreach (var device in model.Tos)
{
var dm = new DeviceMessageEntity(device.DeviceId, message.MessageId)
{
DeviceId = device.DeviceId,
MessageId = message.MessageId
};
transaction.Add(dm);
dm.Save();
}
transaction.Commit();
return(new EmptyResult());
}
catch (Exception ex)
{
transaction.Rollback();
throw new HttpException(417, Message.AddError);
}
finally
{
transaction.Dispose();
}
}
Response.StatusCode = 417;
Response.TrySkipIisCustomErrors = true;
return(PartialView(model));
}
public int SaveOTP(ComposeMessage model)
{
model.Time = DateTime.Now.ToString();
return(WriteJsonToFile(model));
}
private void btn_ComposeMessage_GetFirstConnection_Click(object sender, RoutedEventArgs e)
{
#region MyRegion
//if(LDUsers.LDGlobals.listAccounts.Count==0)
//{
// GlobusLogHelper.log.Info("Please Upload Accout");
// return;
//}
//if(string.IsNullOrEmpty(selectedAccount))
//{
// GlobusLogHelper.log.Info("Please select an account from drop down menu");
// return;
//}
//try
//{
// MessageContacts.Clear();
// GrpMess.Clear();
// chklstBox_Messages_ComposeMessage_FirstConnections.Items.Clear();
// LinkdInContacts.Clear();
// //LstComposeMsg.Items.Clear();
// chklstBox_Messages_ComposeMessage_FirstConnections.Items.Clear();
// new Thread(() =>
// {
// LinkdinAddFromID();
// }).Start();
//}
//catch
//{
//}
#endregion
try
{
if (LDGlobals.listAccounts.Count > 0)
{
Regex checkNo = new Regex("^[0-9]*$");
int processorCount = objUtils.GetProcessor();
int threads = 25;
int maxThread = 25 * processorCount;
ComposeMessage objComposeMessage = new ComposeMessage();
Thread GroupStatusThread = new Thread(objComposeMessage.StarGetFirstConnection);
GroupStatusThread.Start();
}
else
{
GlobusLogHelper.log.Info("Please Load Accounts !");
GlobusLogHelper.log.Debug("Please Load Accounts !");
}
}
catch (Exception ex)
{
GlobusLogHelper.log.Error("Error : " + ex.StackTrace);
}
}
