/// <summary>
/// 清空用户登录信息
/// </summary>
private void ClearUserLoginInfo()
{
var cookie = Request.Cookies["token"];
if (cookie != null)
{
RedisCacheHelper.RemoveCache(cookie.Value);
cookie.Expires = DateTime.Now.AddDays(-1);
Response.Cookies["token"].Expires = cookie.Expires;
}
if (!string.IsNullOrEmpty(PageReq.GetSession("UserId")))
{
Yinhe.ProcessingCenter.Permissions.AuthManage._().ReleaseCache(int.Parse(PageReq.GetSession("UserId")));
}
#region //清除全局author
GlobalBase.ReleaseAuthentication();
GlobalBase.ReleaseSysAuthentication(); //新权限缓存清楚
#endregion
FormsAuthentication.SignOut();
PageReq.ClearSession();
#region 记录登出日志
dataOp.LogSysBehavior(SysLogType.Logout, HttpContext);
#endregion
}
public void Update(List <UiInfo> membersToAdd)
{
try
{
if (membersToAdd?.Count != 0)
{
IsNewChanges = true;
_membersToAdd = membersToAdd;
var temp = new List <UiInfo>();
temp.AddRange(_membersToAdd);
temp.AddRange(GroupMemberList);
var defImage = Image.FromFile("../../Resources/DefaultPicture.jpg");
Task.Run(() =>
{
GlobalBase.loadPictures(UserServiceClient, temp);
}).ContinueWith(Task =>
{
GroupMemberList = temp;
});
}
}
finally
{
}
}
public void Send(string agregatorCode, Dictionary <DateTime, Dictionary <string, Dictionary <DateTime, Dictionary <Enums.MeasureType, double> > > > agregatorData)
{
if (agregatorCode.Length != 4)
{
throw new ArgumentException("Invalid code");
}
try
{
int.Parse(agregatorCode);
}
catch
{
throw new ArgumentOutOfRangeException("It must be number.");
}
if (agregatorData.Count <= 0)
{
try { }
catch (Exception e)
{
throw new ArgumentException("Dictionary is empty.");
}
}
using (var data = new GlobalBaseDBContex())
{
foreach (KeyValuePair <DateTime, Dictionary <string, Dictionary <DateTime, Dictionary <Enums.MeasureType, double> > > > prvi in agregatorData)
{
foreach (KeyValuePair <string, Dictionary <DateTime, Dictionary <Enums.MeasureType, double> > > drugi in prvi.Value)
{
foreach (KeyValuePair <DateTime, Dictionary <Enums.MeasureType, double> > treci in drugi.Value)
{
GlobalBase gb = new GlobalBase()
{
AgregatorCode = agregatorCode,
TimeStamp = prvi.Key.ToString(),
DeviceCode = drugi.Key,
DeviceTime = treci.Key.ToString(),
Voltage = treci.Value[MeasureType.voltage],
Eletricity = treci.Value[MeasureType.electricity],
ActivePower = treci.Value[MeasureType.activePower],
ReactivePower = treci.Value[MeasureType.reactivePower]
};
data.GlobalBaseData.Add(gb);
data.SaveChanges();
}
}
}
}
Console.WriteLine("Measurements for Agregator [{0}] are added in GlobalDataBase.", agregatorCode);
}
private void ExecuteOnDialogSearch()
{
try
{
Task.Run(() =>
{
try
{
if (IsDialogSearchVisible)
{
if (SelectedContact != null)
{
_view.MessageList.Clear();
var res = new List <BaseMessage>();
if (SelectedContact is UserUiInfo)
{
var userUiInfo = SelectedContact as UserUiInfo;
res.AddRange(UserServiceClient.GetUserMessages(GlobalBase.CurrentUser.Id, userUiInfo.UserId, messageLimit));
}
else if (SelectedContact is ChatGroupUiInfo)
{
var chatGroupUiInfo = SelectedContact as ChatGroupUiInfo;
res.AddRange(UserServiceClient.GetGroupMessages(chatGroupUiInfo.ChatGroupId, messageLimit));
}
if (res.Count != 0)
{
foreach (var mes in res)
{
if (GlobalBase.Base64Decode(mes.Text).Contains(DialogSearchStr))
{
GlobalBase.AddMessageOnUi.Invoke(mes);
}
}
}
GlobalBase.UpdateMessagesOnUI();
}
}
else
{
SelectedContactChanged();
}
}
catch (Exception)
{
}
});
}
catch (Exception)
{
}
}
private void ExecuteOnExitChat()
{
try
{
_serializeUser.CleanCurrentUser();
GlobalBase.ExitProgramm();
}
catch (System.Exception)
{
}
}
private void ExecuteOnDeleteContact()
{
try
{
UserServiceClient.RemoveUserToUserContact(GlobalBase.CurrentUser.Id, Profile.Id);
GlobalBase.UpdateContactList();
ManageControls();
}
catch (Exception)
{
}
}
static BaseTestClass()
{
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
// Write to stdout because stderr does not show up in the test output
Console.WriteLine($"Unhandled exception: {e.ExceptionObject}");
};
GlobalBase.AssemblyInit();
RootDir = TestCommon.GetRepoRoot();
DataDir = Path.Combine(RootDir, "test", "data");
}
public EditMessageVM(BaseMessage message, IView View) : base()
{
try
{
_view = View;
Message = message;
MessageText = GlobalBase.Base64Decode(message.Text);
}
finally
{
}
}
private void UpdateMessage(BaseMessage message, Func <BaseMessage, bool> UiUpdateStrategy)
{
try
{
var mes = "New message from @";
var sender = UserServiceClient.GetUserById(message.SenderId);
if (message is GroupMessage gMes)
{
if (SelectedContact is ChatGroupUiInfo)
{
if (gMes.ChatGroupId != (SelectedContact as ChatGroupUiInfo).ChatGroupId)
{
gMes.SenderName = sender.FirstName;
ChatGroup chatGroup = UserServiceClient.GetChatGroupById(gMes.ChatGroupId);
mes += chatGroup.Name;
mes += " group \n";
mes += "\"" + GlobalBase.Base64Decode(message.Text) + "\"";
GlobalBase.ShowNotify("New message", mes);
}
else
{
UiUpdateStrategy(message);
}
}
}
else if (message is UserMessage uMes)
{
if (SelectedContact is UserUiInfo)
{
if (uMes.SenderId != (SelectedContact as UserUiInfo).UserId)
{
mes += sender.FirstName + sender.LastName + "\n";
mes += "\"" + GlobalBase.Base64Decode(message.Text) + "\"";
GlobalBase.ShowNotify("New message", mes);
}
else
{
UiUpdateStrategy(message);
}
}
}
Debug.WriteLine("Receave Message from - ", sender.Login);
}
catch (Exception)
{
}
}
public SendMessage(BaseMessage message)
{
InitializeComponent();
if (message.Text != null)
{
MessageText.Text = GlobalBase.Base64Decode(message.Text);
}
SendTime.Text = message.DateOfSending.ToString("hh:mm");
ButtonDwnld.Visibility = message.ChatFileId != 0 ? Visibility.Visible : Visibility.Collapsed;
DataContext = new MessageControlVM(message);
}
private void OnForward()
{
try
{
if (SelectedContact != null)
{
if (!GlobalBase.IsMenuEnabled && GlobalBase.SelectedContact.UniqueName == SelectedContact.UniqueName)
{
return;
}
BaseMessage mes = null;
if (SelectedContact is UserUiInfo)
{
var userUiInfo = SelectedContact as UserUiInfo;
mes = new UserMessage()
{
Text = _message.Text,
DateOfSending = _message.DateOfSending,
SenderId = GlobalBase.CurrentUser.Id,
ReceiverId = userUiInfo.UserId
};
}
else if (SelectedContact is ChatGroupUiInfo)
{
var groupUiInfo = SelectedContact as ChatGroupUiInfo;
mes = new GroupMessage()
{
Text = _message.Text,
DateOfSending = _message.DateOfSending,
SenderId = GlobalBase.CurrentUser.Id,
ChatGroupId = groupUiInfo.ChatGroupId
};
}
UserServiceClient.SendMessageAsync(mes).ContinueWith((task) =>
{
if (GlobalBase.SelectedContact.UniqueName == SelectedContact.UniqueName)
{
GlobalBase.AddMessageOnUi(mes);
}
});
}
_view.CloseWindow();
}
catch (Exception)
{
}
}
static BaseTestClass()
{
// specific to use tls 1.2 as https://aka.ms/mlnet-resources/ only accpets tls 1.2 or newer
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
// Write to stdout because stderr does not show up in the test output
Console.WriteLine($"Unhandled exception: {e.ExceptionObject}");
};
GlobalBase.AssemblyInit();
RootDir = TestCommon.GetRepoRoot();
DataDir = Path.Combine(RootDir, "test", "data");
}
private void UpdateContacts()
{
try
{
var uiInfos = UserServiceClient.GetAllContactsUiInfo(GlobalBase.CurrentUser.Id);
GlobalBase.loadPictures(UserServiceClient, uiInfos);
ContactsList = uiInfos;
ManageControls();
GlobalBase.UpdateContactList();
}
catch (System.Exception)
{
}
}
private void SetAvatarForUI()
{
Task.Run(() =>
{
Dispatcher.CurrentDispatcher.Invoke(() =>
{
try
{
Images = GlobalBase.getUsersAvatar(GlobalBase.CurrentUser);
}
catch (Exception)
{
}
});
});
}
public ForwardMessageWindowVM(BaseMessage message, IView view) : base()
{
try
{
var uiInfos = UserServiceClient.GetAllContactsUiInfo(GlobalBase.CurrentUser.Id);
GlobalBase.loadPictures(UserServiceClient, uiInfos);
ContactsList = uiInfos;
_view = view;
_message = message;
IsForwardEnabled = false;
}
catch (Exception)
{
}
}
public ContatsWindowVM(IView iview) : base()
{
try
{
view = iview;
var tempUiInfos = UserServiceClient.GetAllContactsUiInfo(GlobalBase.CurrentUser.Id).Where(x => x is UserUiInfo).ToList();
GlobalBase.loadPictures(UserServiceClient, tempUiInfos);
ContactsList = tempUiInfos;
IsAddEnabled = false;
ManageControls();
}
catch (System.Exception)
{
}
}
//update data using server
private void UpdateContactList()
{
try
{
Task.Run(() =>
{
try
{
var temp = SelectedContact;
var tempUiInfos = UserServiceClient.GetAllContactsUiInfo(GlobalBase.CurrentUser.Id);
GlobalBase.loadPictures(UserServiceClient, tempUiInfos);
Dispatcher.CurrentDispatcher.Invoke(() =>
{
lock (GlobalBase.contactsMonitor)
{
ContactsList.Clear();
ContactsList = tempUiInfos;
}
});
if (temp != null)
{
Dispatcher.CurrentDispatcher.Invoke(() =>
{
lock (GlobalBase.contactsMonitor)
{
SelectedContact = ContactsList.FirstOrDefault(ct => ct.UniqueName == temp.UniqueName);
}
});
}
}
catch (Exception)
{
}
});
}
catch (Exception)
{
}
}
public void Init()
{
try
{
List <UiInfo> tempUiInfos = new List <UiInfo>();
Task.Run((() =>
{
try
{
_group = UserServiceClient.GetChatGroup(_groupUiInfo.UniqueName);
tempUiInfos = UserServiceClient.GetGroupParticipants(_group.Id);
UiInfo currentUserUiInfo = tempUiInfos.FirstOrDefault(info => info.UniqueName == GlobalBase.CurrentUser.Login);
tempUiInfos.Remove(currentUserUiInfo);
GlobalBase.loadPictures(UserServiceClient, tempUiInfos);
}
catch (Exception)
{
}
})).ContinueWith(task =>
{
try
{
GroupMemberList = tempUiInfos;
GroupName = _group.Name;
CurrentGroupName = _group.Name;
GroupMembersAmount = GroupMemberList.Count.ToString();
SetAvatarForUI();
}
catch (Exception)
{
}
});
}
catch (Exception)
{
}
}
private void ExecuteOnLeaveGroup()
{
try
{
if (CustomMessageBox.Show(Translations.GetTranslation()["LeaveGroupAsk"].ToString(), MessageBoxType.ConfirmationWithYesNo) == MessageBoxResult.Yes)
{
UserServiceClient.RemoveUserToChatGroupContactAsync(_group.Id, GlobalBase.CurrentUser.Id).ContinueWith(task =>
{
Application.Current.Dispatcher.Invoke(new Action(() =>
{
_view.CloseWindow();
}));
GlobalBase.UpdateContactList();
});
}
}
catch (Exception)
{
}
}
public override void OnNewContactAdded(UiInfo newContact)
{
try
{
var foundedUiInfo = ContactsList.FirstOrDefault(c => c.UniqueName == newContact.UniqueName);
if (foundedUiInfo == null)
{
var temp = new List <UiInfo>();
temp.AddRange(ContactsList);
GlobalBase.loadPicture(UserServiceClient, newContact);
temp.Add(newContact);
ContactsList = temp;
}
}
catch (Exception)
{
}
}
private void SetAvatarForUI()
{
try
{
Task.Run(() =>
{
try
{
System.Windows.Application.Current.Dispatcher.Invoke(() =>
{
Image = GlobalBase.getUsersAvatar(Profile);
});
}
catch (Exception)
{
}
});
}
catch (Exception)
{
}
}
public override void OnEntityChanged(UiInfo changedEntity)
{
try
{
if (changedEntity.UniqueName == GlobalBase.CurrentUser.Login)
{
GlobalBase.UpdateProfileUi.Invoke();
}
else
{
foreach (var uiInfo in ContactsList)
{
if (uiInfo.UniqueName == changedEntity.UniqueName)
{
GlobalBase.UpdateContactList();
break;
}
}
}
}
catch (Exception)
{
}
}
public ReceiveMessage(BaseMessage message)
{
InitializeComponent();
if (message.Text != null)
{
MessageText.Text = GlobalBase.Base64Decode(message.Text);
}
SendTime.Text = message.DateOfSending.ToString("hh:mm");
ButtonDwnld.Visibility = message.ChatFileId != 0 ? Visibility.Visible : Visibility.Collapsed;
if (message is GroupMessage mes)
{
SenderName.Visibility = Visibility.Visible;
SenderName.Text = mes.SenderName;
}
else
{
SenderName.Visibility = Visibility.Collapsed;
}
DataContext = new MessageControlVM(message);
}
public void AssertHandlerTest()
{
GlobalBase.AssertHandlerTest();
}
private void ExecuteOnApplyChanges()
{
try
{
if (Validate())
{
IsSavingProgress = true;
var res = string.Empty;
Task.Run(() =>
{
_group.Name = GroupName;
var chatFile = GlobalBase.FileServiceClient.getChatFileById(_group.ImageId);
if (_newAvatar != null)
{
if (chatFile == null)
{
_group.ImageId = GlobalBase.FileServiceClient.UploadFile(new FileService.ChatFile()
{
Source = CompressionHelper.CompressImage(_newAvatar)
});
}
else
{
GlobalBase.FileServiceClient.UpdateFileSource(chatFile.Id, CompressionHelper.CompressImage(_newAvatar));
}
}
if (_membersToAdd?.Count != 0)
{
foreach (var uiInfo in _membersToAdd)
{
UserServiceClient.AddUserToChatGroupContact(_group.Id, (uiInfo as UserUiInfo).UserId);
}
}
res = UserServiceClient.AddOrUpdateChatGroup(_group);
SetAvatarForUI();
if (res == string.Empty)
{
Application.Current.Dispatcher.Invoke(new Action((() =>
{
CustomMessageBox.Show(Translations.GetTranslation()["ChangesSaved"].ToString());
})));
}
}).ContinueWith(task =>
{
IsSavingProgress = false;
IsNewChanges = false;
GlobalBase.UpdateContactList();
});
}
}
catch (Exception)
{
}
}
private void ExecuteOnSendMessage()
{
try
{
if (SelectedContact != null && (!string.IsNullOrWhiteSpace(MessageText) || FilesPath != null))
{
BaseMessage messageTemplate = null;
if (SelectedContact is UserUiInfo)
{
messageTemplate = new UserMessage();
}
else if (SelectedContact is ChatGroupUiInfo)
{
messageTemplate = new GroupMessage();
}
messageTemplate.DateOfSending = DateTime.Now;
messageTemplate.SenderId = GlobalBase.CurrentUser.Id;
messageTemplate.Sender = GlobalBase.CurrentUser;
if (SelectedContact is UserUiInfo)
{
(messageTemplate as UserMessage).ReceiverId = (SelectedContact as UserUiInfo).UserId;
}
else if (SelectedContact is ChatGroupUiInfo)
{
(messageTemplate as GroupMessage).ChatGroupId = (SelectedContact as ChatGroupUiInfo).ChatGroupId;
}
if (MessageText != null && MessageText != string.Empty)
{
messageTemplate.Text = Encoding.UTF8.GetBytes(MessageText);
UserServiceClient.SendMessageAsync(messageTemplate).ContinueWith(task => GlobalBase.AddMessageOnUi(UserServiceClient.GetLastMessage()));
}
if (FilesPath != null)
{
foreach (var file in FilesPath)
{
var chatFile = new FileService.ChatFile()
{
Source = CompressionHelper.CompressFile(GlobalBase.FileToByte(file)), Name = GlobalBase.GetShortName(file)
};
messageTemplate.Text = Encoding.UTF8.GetBytes(chatFile.Name);
messageTemplate.ChatFileId = GlobalBase.FileServiceClient.UploadFile(chatFile);
UserServiceClient.SendMessageAsync(messageTemplate).ContinueWith(task => GlobalBase.AddMessageOnUi(UserServiceClient.GetLastMessage()));
}
}
FilesPath = null;
FileAmount = 0;
MessageText = string.Empty;
Debug.WriteLine("Send Message");
}
}
catch (Exception)
{
}
}
static BaseTestClass()
{
GlobalBase.AssemblyInit();
RootDir = GetRepoRoot();
DataDir = Path.Combine(RootDir, "test", "data");
}
private string GetContent()
{
return(GlobalBase.Base64Decode(Message.Text));
}
private void SelectedContactChanged(object sender = null, PropertyChangedEventArgs e = null)
{
try
{
ResetDialogSearchOnUi();
if (SelectedContact != null)
{
IsMenuEnabled = true;
}
else
{
IsMenuEnabled = false;
}
if (_view.MessageList != null)
{
Task.Run(() =>
{
try
{
lock (_view.MessageList)
{
_view.MessageList.Clear();
}
GlobalBase.loadPictures(UserServiceClient, ContactsList);
var res = new List <BaseMessage>();
if (SelectedContact is UserUiInfo)
{
res.AddRange(UserServiceClient.GetUserMessages(GlobalBase.CurrentUser.Id,
(SelectedContact as UserUiInfo).UserId, messageLimit));
}
else if (SelectedContact is ChatGroupUiInfo)
{
res.AddRange(
UserServiceClient.GetGroupMessages((SelectedContact as ChatGroupUiInfo).ChatGroupId, messageLimit));
}
if (res.Count != 0)
{
Application.Current.Dispatcher.Invoke(new Action(() =>
{
lock (_view.MessageList)
{
_view.MessageList.AddRange(res);
}
}));
}
}
catch (Exception)
{
}
}).ContinueWith((task =>
{
GlobalBase.UpdateMessagesOnUI();
}));
}
}
catch (Exception)
{
}
}
