public MainViewModel()
{
// Singleton
instance = this;
// Instance services
navigationService = new NavigationService();
dataService = new DataService();
apiService = new ApiService();
netService = new NetService();
// Create Observable Collections
Pins = new ObservableCollection <Pin>();
Menu = new ObservableCollection <MenuItemViewModel>();
Products = new ObservableCollection <ProductItemViewModel>();
Customers = new ObservableCollection <CustomerItemViewModel>();
// Create Views
NewLogin = new LoginViewModel();
UserLoged = new UserViewModel();
NewCustomer = new CustomerItemViewModel();
CurrentCustomer = new CustomerItemViewModel();
// Load Data
LoadMenu();
LoadProducts();
LoadCustomers();
}
protected override async Task LoadDatas()
{
var model = searchForm.GetValue <SearchPersonalReplyCondition>();
var result = await NetService.QueryPersonalReplys(User.Id, currentPage, pageSize, model.Title ??= "");
SetData(result?.Data?.Items, result.Data.TotalCount);
}
public static IUnityContainer AddCommunicationServices(this IUnityContainer services)
{
var listenOptions = MulticastConnectionOptions.Create(ipAddress: "225.0.0.0",
multicastLoopback: false,
exclusiveAddressUse: false);
var senderOptions = MulticastConnectionOptions.Create(ipAddress: "225.0.0.0",
exclusiveAddressUse: false,
useBind: false);
var listenConnection = new UdpMulticastConnection(listenOptions);
var senderConnection = new UdpMulticastConnection(senderOptions);
services.AddLocalConnectionTable();
var table = services.Resolve <IRedistributableLocalConnectionTable>();
var settings = services.Resolve <RadioSettings>();
var netService = new NetService(33100, table, settings);
var taskService = new NetworkTaskService(netService);
services.RegisterInstance <ITaskService>(taskService, new SingletonLifetimeManager());
services.RegisterInstance <IDataReceiver>(listenConnection);
services.RegisterInstance <IDataTransmitter>(senderConnection);
IDataProvider <byte[]> miner = new DataEngineMiner(services.Resolve <IDataReceiver>());
services.RegisterInstance(miner, new SingletonLifetimeManager());
services.RegisterInstance <IDataAsByteConverter <DataModel> >(new Converter <DataModel>());
services.RegisterType <IDataProcessingBuilder, DataModelProcessingBuilder>();
return(services);
}
/// <summary>
/// Bonjour callback
/// </summary>
/// <param name="service"></param>
private void didUpdateTXT(NetService service)
{
ArrayList list = getList(service.Type);
if (list == null)
{
return;
}
lock (list.SyncRoot) {
foreach (JSONSrcSink player in list)
{
if (player.id.Equals(service.Name))
{
processTXTrecord(service, player);
// Kludge. Sometimes, we miss the TXT update record from Bonjour.
// So, we stop and restart a new monitoring session. That forces the system to continously get updates/stop/new update/stop, yuck
service.StopMonitoring();
service.DidUpdateTXT += new NetService.ServiceTXTUpdated(didUpdateTXT);
service.StartMonitoring();
return;
}
}
}
}
public void InitNetService()
{
instance = this;
client = new PESocket <ClientSession, GameMsg>();
client.StartAsClient(ServerConfig.serverIP, ServerConfig.serverPort);
client.SetLog(true, (string msg, int lv) =>
{
switch (lv)
{
case 0:
msg = "Log:" + msg;
Debug.Log(msg);
break;
case 1:
msg = "Warn:" + msg;
Debug.LogWarning(msg);
break;
case 2:
msg = "Error:" + msg;
Debug.LogError(msg);
break;
case 3:
msg = "Info:" + msg;
Debug.Log(msg);
break;
}
});
PECommon.Log("NetService Init...");
}
protected override NetService GetNetService()
{
Logger.Debug("RAOPEmitter: {0}, {1}, {2}", name, identifier, port);
Dictionary <string, object> txtRecord = new Dictionary <string, object>();
txtRecord.Add("txtvers", "1");
txtRecord.Add("pw", pass.ToString());
txtRecord.Add("sr", "44100");
txtRecord.Add("ss", "16");
txtRecord.Add("ch", "2");
txtRecord.Add("tp", "UDP");
txtRecord.Add("sm", "false");
txtRecord.Add("sv", "false");
txtRecord.Add("ek", "1");
txtRecord.Add("et", "0,1");
txtRecord.Add("cn", "0,1");
txtRecord.Add("vn", "3");
txtRecord.Add("md", "0,1,2");
txtRecord.Add("da", "true");
txtRecord.Add("am", model);
txtRecord.Add("vs", "130.14");
NetService service = new NetService("", TYPE, identifier + "@" + name, port);
service.TXTRecordData = NetService.DataFromTXTRecordDictionary(txtRecord);
return(service);
}
internal async Task Save()
{
var SetRoleResult = await NetService.SetUserRoles(new UserRoleDto { UserId = model.Id, RoleIds = SelectedValues.Select(p => p.Id).ToList() });
MessageService.Show(SetRoleResult.IsSuccess ? "Success" : SetRoleResult.Message, SetRoleResult.IsSuccess ? MessageType.Success : MessageType.Error);
await CloseAsync(SetRoleResult.IsSuccess);
}
/// <summary>
/// Starts publishing the airplay service over Bonjour so that iOS devices can find it.
/// This only advertises the service, Bonjour doesn't deal with the connections themselves. The connections are dealt with in the Server class.
/// </summary>
private void DoPublish()
{
publishService = new NetService(domain, type, name, port);
//add delegates for success/false
publishService.DidPublishService += publishService_DidPublishService;
publishService.DidNotPublishService += publishService_DidNotPublishService;
//add txtrecord, which gives details of the service. For now we'll just put the version number
System.Collections.Hashtable dict = new System.Collections.Hashtable();
/* dict.Add("deviceid", "FF:FF:FF:FF:FF:FF");
* dict.Add("features", "0x77");
* dict.Add("model", "AppleTV2,1");
* dict.Add("srcvers", "101.10");*/
dict.Add("deviceid", "58:55:CA:1A:E2:88");
dict.Add("features", "0x39f7");
dict.Add("model", "AppleTV2,1");
dict.Add("protovers", "1.0");
dict.Add("srcvers", "120.2");
publishService.TXTRecordData = NetService.DataFromTXTRecordDictionary(dict);
publishService.Publish();
}
void nsBrowser_DidFindService(NetServiceBrowser browser, NetService service, bool moreComing)
{
Debug.WriteLine(String.Format("{0}: nsBrowser_DidFindService: {1}", System.Threading.Thread.CurrentThread.ManagedThreadId, service.Name));
service.DidUpdateTXT += new NetService.ServiceTXTUpdated(ns_DidUpdateTXT);
service.DidResolveService += new NetService.ServiceResolved(ns_DidResolveService);
service.StartMonitoring();
ListViewItem item = new ListViewItem(service.Name);
item.Tag = service;
if (!devices.Contains(service))
{
devices.Add(service);
}
if (moreComing)
{
// devices.Add(service);
// waitingAdd.Add(item);
}
else
{
comboBox1.Invoke(new Action(() => comboBox1.Items.Clear()));
foreach (NetService s in devices)
{
if (!comboBox1.Items.Contains(s.Name))
{
comboBox1.Invoke(new Action(() => comboBox1.Items.Add(s.Name)));
}
}
}
}
protected async override Task OnAfterRenderAsync(bool firstRender)
{
await base.OnAfterRenderAsync(firstRender);
if (firstRender)
{
var rolesResut = await NetService.QueryRoles(true);
if (rolesResut != null)
{
Values = rolesResut.IsSuccess ? rolesResut.Data : new List <RoleDisplayDto>();
}
var UserRolesResult = await NetService.QueryUserRoles(model.Id);
if (UserRolesResult.IsSuccess)
{
var userroles = UserRolesResult.Data;
SelectedValues = new ObservableCollection <RoleDisplayDto>(Values.Where(p => userroles.Contains(p.Name)));
}
else
{
SelectedValues = new ObservableCollection <RoleDisplayDto>();
}
Status = Status.Indeterminate;
RequireRender = true;
StateHasChanged();
}
}
void nsBrowser_DidRemoveService(NetServiceBrowser browser, NetService service, bool moreComing)
{
Debug.WriteLine(String.Format("{0}: nsBrowser_DidRemoveService: {1}", System.Threading.Thread.CurrentThread.ManagedThreadId, service.Name));
service.Dispose();
}
public DiscoveredPairingUtility(NetService service)
{
Service = service;
Name = service.TXTRecordData.GetValueOrDefault("CtlN", service.Hostname);
ServiceID = service.TXTRecordData.GetValueOrDefault("ServiceID", service.Name);
}
/// <summary>
/// Publishes the mDNS sevrice to pretend like we are a client device
/// like an iPod Touch. Service is "_touch-remote._tcp" and Pair is
/// the important value here.
/// </summary>
private void PublishTouchRemoteService()
{
try {
Console.WriteLine("mDNS: {0}", NetService.DaemonVersion);
String domain = "";
String name = "0000000000000000000000000000000000000001";
touchRemoteService = new NetService(domain, SERVICE_TYPE, name, PORT);
touchRemoteService.AllowMultithreadedCallbacks = true;
touchRemoteService.DidPublishService += new NetService.ServicePublished(publishService_DidPublishService);
touchRemoteService.DidNotPublishService += new NetService.ServiceNotPublished(publishService_DidNotPublishService);
/* HARDCODE TXT RECORD */
System.Collections.Hashtable dict = new System.Collections.Hashtable();
dict.Add("DvNm", this.applicationName + " Client");
dict.Add("RemV", "10000");
dict.Add("DvTy", "iPod");
dict.Add("RemN", "Remote");
dict.Add("txtvers", "1");
dict.Add("Pair", "0000000000000001");
touchRemoteService.TXTRecordData = NetService.DataFromTXTRecordDictionary(dict);
touchRemoteService.Publish();
} catch (Exception ex) {
Console.WriteLine("Error publishing mDNS TouchRemote Service", ex);
}
}
void nsBrowser_DidFindService(NetServiceBrowser browser, NetService service, bool moreComing)
{
Debug.WriteLine(String.Format("{0}: nsBrowser_DidFindService: {1}", System.Threading.Thread.CurrentThread.ManagedThreadId, service.Name));
service.DidUpdateTXT += new NetService.ServiceTXTUpdated(ns_DidUpdateTXT);
service.DidResolveService += new NetService.ServiceResolved(ns_DidResolveService);
service.StartMonitoring();
ListViewItem item = new ListViewItem(service.Name);
item.Tag = service;
if (moreComing)
{
waitingAdd.Add(item);
}
else
{
servicesList.BeginUpdate();
while (waitingAdd.Count > 0)
{
servicesList.Items.Add((ListViewItem)waitingAdd[0]);
waitingAdd.RemoveAt(0);
}
servicesList.Items.Add(item);
servicesList.EndUpdate();
}
}
protected async Task CanCelBindConfirm()
{
var model = bForm.GetValue <PasswordModel>();
var result = await NetService.ValidateVerifyCode(User.Id, EmailType.EmailUnBind, model.Code);
if (result.IsSuccess)
{
User.Email = "";
User.NormalizedEmail = "";
var UplodateResult = await userManager.UpdateAsync(User);
if (UplodateResult.Succeeded)
{
ToastSuccess("邮箱已解绑");
TimeOut = 0;
await LoadData();
BtnBindEmailDisabled = false;
SendCanCelEmailBindCodeSuccess = false;
UpdateUI();
}
else
{
ToastError(JsonConvert.SerializeObject(UplodateResult.Errors));
}
}
else
{
ToastError("验证失败");
}
}
/// <summary>
///
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
private static String getName(NetService service)
{
String name = service.Name;
if (service.TXTRecordData != null)
{
byte[] txt = service.TXTRecordData;
IDictionary dict = NetService.DictionaryFromTXTRecordData(txt);
if (dict != null)
{
foreach (DictionaryEntry kvp in dict)
{
String key = (String)kvp.Key;
key = key.ToUpper();
if (key.Equals("NAME"))
{
byte[] value = (byte[])kvp.Value;
try {
name = Encoding.UTF8.GetString(value);
} catch {
}
break;
}
}
}
}
return(name);
}
protected async Task Save()
{
if (!roleForm.IsValid())
{
return;
}
var role = roleForm.GetValue <RoleDisplayDto>();
if (EntryOperation == EntryOperation.Add)
{
var NewRoleResult = await NetService.AddRoleAsync(new NewRoleDto { Name = role.Name });
if (!NewRoleResult.IsSuccess)
{
MessageService.Show(NewRoleResult.Message, MessageType.Error);
}
await CloseAsync(NewRoleResult.IsSuccess);
}
else
{
var UpdateRoleResult = await NetService.UpdateRoleAsync(role);
if (!UpdateRoleResult.IsSuccess)
{
MessageService.Show(UpdateRoleResult.Message, MessageType.Error);
}
await CloseAsync(UpdateRoleResult.IsSuccess);
}
}
protected virtual async Task <BZUserDto> GetUser()
{
try
{
var UserId = await localStorage.GetItemAsync <string>("CurrentUserId");
if (UserId == null)
{
return(null);
}
var cacheUser = await localStorage.CreateOrGetCache <CurrentUserCache>("CurrentUser", async() =>
{
var user = await NetService.FindUserByIdAsync(UserId);
return(new CurrentUserCache
{
Expire = DateTime.Now.AddMinutes(30),
User = user
});
});
return(cacheUser.User);
}
catch (Exception ex)
{
ToastError(ex.Message);
_logger.LogError($"OnAfterRenderAsync----->>{ex.StackTrace}");
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="service"></param>
void ns_DidUpdateTXT(NetService service)
{
#if PLAYER_TASKBAR
foreach (MenuItem item in streamersItem.MenuItems)
{
NetService iService = (NetService)item.Tag;
if (iService == null)
{
continue;
}
if (iService.Name.Equals(service.Name))
{
item.Text = getName(service);
}
}
#else
browserList.BeginUpdate();
foreach (ListViewItem item in browserList.Items)
{
NetService iService = (NetService)item.Tag;
if (iService.Name.Equals(service.Name))
{
item.Text = getName(service);
}
}
browserList.EndUpdate();
// MessageBox.Show("Did update TXT + " + service.Name, "DEBUG");
#endif
}
public override bool Initialize()
{
System.Threading.Thread.Sleep(1500);
if (false == base.Initialize())
{
return(false);
}
if (false == RedisMultiplexer.Instance.Start(eRedis.Token, rdToken()))
{
return(false);
}
if (false == RedisMultiplexer.Instance.Start(eRedis.Game, rdGame()))
{
return(false);
}
//if (false == RedisMultiplexer.Instance.Start(eRedis.Log, dbLog()))
// return false;
m_messageExecuter.Start(new MessageDispatcher(this));
m_separator.Start(this);
List <Connector> listConnector = new List <Connector>();
m_atchCenter = new CenterServerAttacher(this);
ChatServerAttacher chatSvr = new ChatServerAttacher(this);
//m_chatSvr = new ChatServerAttacher(this);
listConnector.Add(m_atchCenter);
listConnector.Add(chatSvr);
ChatSessionManager.Instance.SetAttacher(chatSvr, m_config);
// managerSAEA
m_managerSAEA.Initialize(m_config);
// for client
m_netServiceForClient = new NetService(this,
new ClientSessionHandler(m_managerSAEA, OnAddClientSession, OnRemoveClientSession),
new NetListenable(m_config.m_listnerClient));
// for attacher
m_managerSessionForServer = new ServerSessionManager();
m_netServiceForAttach = new NetService(this,
new ServerSessionHandler(m_managerSAEA, OnAddServerSession, OnRemoveServerSession, OnCheckingServer),
new NetAttachable(listConnector));
m_netServiceForClient.Initialize(OnHandleMessage);
m_netServiceForAttach.Initialize(OnHandleMessage);
// attaching
m_atchCenter.OnAttach(m_config.m_nSequence, m_config.m_center, m_config.m_listnerClient);
//m_atchCenter.OnAttach(m_config.m_nSequence, m_config.m_center, m_config.m_listnerClient);
return(true);
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
await base.OnAfterRenderAsync(firstRender);
if (firstRender)
{
Title = "活跃用户";
var cacheDatas = await localStorage.CreateOrGetCache <HotUsersCache>("HotUsersCache", async() =>
{
var UserResult = await NetService.QueryHotUsers();
if (UserResult != null)
{
return new HotUsersCache
{
Expire = DateTime.Now.AddDays(1), hotUserDtos = UserResult.IsSuccess ? UserResult.Data : new List <HotUserDto>()
}
}
;
return(new HotUsersCache
{
Expire = null,
hotUserDtos = new List <HotUserDto>()
});
});
public DrawTextCommand(DiscordShardedClient client, ImageService img, MiscService misc, NetService net)
{
_client = client;
_img = img;
_misc = misc;
_net = net;
}
internal async Task CheckAndNavigatToReset()
{
if (string.IsNullOrWhiteSpace(verifyCode))
{
ToastError("请先发送验证码到您的邮箱");
return;
}
if (!form.IsValid())
{
return;
}
var model = form.GetValue <PasswordModel>();
if (!model.Code.Equals(verifyCode))
{
ToastError("验证码无效");
return;
}
else
{
var response = await NetService.ValidateVerifyCode(UserId, EmailType.EmailRetrievePassword, model.Code);
if (response.IsSuccess)
{
NavigationManager.NavigateTo($"/account/reset/{UserId}", true);
}
else
{
ToastError(response.Message);
}
}
}
static SocketBase()
{
// 注册接口实现
NetService.Install();
// 自动收缩内存，调试状态1分钟一次，非调试状态10分钟一次
Int32 time = NetHelper.Debug ? 60000 : 600000;
new TimerX(s => Runtime.ReleaseMemory(), null, time, time, false);
#if !NET4
try
{
// 写在另外一个方法里面，保证不会在当前方法编译的时候就报错
CheckNet21();
// 回收一次，引发编译NetEventArgs的析构函数
GC.Collect();
}
catch (TypeLoadException ex)
{
if (ex.TypeName.Contains("SocketAsyncEventArgs"))
{
throw new XException("NewLife.Net网络库需要.Net2.0 Sp1支持！", ex);
}
else
{
throw ex;
}
}
#endif
}
public BonjourTests()
{
InitializeComponent();
servicesListBox.ItemsSource = _services;
publishStopButton.IsEnabled = false;
browseStopButton.IsEnabled = false;
// Set up the net service
_netService = new NetService();
_netService.FullServiceInstanceName = "test-01._touch-remote._tcp.local.";
_netService.Port = 1234;
_netService.Hostname = "this-is-a-test.local.";
_netService.IPAddresses.Add("127.0.0.1");
Dictionary <string, string> txt = new Dictionary <string, string>();
txt.Add("DvNm", "Windows Phone 7 Device");
txt.Add("RemV", "10000");
txt.Add("DvTy", "iPhone");
txt.Add("RemN", "Remote");
txt.Add("txtvers", "1");
txt.Add("Pair", "1111111111111111");
_netService.TXTRecordData = txt;
}
/// <summary>
/// Callback when a Service TXT record is updated.
/// </summary>
/// <param name="service">the Service that has the TXT change</param>
void ns_DidUpdateTXT(NetService service)
{
Console.WriteLine("Did Update TXT Record: {0}", service.Name);
byte[] txt = service.TXTRecordData;
IDictionary dict = NetService.DictionaryFromTXTRecordData(txt);
Console.WriteLine("TXT Records Count: {0}", dict.Count);
foreach (DictionaryEntry kvp in dict)
{
String key = (String)kvp.Key;
byte[] value = (byte[])kvp.Value;
// If you were creating your own service, or browsing a known service,
// then you'd know what kind of data to expect as the value.
// But we don't here, so we assume UTF8 strings.
string valueStr;
try {
valueStr = new UTF8Encoding(false).GetString(value);
} catch {
valueStr = "[Binary Data]";
}
Console.WriteLine("TXT Record: {0} = {1}", key, valueStr);
}
}
private void PrepareService()
{
m_publishService = new NetService(DOMAIN, TYPE, m_name, SERVICE_PORT);
string macAddr = Utils.GetMacAddress();
// AirPlay now shows everywhere :) not only in "Photos.app" and "Videos.app"
var dicTXTRecord = new Dictionary <string, string>();
dicTXTRecord.Add("model", "AppleTV2,1");
dicTXTRecord.Add("deviceid", "58:55:CA:06:BD:9E");
//dicTXTRecord.Add("deviceid", macAddr);
// Bit field -> http://nto.github.com/AirPlay.html#servicediscovery-airplayservice
dicTXTRecord.Add("features", "0x39f7");
dicTXTRecord.Add("protovers", "1.0");
dicTXTRecord.Add("srcvers", "101.10");
// set to 1 to enable
dicTXTRecord.Add("pw", "0");
m_publishService.TXTRecordData = NetService.DataFromTXTRecordDictionary(dicTXTRecord);
//add delegates for success/false
m_publishService.DidPublishService += publishService_DidPublishService;
m_publishService.DidNotPublishService += publishService_DidNotPublishService;
m_isPrepared = true;
}
private void HandleDiscoverEvent(NetService service, string logText, EventHandler <ServiceEventArgs> eventHandler)
{
foreach (var address in service.Addresses)
{
IPEndPoint endpoint = (IPEndPoint)address;
if (NetworkInformation.IsLocalAddress(endpoint.Address) || !NetworkInformation.IsValid(endpoint.Address))
{
continue;
}
if (serviceTypes.ContainsValue(service.Type))
{
WebService webService = serviceTypes.Where(x => x.Value == service.Type).First().Key;
Log.Debug("Zeroconf: {0} {1} ({2}) at {3}:{4}", logText, webService, service.Type, endpoint.Address, endpoint.Port);
if (eventHandler != null)
{
eventHandler(this, new ServiceEventArgs()
{
Service = webService,
Endpoint = endpoint
});
}
}
}
}
internal async Task ReSetPassword()
{
if (!resetPasswordForm.IsValid())
{
return;
}
var model = resetPasswordForm.GetValue <PasswordModel>();
if (model.Password.Equals(model.ConfirmPassword))
{
var resetResult = await NetService.ResetPasswordAsync(new UpdateUserPasswordDto()
{
UserId = User.Id,
NewPassword = model.Password
});;
if (resetResult.IsSuccess)
{
ToastSuccess("密码修改成功，下次登录请使用新密码");
resetPasswordForm.Reset();
form.Reset();
CheckverifyCodeSuccess = false;
StateHasChanged();
}
else
{
ToastError(resetResult.Message);
}
}
else
{
ToastError("两次密码输入不一致");
}
}
// RunInLogic is called once per frame
void Update()
{
DateTime runtime = DateTime.Now;
NetService.getInstance().Update();
PaymentService.getInstance().Update(runtime);
}
public bool initService()
{
//实例化各服务
dbService = new DBService();
netService = new NetService();
helperService = new HelperService();
safetyService = new SafetyService();
//初始化各服务
DBState = dbService.initService() ? State.Suspend : State.Close;
netState = netService.initService() ? State.Suspend : State.Close;
helperState = helperService.initService() ? State.Suspend : State.Close;
safetyState = safetyService.initService() ? State.Suspend : State.Close;
return DBState == State.Suspend && netState == State.Suspend && helperState == State.Suspend && safetyState == State.Suspend;
}
public void setNetService(NetService netService)
{
this.netService = netService;
}
