/// <summary>
/// Send an internal message through system.
/// </summary>
/// <param name="target">The steam person we are sending internal message to.</param>
/// <param name="type">The type of <see cref="InternalMessage"/> we want to send.</param>
internal bool SendInternal(ProductUserId target, InternalMessage type, SocketId socket)
{
Result sent = EpicManager.P2PInterface.SendPacket(new SendPacketOptions
{
AllowDelayedDelivery = true,
Channel = (byte)Options.Channels.Length,
Data = new[] { (byte)type },
LocalUserId = EpicManager.AccountId.ProductUserId,
Reliability = PacketReliability.ReliableOrdered,
RemoteUserId = target,
SocketId = socket
});
if (sent == Result.Success)
{
if (Transport.transportDebug)
{
DebugLogger.RegularDebugLog("[Client] - Packet sent successfully.");
}
}
else
{
if (Transport.transportDebug)
{
DebugLogger.RegularDebugLog($"[Client] - Packet failed to send. Results: {sent}");
}
}
return(sent == Result.Success);
}
public string Create([Bind(Include = "To,Mesage")] InternalMessage internalmessage)
{
if (ModelState.IsValid)
{
AspNetUser touser = db.AspNetUsers.SingleOrDefault(t => t.UserName == internalmessage.To);
if (touser == null)
{
return("Wrong UserID or Username!");
}
if (touser.Id == User.Identity.GetUserId())
{
return("FAIL");
}
internalmessage.To = touser.Id;
internalmessage.From = User.Identity.GetUserId();
internalmessage.DateCreate = DateTime.Now;
db.InternalMessages.Add(internalmessage);
db.SaveChanges();
return("OK");
}
ViewBag.From = new SelectList(db.AspNetUsers, "Id", "UserName", internalmessage.From);
ViewBag.To = new SelectList(db.AspNetUsers, "Id", "UserName", internalmessage.To);
return(null);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
if ((Request.QueryString["id"] != null) || (Request.QueryString["typ"] != null))
{
HF_ToID.Value = Request.QueryString["id"];
switch (Request.QueryString["typ"])
{
case "1":
RB_T1.Enabled = false;
break;
case "2":
RB_T2.Enabled = false;
break;
case "3":
RB_T3.Enabled = false;
break;
default:
RB_T1.Enabled = false;
RB_T2.Enabled = false;
RB_T3.Enabled = false;
IB_Send.Enabled = false;
L_Warning.Text = "Pls Refresh the page and try again";
break;
}
}
else
{
//Error 405
Server.Transfer("~/Extras/ErrorReport.aspx?id=405");
}
}
else // Update Databse
{
HttpCookieCollection objHttpCookieCollection = Request.Cookies;
HttpCookie objHttpCookie = objHttpCookieCollection.Get("MatCookie5639sb");
string strMtaID = Crypto.DeCrypto(objHttpCookie.Values["MatrimonialID"]);
if (RB_T1.Checked)
{
InternalMessage.IntrestApprovel(strMtaID, HF_ToID.Value, InternalMessage.IntrestStatus.Pending);
}
else if (RB_T2.Checked)
{
InternalMessage.IntrestApprovel(strMtaID, HF_ToID.Value, InternalMessage.IntrestStatus.Accepted);
}
else if (RB_T3.Checked)
{
InternalMessage.IntrestApprovel(strMtaID, HF_ToID.Value, InternalMessage.IntrestStatus.Declined);
}
Server.Transfer("~/Extras/sucess.aspx");
}
}
public async Task <bool> NotifySubscriptors(InternalMessage message)
{
bool result = false;
try
{
var jsonPayload = JsonConvert.SerializeObject(message);
logger.LogInformation("******* Using Dapr sidecar *******");
HttpRequestMessage httpRequestMessage = new HttpRequestMessage()
{
Method = HttpMethod.Post, RequestUri = new Uri($"http://localhost:{Settings.DAPR_HTTP_PORT}/v1.0/publish/{Settings.PUBSUB_COMPONENT_NAME}/{Settings.PUBSUB_TOPIC_NAME}"), Content = new StringContent(jsonPayload)
};
HttpResponseMessage httpResponseMessage = await httpClient.SendAsync(httpRequestMessage);
if (httpResponseMessage.IsSuccessStatusCode)
{
result = true;
}
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
}
return(result);
}
public void Delete()
{
if (this.CB_Delete.Checked)
{
HttpCookieCollection objHttpCookieCollection = Request.Cookies;
HttpCookie objHttpCookie = objHttpCookieCollection.Get("MatCookie5639sb");
string strMatID = Crypto.DeCrypto(objHttpCookie.Values["MatrimonialID"]);
switch (HF_Type.Value.ToLower())
{
case "photo":
InternalMessage.DeletePasswordRequest(L_RequestFrom_To.Text, strMatID, true);
break;
case "horoscope":
InternalMessage.DeletePasswordRequest(L_RequestFrom_To.Text, strMatID, false);
break;
default:
InternalMessage.DeletePasswordRequest(L_RequestFrom_To.Text, strMatID, true);
break;
}
}
}
public JsonResult GET(string BusID, string TeacherID, string ReportType, string Content)
{
if (!ValidateSession())
{
return(SessionError);
}
if (TeacherID != CurrentUser.ObjectId)
{
return(RequestIllegal);
}
if (DataBaseOperation.QuerySingle(new DBQuery().WhereIDIs(BusID).WhereEqualTo("TeacherObjectID", TeacherID), out SchoolBusObject bus) != DBQueryStatus.ONE_RESULT)
{
return(RequestIllegal);
}
BusReport busReport = new BusReport
{
BusID = BusID,
TeacherID = TeacherID,
ReportType = (BusReportTypeE)Convert.ToInt32(ReportType),
OtherData = Content
};
if (DataBaseOperation.CreateData(ref busReport) != DBQueryStatus.ONE_RESULT)
{
return(DataBaseError);
}
InternalMessage message_TP = new InternalMessage(InternalMessageTypes.Bus_Status_Report, CurrentUser, busReport, BusID);
MessagingSystem.AddMessageProcesses(message_TP);
return(Json(new { Report = busReport }));
}
public async Task ProcessMessage(InternalHubNetworkClient sender, InternalMessage msg)
{
if (msg == null)
{
return;
}
msg.Sender = sender.Name;
switch (msg.Type)
{
case InternalMessageType.Direct:
await SendDirect(sender, msg);
break;
case InternalMessageType.Broadcast:
await SendBroadcast(sender, msg);
break;
case InternalMessageType.Random:
await SendRandom(sender, msg);
break;
case InternalMessageType.RoundRobin:
await SendRoundRobin(sender, msg);
break;
}
}
private async Task SendRoundRobin(InternalHubNetworkClient sender, InternalMessage msg)
{
if (!msg.NoAck)
{
await Ack(msg.CorrelationId, sender);
}
while (_clients.Count > 0)
{
try
{
InternalHubNetworkClient socket = null;
lock (_roundRobinLock)
{
_roundRobinIndex++;
if (_roundRobinIndex >= _clients.Count)
{
_roundRobinIndex = 0;
}
socket = _clients.Values.ElementAt(_roundRobinIndex);
}
await SendAsync(socket, msg);
break;
}
catch (ArgumentOutOfRangeException)
{
continue;
}
}
}
private void OnInternalMessage(InternalMessage msg)
{
if (msg.Type == InternalMessageType.Heartbeat)
{
return;
}
if (_ackTasks.TryRemove(msg.CorrelationId, out var tcs))
{
if (msg.Type == InternalMessageType.Error)
{
tcs.TrySetException(new Exception(Encoding.UTF8.GetString(msg.Payload)));
}
else
{
tcs.TrySetResult(true);
}
}
else if (_directResponses.TryRemove(msg.CorrelationId, out var resp))
{
resp.TrySetResult(msg);
}
else
{
OnMessage?.Invoke(this, new Message
{
CorrelationId = msg.CorrelationId,
Payload = msg.Payload,
Sender = msg.Sender,
Type = (MessageType)msg.Type
});
}
}
public EpicMessage(ProductUserId connectionId, int channel, InternalMessage eventType, byte[] data)
{
EventType = eventType;
Data = data;
ConnectionId = connectionId;
Channel = channel;
}
protected void IMG_Grand_Click(object sender, ImageClickEventArgs e)
{
HttpCookieCollection objHttpCookieCollection = Request.Cookies;
HttpCookie objHttpCookie = objHttpCookieCollection.Get("MatCookie5639sb");
string strMatID = Crypto.DeCrypto(objHttpCookie.Values["MatrimonialID"]);
switch (HF_Type.Value.ToLower())
{
case "photo":
InternalMessage.GrandPhotoRequest(HF_ID.Value, strMatID, true);
IMG_Grand.Visible = false;
IMG_Granted.Visible = true;
break;
case "horoscope":
InternalMessage.GrandPhotoRequest(HF_ID.Value, strMatID, false);
IMG_Grand.Visible = false;
IMG_Granted.Visible = true;
break;
default:
IMG_Grand.Visible = false;
IMG_Granted.Visible = true;
break;
}
}
// GET: /InternalMessage/Create
public ActionResult Create(string To = null)
{
InternalMessage message = new InternalMessage();
message.To = To;
return(PartialView("Create", message));
}
private async Task SendBroadcast(InternalHubNetworkClient sender, InternalMessage msg)
{
if (!msg.NoAck)
{
await Ack(msg.CorrelationId, sender);
}
await Task.WhenAll(_clients.Values.Where(c => c.Name != sender.Name).Select(c => SendAsync(c, msg)));
}
public ActionResult Read(int id)
{
InternalMessage msg = MessageService.GetById(id);
msg.Read = true;
MessageService.UpdateEntitySaved(msg);
return(Content("ok"));
}
public ActionResult Unread(int id)
{
InternalMessage msg = MessageBll.GetById(id);
msg.Read = false;
MessageBll.UpdateEntitySaved(msg);
return(Content("ok"));
}
internal void ProcessInternalMessage(InternalMessage message)
{
switch (message.MessageType)
{
case InternalMessageType.ClientList:
StringReader reader = new StringReader(message.Content);
string client;
while ((client = reader.ReadLine()) != null)
{
AddConnectableClient(client);
}
break;
case InternalMessageType.ClientConnected:
AddConnectableClient(message.Content, onClientConnected);
break;
case InternalMessageType.ClientDisconnected:
ConnectableClients = ConnectableClients.Remove(message.Content);
onClientDisconnected?.Invoke(message.Content);
parent.onRemoteHostDisconnected?.Invoke();
break;
case InternalMessageType.RegistrationRequest:
parent.remoteHostName.Value = message.Sender;
break;
case InternalMessageType.ConnectionRequest:
parent.onRemoteJoinedHostName.Value = message.Content;
break;
case InternalMessageType.BroacastRequest:
short setBroadcastedType = short.Parse(message.Content);
switch (setBroadcastedType)
{
case (short)BroadcastSettingCodes.Cancel:
broadcastedType.Value = EMPTY_BROADCASTED_TYPE;
broadcastEverything.Value = false;
break;
case (short)BroadcastSettingCodes.BroadcastEverythingTrue:
broadcastEverything.Value = true;
break;
case (short)BroadcastSettingCodes.BroadcastEverythingFalse:
broadcastEverything.Value = false;
break;
default:
broadcastedType.Value = setBroadcastedType;
break;
}
break;
default:
break;
}
}
public void EnqueueMessage(InternalMessage message)
{
Ensure.NotNull(message, nameof(message));
_messageQueue.Enqueue(message);
if (Interlocked.CompareExchange(ref _isProcessing, 1, 0) == 0)
{
ThreadPool.QueueUserWorkItem(ProcessQueue);
}
}
public MongoMessage Message(InternalMessage msg)
{
return(new MongoMessage
{
Date = msg.Date,
FromId = msg.FromId,
Message = msg.Message,
ToId = msg.ToId
});
}
public static ChatMessage Map(this InternalMessage message)
{
return(new ChatMessage
{
CreateDate = message.CreateDate,
Message = message.Message,
Recipient = message.Recipient,
ConversationFinished = message.ConversationFinished
});
}
public JsonResult GET(string BusID, string TeacherID, string ReportType, string Content)
{
Dictionary <string, string> dict = new Dictionary <string, string>();
if (ValidateSession())
{
if (TeacherID != CurrentUser.ObjectId)
{
return(RequestIllegal);
}
if (DataBaseOperation.QuerySingleData(
new DBQuery()
.WhereEqualTo("objectId", BusID)
.WhereEqualTo("TeacherObjectID", TeacherID)
, out SchoolBusObject bus) != DBQueryStatus.ONE_RESULT)
{
return(RequestIllegal);
}
BusReport busReport = new BusReport
{
BusID = BusID,
TeacherID = TeacherID,
ReportType = (BusReportTypeE)Convert.ToInt32(ReportType),
OtherData = Content
};
if (DataBaseOperation.CreateData(ref busReport) == DBQueryStatus.ONE_RESULT)
{
InternalMessage message_TC = new InternalMessage()
{
DataObject = busReport,
ObjectId = BusID,
User = CurrentUser,
_Type = GlobalMessageTypes.Bus_Status_Report_TC
};
InternalMessage message_TP = new InternalMessage()
{
DataObject = busReport,
ObjectId = BusID,
User = CurrentUser,
_Type = GlobalMessageTypes.Bus_Status_Report_TP
};
MessagingSystem.AddMessageProcesses(message_TC, message_TP);
dict.Add("CreatedAt", busReport.CreatedAt.ToNormalString());
dict.Add("ErrCode", "0");
dict.Add("ReportID", busReport.ObjectId);
dict.Add("ErrMessage", "null");
}
else
{
return(DataBaseError);
}
}
return(Json(dict));
}
/// <summary>
/// </summary>
/// <param name="triggerTime">
/// </param>
/// <param name="obj">
/// </param>
public void Add(DateTime triggerTime, InternalMessage obj)
{
if (triggerTime <= DateTime.UtcNow)
{
this.playfieldBus.Publish(obj);
return;
}
this.TimerList.Add(new PlayfieldTimedListEntry(triggerTime, obj));
this.stillSorted = false;
}
public IActionResult RequestChange()
{
ViewData["where"] = ControllerName;
if (ValidateSession())
{
if (Request.HasFormContentType)
{
Microsoft.AspNetCore.Http.IFormCollection form = Request.Form;
UserChangeRequestTypes types = (UserChangeRequestTypes)Enum.Parse(typeof(UserChangeRequestTypes), form[nameof(UserChangeRequest.RequestTypes)][0]);
string reason = form[nameof(UserChangeRequest.DetailTexts)][0];
string newVal = form[nameof(UserChangeRequest.NewContent)][0];
UserChangeRequest request = new UserChangeRequest()
{
DetailTexts = reason,
SolverID = "",
NewContent = newVal,
Status = UCRProcessStatus.NotSolved,
RequestTypes = types,
UserID = CurrentUser.ObjectId
};
if (DataBaseOperation.CreateData(ref request) != DBQueryStatus.ONE_RESULT)
{
LW.E("AccountController->ProcessNewUCR: Create UCR Failed!");
return(DatabaseError(ServerAction.MyAccount_CreateChangeRequest, XConfig.Messages["CreateUCR_Failed"]));
}
InternalMessage messageAdmin = new InternalMessage()
{
_Type = GlobalMessageTypes.UCR_Created_TO_ADMIN, DataObject = request, User = CurrentUser, ObjectId = request.ObjectId
};
InternalMessage message_User = new InternalMessage()
{
_Type = GlobalMessageTypes.UCR_Created__TO_User, DataObject = request, User = CurrentUser, ObjectId = request.ObjectId
};
MessagingSystem.AddMessageProcesses(messageAdmin, message_User);
return(Redirect($"/{HomeController.ControllerName}/{nameof(HomeController.RequestResult)}?req=changereq&status=ok&callback=/Account/"));
}
else
{
ViewData["cUser"] = CurrentUser.ToString();
return(View(new UserChangeRequest()
{
UserID = CurrentUser.ObjectId
}));
}
}
else
{
return(LoginFailed("/" + ControllerName + "/" + nameof(RequestChange)));
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
// Filling Hiden Folder
HF_ToID.Value = Request.QueryString["id"];
if (HF_ToID.Value.Equals("")) // Error
{
Server.Transfer("../extras/Sucess.aspx?id=" + Server.UrlEncode("Error in url"));
}
txtCount.Text = TB_Message.MaxLength.ToString();
//Adding Attributes to Text Box
TB_Message.Attributes.Add("onKeyUp",
"javascript:document.getElementById('" + txtCount.ClientID +
"').setAttribute('value', (" + TB_Message.MaxLength +
" - parseInt(document.getElementById('" + TB_Message.ClientID +
"').getAttribute('value').length)));");
}
else
{
try
{
// Getting User Information
HttpCookieCollection objHttpCookieCollection = Request.Cookies;
HttpCookie objHttpCookie = objHttpCookieCollection.Get("MatCookie5639sb");
string strMatID = Crypto.DeCrypto(objHttpCookie.Values[2]);
// Send Message
switch (InternalMessage.SendMessage(strMatID, HF_ToID.Value, TB_Message.Text))
{
case true: // Sucess
Server.Transfer("../extras/Sucess.aspx?id=Your message has been send");
break;
default: // Oops some error had happened
Server.Transfer("../extras/Sucess.aspx?id=" + Server.UrlEncode("Sorry Server is not responding now"));
break;
}
}
catch (Exception Ex)
{
// Some unexpected error Write Log
ErrorLog.WriteErrorLog("Member-SendMessages.aspx", Ex);
}
}
}
public async Task <IActionResult> Notify()
{
InternalMessage message = new InternalMessage();
message.MessageId = Guid.NewGuid().ToString();
message.Description = $"Message {message.MessageId} description";
var result = await publisherSvc.NotifySubscriptors(message);
ActionResult actionResult = (result) ? StatusCode(200) : StatusCode(500);
return(actionResult);
}
public string DeleteConfirmed(string from, DateTime datecreate)
{
string to = User.Identity.GetUserId();
InternalMessage internalmessage = db.InternalMessages.SingleOrDefault(t => t.DateCreate.Hour == datecreate.Hour &&
t.DateCreate.Minute == datecreate.Minute &&
t.DateCreate.Second == datecreate.Second &&
t.From == from &&
t.To == to);
db.InternalMessages.Remove(internalmessage);
db.SaveChanges();
return("OK");
}
public ActionResult CreateMessage(SendMessage myMessage)
{
var internalMssage = new InternalMessage
{
Message = myMessage.message,
ReceiverID = myMessage.receiver.user.Id,
SenderID = User.Identity.GetUserId(),
Status = 0
};
_db.InternalMessages.Add(internalMssage);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Start the timer if running and there are intervals
/// The timer is set based on the lowest interval and removed from the list
/// </summary>
private void StartTimer()
{
lock (_lock)
{
if (!IsRunning || _getStack().Count == 0)
{
_timer?.Change(Timeout.Infinite, Timeout.Infinite);
return;
}
InternalMessage internalMessage = _getStack().Peek();
TimeSpan ts = internalMessage.EventDate - DateTime.Now;
_timer.Change(Math.Max((int)ts.TotalMilliseconds, 0), Timeout.Infinite);
}
}
private async Task SendAsync(InternalHubNetworkClient client, InternalMessage msg)
{
try
{
msg.Reciever = client.Name;
_logger.Trace("[{0}] Send message from client {1} to client {2} with id {3} with type {4}", _networkName, msg.Sender, msg.Reciever, msg.CorrelationId, msg.Type);
await client.SendAsync(msg);
}
catch (Exception)
{
_clients.TryRemove(client.Name, out var _);
}
}
private static void ProcessInternalMessage(InternalMessage m)
{
Logger.Info(m.DataString, "INT <");
switch (m.DataString)
{
case "GET_BM_SCREEN":
// TODO send last BM screen
if (BordmonitorMenu.Instance.IsEnabled)
{
BordmonitorMenu.Instance.UpdateScreen(/*MenuScreenUpdateReason.Refresh*/);
}
break;
}
}
protected void OnInternalMessageReceived(InternalMessage m)
{
var e = InternalMessageReceived;
if (e != null)
{
try
{
e(this, m);
}
catch (Exception ex)
{
Logger.Error(ex, "while processing incoming internal message");
}
}
}
