private void SearchNewDevices()
{
try
{
string[] messages;
ResultTypes resultTypes;
var deviceCodes = new DeviceServiceClient().SearchNewDevices(out resultTypes, out messages);
if (resultTypes == ResultTypes.Ok)
{
if (deviceCodes != null && deviceCodes.Any())
{
var deviceCodeString = string.Join(", ", deviceCodes);
string question = string.Format("发现新设备编号:{0}, 现在导入系统吗？", deviceCodeString);
Messenger.Default.Send(new NotificationMessageAction(this, question, ConfirmImportNewController), Tokens.DevicePage_ShowQuestion);
}
else
{
var message = "没有发现新设备";
Messenger.Default.Send(new NotificationMessage(message), Tokens.DevicePage_ShowNotification);
}
}
else
{
var message = "搜索设备失败！";
Messenger.Default.Send(new NotificationMessage(message), Tokens.DevicePage_ShowNotification);
}
}
catch (Exception ex)
{
Log.Error(ex);
}
}
private void ConfirmImportNewController()
{
DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
string message = "";
try
{
string[] messages;
ResultTypes resultTypes;
var newDevices = new DeviceServiceClient().SyncDevices(out resultTypes, out messages);
if (resultTypes == ResultTypes.Ok && newDevices != null && newDevices.Any())
{
newDevices.ForEach(x => DeviceControllerViewModels.Add(x.ToViewModel()));
var cacheableRepo = _deviceControllerRepo as CacheableRepository <DeviceController, int>;
cacheableRepo.Refresh();
}
message = "导入新设备成功！";
}
catch (Exception ex)
{
Log.Error(ex);
message = "删除设备失败！";
}
Messenger.Default.Send(new NotificationMessage(message), Tokens.DevicePage_ShowNotification);
});
}
private void SyncToDevice(IEnumerable <DeviceController> devices, IEnumerable <UserEvent> systemUserEvents)
{
Log.Info("Start sync data to device...");
var proxy = new DeviceServiceClient();
var userRepo = RepositoryManager.GetRepository <IUserRepository>();
foreach (var systemUserEvent in systemUserEvents)
{
try
{
Log.InfoFormat("Start sync user id={0} to device.", systemUserEvent.UserID);
string[] message;
var option = GetSyncOption(systemUserEvent);
var userInfo = userRepo.GetByKey(systemUserEvent.UserID);
var result = proxy.SyncDeviceUsers(devices.ToArray(), option, new[] { userInfo }, out message);
if (result != ResultTypes.Ok)
{
string errorMessage = string.Join(",", message);
throw new Exception("sync device user fails." + errorMessage);
}
}
catch (Exception ex)
{
Log.InfoFormat("Sync user id={0} to device fails.", systemUserEvent.UserID);
Log.Error(ex);
}
Log.InfoFormat("Finish sync user id={0} to device.", systemUserEvent.UserID);
}
}
static void Main(string[] args)
{
// Si trova nel namespace che abbiamo scelto in fase di "Add Service Reference"
// Ha come suffisso "Client"
// Il nome della classe è composto da Namespace + *Client (?)
var client = new DeviceServiceClient();
DateTime today = client.Ping();
Console.WriteLine(today.ToString());
Console.ReadLine();
}
public static object [] GetDevicesByFixedAssetId(int id)
{
object[] list;
using (DeviceServiceClient client = new DeviceServiceClient())
{
client.Open();
list = client.GetDevicesByFixedAssetId(id);
client.Close();
}
return list;
}
private void SyncToSystem(IEnumerable <DeviceController> devices, IEnumerable <DeviceOperationLog> deviceUserEvents)
{
Log.Info("Start sync data to system...");
var proxy = new DeviceServiceClient();
var userRepo = RepositoryManager.GetRepository <IUserRepository>();
//filter out duplicated and non user operations.
var userEvents = deviceUserEvents.GroupBy(x => x.DeviceUserId).Select(e => e.FirstOrDefault(x => x.DeviceUserId != 0));
foreach (var deviceUserEvent in userEvents)
{
int userId = 0;
Log.InfoFormat("user code={0}.", deviceUserEvent.DeviceUserId);
try
{
var conditions = new Hashtable()
{
{ "UserCode", deviceUserEvent.DeviceUserId }
};
var userInfo = userRepo.QueryUsersForSummaryData(conditions).FirstOrDefault();
if (userInfo != null)
{
userId = userInfo.UserID;
}
else
{
userInfo = new User()
{
UserID = 0, UserCode = deviceUserEvent.DeviceUserId.ToString()
};
}
Log.InfoFormat("Start sync user id={0} to system.", userId);
string[] message;
var result = proxy.SyncSystemUsers(devices.ToArray(), new[] { userInfo }, out message);
if (result != ResultTypes.Ok)
{
string errorMessage = string.Join(",", message ?? new string[] {});
throw new Exception("sync system user fails." + errorMessage);
}
}
catch (Exception ex)
{
Log.InfoFormat("Sync user id={0} to system fails.", userId);
Log.Error(ex);
}
Log.InfoFormat("Finish sync user id={0} to system.", userId);
}
}
private async void UpdateDoorState(object sender, DoorControlOption option)
{
var menuItem = (MenuItem)sender;
var panel = menuItem.Tag as StackPanel;
var floordoor = panel.DataContext as FloorDoorViewModel;
var doorInfo = FloorDoorManager.GetInstance().AuthorizationDoors.FirstOrDefault(x => x.DeviceDoorID == floordoor.DoorID);
var deviceCode = ApplicationManager.GetInstance().AuthorizationDevices.First(x => x.DeviceID == doorInfo.DeviceID).Code.ToInt32();
string message = "";
var controller = await MessageBoxSingleton.Instance.ShowProgressAsync("同步数据", "同步数据中，请稍等", false);
controller.SetIndeterminate();
await Task.Run(() =>
{
try
{
string[] messages;
Int32 doorIndex = doorInfo.Code.ToInt32();
var selectedOption = (DeviceProxy.DoorControlOption)option.GetHashCode();
ResultTypes resultTypes = new DeviceServiceClient().UpdateDoorState(deviceCode, doorIndex, selectedOption, out messages);
message = MessageHandler.GenerateDeviceMessage(resultTypes, messages, "操作设备成功！", "操作设备失败！");
}
catch (Exception ex)
{
Log.Error(ex);
message = "操作设备失败！";
}
});
await controller.CloseAsync();
MessageBoxSingleton.Instance.ShowDialog(message, "");
if (option == DoorControlOption.KeepClose)
{
UpdateDoorColerByState(panel, false);
}
else if (option == DoorControlOption.Open || option == DoorControlOption.KeepOpen)
{
UpdateDoorColerByState(panel, true);
}
}
private void btnCallWcf_Click(object sender, RoutedEventArgs e)
{
int id1 = Thread.CurrentThread.ManagedThreadId;
DeviceServiceClient client = new DeviceServiceClient("BasicHttpBinding_IDeviceService");
client.PingCompleted += (s2, e2) => {
int id2 = Thread.CurrentThread.ManagedThreadId;
if (e2.Error == null)
{
MessageBox.Show(e2.Result.ToString());
}
};
client.PingAsync();
//var today = client.Ping();
//MessageBox.Show(today.ToString());
}
private IEnumerable <DeviceOperationLog> GetDeviceOperationEvents(IEnumerable <DeviceController> devices, DateTime startTime, DateTime endTime)
{
var events = new List <DeviceOperationLog>();
string[] messages;
var resultTypes = new DeviceServiceClient().SyncDeviceOperationLogs(devices.ToArray(), out messages);
Log.InfoFormat("SyncDeviceOperationLogs result = {0}", resultTypes);
var conditions = new Hashtable()
{
{ "StartDate", startTime },
{ "EndDate", endTime },
};
var deviceOperationLogRepo = RepositoryManager.GetRepository <IDeviceOperationLogRepository>();
events = deviceOperationLogRepo.Query(conditions).ToList();
return(events);
}
private static void RunLoadtestSimulation()
{
var serviceProvider = new ServiceCollection().AddHttpClient().BuildServiceProvider();
var httpClientFactory = serviceProvider.GetService <IHttpClientFactory>();
/// Creating clients
IDeviceServiceClient deviceServiceClient = new DeviceServiceClient(httpClientFactory);
IScanServiceClient scanServiceClient = new ScanServiceClient(httpClientFactory);
ISettingServiceClient settingServiceClient = new SettingServiceClient(httpClientFactory);
// Read in test data
IList <DeviceModel> TestDevices = FileParser.ReadTestDevices();
IList <ScanBatchModel> scanBatchModels = ScanServiceClient.CreateScanBatchModels(FileParser.ReadScanModel().GetRange(0, 10000), 5).ToList();
DeviceModel device = new DeviceModel()
{
Id = 1
};
var wifiBleDevices = FileParser.ReadClusterDevices();
IClusterGraphScanGenerator scanGenerator = new ClusterGraphScanGenerator();
scanGenerator.Run(device, wifiBleDevices.Item1, wifiBleDevices.Item2);
ISimulation <SimulationResult> loadTestSimulation = new LoadTestSimulation(
deviceServiceClient,
settingServiceClient,
scanServiceClient,
TestDevices,
scanBatchModels);
ISimulation <SimulationResult> clusterInsertSimulation = new ClusterInsertSimulation(
deviceServiceClient,
settingServiceClient,
scanServiceClient,
scanGenerator,
wifiBleDevices.Item1,
wifiBleDevices.Item2);
loadTestSimulation.Run();
}
private void OnTimedEvent(object source, ElapsedEventArgs e)
{
try
{
Log.Info("Trigger Floor monitor timer event...");
if (_selectedFloorViewModel != null && _selectedFloorViewModel.Doors.Any())
{
Log.InfoFormat("Floor monitor timer check doors for floor id: {0}", _selectedFloorViewModel.FloorID);
foreach (var floordoorId in _dropDoorDict.Keys)
{
var doorInfo = FloorDoorManager.GetInstance().AuthorizationDoors.FirstOrDefault(x => x.DeviceDoorID == floordoorId);
var deviceCode = ApplicationManager.GetInstance().AuthorizationDevices.First(x => x.DeviceID == doorInfo.DeviceID).Code.ToInt32();
ResultTypes resultTypes;
string[] messages;
Int32 doorIndex = doorInfo.Code.ToInt32();
bool isopened = new DeviceServiceClient().GetDoorState(deviceCode, doorIndex, out resultTypes, out messages);
if (resultTypes == ResultTypes.Ok)
{
Log.InfoFormat("Floor monitor timer gets state result: [doorId={0}, isopened={1}]", floordoorId, isopened);
Dispatcher.Invoke(() =>
{
UpdateDoorColerByState(_dropDoorDict[floordoorId], isopened);
});
}
else
{
Log.Warn(messages.ConvertToString());
}
}
}
}
catch (Exception ex)
{
Log.Error("OnTimedEvent error", ex);
MessageBoxSingleton.Instance.ShowDialog("内部错误", "");
}
}
private void ProcessQueryPage(int pageIndex)
{
try
{
var conditions = new Hashtable();
if (!TryGetConditions(pageIndex, PageSize, out conditions))
{
return;
}
DispatcherHelper.CheckBeginInvokeOnUI(async() =>
{
string message = "";
var controller = await DialogCoordinator.Instance.ShowProgressAsync(this, "查询数据", "查询数据中，请稍等");
controller.SetIndeterminate();
await Task.Run(() =>
{
try
{
Log.Info("同步数据中..");
var devices = new List <DeviceController>();
if (!string.IsNullOrWhiteSpace(DeviceCode))
{
var queriedDevice = ApplicationManager.GetInstance().AuthorizationDevices.First(x => x.Code == DeviceCode);
devices.Add(queriedDevice);
}
else
{
devices = ApplicationManager.GetInstance().AuthorizationDevices;
}
string[] messages;
var resultTypes = new DeviceServiceClient().SyncDeviceOperationLogs(devices.ToArray(), out messages);
message = MessageHandler.GenerateDeviceMessage(resultTypes, messages, "同步数据成功！", "同步数据失败！");
Log.Info(message);
}
catch (Exception ex)
{
Log.Error(ex);
}
try
{
Log.Info("查询数据中..");
int totalCount = 0;
DeviceOperationLogViewModels = QueryData(conditions, out totalCount);
if (totalCount % PageSize == 0)
{
TotalPage = (totalCount / PageSize).ToString();
}
else
{
TotalPage = ((totalCount / PageSize) + 1).ToString();
}
RaisePropertyChanged(null);
}
catch (Exception ex)
{
Log.Error(ex);
}
});
await controller.CloseAsync();
if (!DeviceOperationLogViewModels.Any())
{
Messenger.Default.Send(new NotificationMessage("查询数据结果为空"), Tokens.DeviceOperationLogPage_ShowNotification);
}
});
}
catch (Exception ex)
{
Log.Error(ex);
}
}
private void CallbackProcessor()
{
_lscb = new ListServiceCallback();
_dscb = new DeviceServiceCallback();
_mscb = new MaterialServiceCallback();
_arscb = new AsRunServiceCallback();
while (true)
{
//ListServiceCallbacks
_lsc = new ListServiceClient(new InstanceContext(_lscb));
_lsc.Endpoint.Behaviors.Find <CallbackBehaviorAttribute>().MaxItemsInObjectGraph = 2147483647;
//DeviceServiceCallbacks
_dsc = new DeviceServiceClient(new InstanceContext(_dscb));
_dsc.Endpoint.Behaviors.Find <CallbackBehaviorAttribute>().MaxItemsInObjectGraph = 2147483647;
//MaterialServiceCallbaks
_msc = new MaterialServiceClient(new InstanceContext(_mscb));
_msc.Endpoint.Behaviors.Find <CallbackBehaviorAttribute>().MaxItemsInObjectGraph = 2147483647;
//AsRunServiceCallbacks
_arsc = new AsRunServiceClient(new InstanceContext(_arscb));
_arsc.Endpoint.Behaviors.Find <CallbackBehaviorAttribute>().MaxItemsInObjectGraph = 2147483647;
try
{
//ListService
_lsc.RegisterConnectionStateListener(_loginSession, _serverName);
_lsc.RegisterListListener(new LoginSession(), _serverName, _airList);
_lsc.RegisterListListener(new LoginSession(), _serverName, 25); //BA List test
//DeviceService
_dsc.RegisterConnectionStateListener(_serverName);
_dsc.RegisterDeviceListener(_serverName);
_dsc.RegisterStorageListener(_serverName);
//MaterialService
_msc.RegisterDatabaseChangeListener();
_msc.RegisterVerifyListListener(_materialServiceLoginSession);
//AsRunService
_arsc.RegisterAsRunListener(_serverName, _airList);
_arsc.RegisterConnectionStateListener(_asrunServiceLoginSession, _serverName);
Boolean doWork = true;
while (doWork)
{
Thread.Sleep(5);
doWork = _lsc.State == CommunicationState.Opened;
//Processing callbacks
//List Service
_updatedEvents = _lscb.EventsUpdated;
if (_updatedEvents.Count() > 0)
{
UpdateGrid(_updatedEvents, GlobalFlags.CallbackTypes.OnEvensUpdated);
_lscb.IsEventUpdated = false;
_loggerService.PrintCallBack(GlobalFlags.CallbackTypes.OnEvensUpdated, _updatedEvents);
}
_addedEvents = _lscb.EventsAdded;
if (_addedEvents.Count() > 0)
{
UpdateGrid(_addedEvents, GlobalFlags.CallbackTypes.OnEventsAdded);
_lscb.IsEventAdded = false;
_loggerService.PrintCallBack(GlobalFlags.CallbackTypes.OnEventsAdded, _addedEvents);
}
_deletedEvents = _lscb.EventsDeleted;
if (_deletedEvents.Count() > 0)
{
UpdateGrid(_deletedEvents, GlobalFlags.CallbackTypes.OnEventsDeleted);
_lscb.IsEventDeleted = false;
_loggerService.PrintCallBack(GlobalFlags.CallbackTypes.OnEventsDeleted, _deletedEvents);
}
if (_lscb.StateChanged.ServerName != null)
{
_loggerService.PrintCallBack(_lscb.StateChanged, GlobalFlags.CallbackDestination.ListService);
_lscb.IsStateUpdated = false;
}
if (_lscb.ListChanged.ServerName != null)
{
_loggerService.PrintCallBack(_lscb.ListChanged);
_lscb.IsListChanged = false;
}
if (_lscb.IsAvailabilityChecked)
{
_loggerService.PrintCallBack(GlobalFlags.CallbackDestination.ListService, GlobalFlags.InfoMessages.CheckAvailability);
_lscb.IsAvailabilityChecked = false;
}
if (_lscb.ListLockedData.ServerName != null)
{
_loggerService.PrintCallBack(GlobalFlags.CallbackTypes.ListLocked, _lscb.ListLockedData);
_lscb.IsListLocked = false;
}
if (_lscb.ListUnlockedData.ServerName != null)
{
_loggerService.PrintCallBack(GlobalFlags.CallbackTypes.ListUnlocked, _lscb.ListUnlockedData);
_lscb.IsListUnLocked = false;
}
//Device Service
if (_dscb.StateChanged.ServerName != null)
{
_loggerService.PrintCallBack(_dscb.StateChanged,
GlobalFlags.CallbackDestination.DeviceService);
_dscb.IsStateUpdated = false;
}
if (_dscb.DeviceChange.ServerName != null)
{
_loggerService.PrintCallBack(_dscb.DeviceChange);
_dscb.IsDeviceChanged = false;
}
if (_dscb.StorageUpdate.ServerName != null)
{
_loggerService.PrintCallBack(_dscb.StorageUpdate);
_dscb.IsStorageUpdated = false;
}
if (_dscb.IsAvailabilityChecked)
{
_loggerService.PrintCallBack(GlobalFlags.CallbackDestination.DeviceService, GlobalFlags.InfoMessages.CheckAvailability);
_dscb.IsAvailabilityChecked = false;
}
//AsRun Service
if (_arscb.AsRunStateChanged.ServerName != null)
{
_loggerService.PrintCallBack(_arscb.AsRunStateChanged,
GlobalFlags.CallbackDestination.AsRunService);
_arscb.IsConnectionStateChanged = false;
}
if (_arscb.OnAsRunData.ServerName != null)
{
_loggerService.PrintCallBack(_arscb.OnAsRunData);
_arscb.IsOnAsRunCallbackRecieved = false;
}
}
}
catch (Exception)
{
GC.Collect();
}
}
// ReSharper disable FunctionNeverReturns
}
