public void Init()
{
InitAudios();
InitModels();
InitBehavs();
remoteService = new RemoteService();
SetController(ApplicationData.GAME_STATE);
}
public List <TrendCorrection> GetTrendCorrectionFiltered(long storeID, DateTime?dateFrom, DateTime?dateTo)
{
return(RemoteService.GetTrendCorrectionFiltered(storeID, dateFrom, dateTo));
}
private RemoteService TryStartProcess(CancellationToken cancellationToken)
{
Process newProcess = null;
int newProcessId = -1;
Semaphore semaphore = null;
try
{
int currentProcessId = Process.GetCurrentProcess().Id;
bool semaphoreCreated;
string semaphoreName;
while (true)
{
semaphoreName = "InteractiveHostSemaphore-" + Guid.NewGuid();
semaphore = new Semaphore(0, 1, semaphoreName, out semaphoreCreated);
if (semaphoreCreated)
{
break;
}
semaphore.Close();
cancellationToken.ThrowIfCancellationRequested();
}
var remoteServerPort = "InteractiveHostChannel-" + Guid.NewGuid();
var processInfo = new ProcessStartInfo(_hostPath);
processInfo.Arguments = remoteServerPort + " " + semaphoreName + " " + currentProcessId;
processInfo.WorkingDirectory = _initialWorkingDirectory;
processInfo.CreateNoWindow = true;
processInfo.UseShellExecute = false;
processInfo.RedirectStandardOutput = true;
processInfo.RedirectStandardError = true;
processInfo.StandardErrorEncoding = Encoding.UTF8;
processInfo.StandardOutputEncoding = Encoding.UTF8;
newProcess = new Process();
newProcess.StartInfo = processInfo;
// enables Process.Exited event to be raised:
newProcess.EnableRaisingEvents = true;
newProcess.Start();
// test hook:
var processCreated = InteractiveHostProcessCreated;
if (processCreated != null)
{
processCreated(newProcess);
}
cancellationToken.ThrowIfCancellationRequested();
try
{
newProcessId = newProcess.Id;
}
catch
{
newProcessId = 0;
}
// sync:
while (!semaphore.WaitOne(_millisecondsTimeout))
{
if (!CheckAlive(newProcess))
{
return(null);
}
_output.WriteLine(FeaturesResources.AttemptToConnectToProcess, newProcessId);
cancellationToken.ThrowIfCancellationRequested();
}
// instantiate remote service:
Service newService;
try
{
newService = (Service)Activator.GetObject(
typeof(Service),
"ipc://" + remoteServerPort + "/" + Service.ServiceName);
cancellationToken.ThrowIfCancellationRequested();
newService.Initialize(_replType);
}
catch (RemotingException) when(!CheckAlive(newProcess))
{
return(null);
}
return(new RemoteService(this, newProcess, newProcessId, newService));
}
catch (OperationCanceledException)
{
if (newProcess != null)
{
RemoteService.InitiateTermination(newProcess, newProcessId);
}
return(null);
}
finally
{
if (semaphore != null)
{
semaphore.Close();
}
}
}
private async Task <RemoteService> TryStartProcess(CancellationToken cancellationToken)
{
Process newProcess = null;
int newProcessId = -1;
try
{
var currentProcessId = Process.GetCurrentProcess().Id;
var remotePort = "RoslynPad-" + Guid.NewGuid();
var processInfo = new ProcessStartInfo(HostPath)
{
Arguments = $"{HostArguments} {remotePort} 0 {currentProcessId}",
WorkingDirectory = _initializationParameters.WorkingDirectory,
CreateNoWindow = true,
UseShellExecute = false
};
newProcess = new Process {
StartInfo = processInfo
};
newProcess.Start();
cancellationToken.ThrowIfCancellationRequested();
try
{
newProcessId = newProcess.Id;
}
catch
{
newProcessId = 0;
}
if (!newProcess.IsAlive())
{
return(null);
}
cancellationToken.ThrowIfCancellationRequested();
ClientImpl client = null;
// instantiate remote service
try
{
cancellationToken.ThrowIfCancellationRequested();
client = new ClientImpl(remotePort, this);
await client.Connect(TimeSpan.FromSeconds(4)).ConfigureAwait(false);
await client.Initialize(new InitializationMessage { Parameters = _initializationParameters })
.ConfigureAwait(false);
}
catch (Exception)
{
client?.Dispose();
return(null);
}
return(new RemoteService(newProcess, newProcessId, client));
}
catch (OperationCanceledException)
{
if (newProcess != null)
{
RemoteService.InitiateTermination(newProcess, newProcessId);
}
return(null);
}
}
public Client(RemoteService service, IPAddress address, int port)
{
_service = service;
_client = new Netronics.Client(new Properties(new IPEndPoint(address, port), () => new Handler.Service(_service.GetServices().GetManagerProcessor())));
_client.Start();
}
private void bgThread_StopService(object sender, DoWorkEventArgs e)
{
// Background thread to stop a Windows service.
e.Result = RemoteService.StopService(e.Argument as RemoteService);
}
public List <WorldToHwgr> InsertRelation(WorldToHwgr entity)
{
List <WorldToHwgr> lst = RemoteService.InsertRelation(entity);
return(FillHwgrName(lst));
}
public List <StoreToWorld> FindAllForCountry(long countryID)
{
return(FillWorldName(RemoteService.FindAllForCountry(countryID)));
}
public IList GetCashDeskPeopleEstimated(DateTime begin, DateTime end, long storeID)
{
return(RemoteService.GetCashDeskPeopleEstimated(begin, end, storeID));
}
static ServerToServer()
{
tcpRemote = RemoteService.CreateTcpProxy("0", "192.168.0.100", 9001, 30 * 1000);
}
public List <StoreToWorld> FindAllForRegion(long regionID)
{
return(FillWorldName(RemoteService.FindAllForRegion(regionID)));
}
public HeartbeatService(ILogger <HeartbeatService> log, RemoteService remote)
{
this.log = log;
this.remote = remote;
}
internal static SMBCommand GetOpenAndXResponse(SMBHeader header, OpenAndXRequest request, object share, StateObject state)
{
bool isExtended = (request.Flags & OpenFlags.SMB_OPEN_EXTENDED_RESPONSE) > 0;
string path = request.FileName;
if (share is NamedPipeShare)
{
RemoteService service = ((NamedPipeShare)share).GetService(path);
if (service != null)
{
ushort fileID = state.AddOpenedFile(path);
if (isExtended)
{
return(CreateResponseExtendedForNamedPipe(fileID));
}
else
{
CreateResponseForNamedPipe(fileID);
}
}
header.Status = NTStatus.STATUS_OBJECT_PATH_NOT_FOUND;
return(new ErrorResponse(CommandName.SMB_COM_OPEN_ANDX));
}
else // FileSystemShare
{
FileSystemShare fileSystemShare = (FileSystemShare)share;
string userName = state.GetConnectedUserName(header.UID);
bool hasWriteAccess = fileSystemShare.HasWriteAccess(userName);
IFileSystem fileSystem = fileSystemShare.FileSystem;
OpenResult openResult;
FileSystemEntry entry = fileSystem.GetEntry(path);
if (entry != null)
{
if (!hasWriteAccess && request.AccessMode.AccessMode == AccessMode.Write || request.AccessMode.AccessMode == AccessMode.ReadWrite)
{
header.Status = NTStatus.STATUS_ACCESS_DENIED;
return(new ErrorResponse(CommandName.SMB_COM_OPEN_ANDX));
}
if (request.OpenMode.FileExistsOpts == FileExistsOpts.ReturnError)
{
header.Status = NTStatus.STATUS_OBJECT_NAME_COLLISION;
return(new ErrorResponse(CommandName.SMB_COM_OPEN_ANDX));
}
else if (request.OpenMode.FileExistsOpts == FileExistsOpts.TruncateToZero)
{
try
{
Stream stream = fileSystem.OpenFile(path, FileMode.Truncate, FileAccess.ReadWrite, FileShare.ReadWrite);
stream.Close();
}
catch (IOException ex)
{
ushort errorCode = IOExceptionHelper.GetWin32ErrorCode(ex);
if (errorCode == (ushort)Win32Error.ERROR_SHARING_VIOLATION)
{
header.Status = NTStatus.STATUS_SHARING_VIOLATION;
return(new ErrorResponse(CommandName.SMB_COM_OPEN_ANDX));
}
else
{
header.Status = NTStatus.STATUS_DATA_ERROR;
return(new ErrorResponse(CommandName.SMB_COM_OPEN_ANDX));
}
}
catch (UnauthorizedAccessException)
{
header.Status = NTStatus.STATUS_ACCESS_DENIED;
return(new ErrorResponse(CommandName.SMB_COM_OPEN_ANDX));
}
openResult = OpenResult.FileExistedAndWasTruncated;
}
else // FileExistsOpts.Append
{
openResult = OpenResult.FileExistedAndWasOpened;
}
}
else
{
if (request.OpenMode.CreateFile == CreateFile.ReturnErrorIfNotExist)
{
header.Status = NTStatus.STATUS_NO_SUCH_FILE;
return(new ErrorResponse(CommandName.SMB_COM_OPEN_ANDX));
}
entry = fileSystem.CreateFile(path);
openResult = OpenResult.NotExistedAndWasCreated;
}
ushort fileID = state.AddOpenedFile(path, true);
if (isExtended)
{
return(CreateResponseFromFileSystemEntry(entry, fileID, openResult));
}
else
{
return(CreateResponseExtendedFromFileSystemEntry(entry, fileID, openResult));
}
}
}
public SaveDataResult Save_HWGR_WGR_Values(List <HWGR_WGR_SysValuesShort> list)
{
return(RemoteService.Save_HWGR_WGR_Values(list));
}
public InitializedRemoteService(RemoteService service, RemoteExecutionResult initializationResult)
{
ServiceOpt = service;
InitializationResult = initializationResult;
}
public decimal GetEstimatedTargetedNetPerformance(short year, long storeID, long worldID)
{
return(RemoteService.GetEstimatedTargetedNetPerformance(year, storeID, worldID));
}
public List <HwgrToWgr> InsertRelation(HwgrToWgr entity)
{
return(FillWgrName(RemoteService.InsertRelation(entity)));
}
public IList GetEstWorkingHours(DateTime begin, DateTime end, long storeID, long worldID)
{
return(RemoteService.GetEstWorkingHours(begin, end, storeID, worldID));
}
public OwinRemotingFixture() : base(new RemoteService(ClientApplicationDirectoryName, ClientExecutableName, ApplicationType.Bounded))
{
OwinRemotingServerApplication = new RemoteService(ServerApplicationDirectoryName, ServerExecutableName, ApplicationType.Bounded);
OwinRemotingServerApplication.CopyToRemote();
OwinRemotingServerApplication.Start(string.Empty, captureStandardOutput: false, doProfile: false);
}
public IList GetEstWorldDiffData(short year, long storeID, long worldID)
{
return(RemoteService.GetEstWorldDiffData(year, storeID, worldID));
}
public List <World_HWGR_SysValues> Get_World_HWGR_SysValues()
{
return(RemoteService.Get_World_HWGR_SysValues());
}
public IList GetEstWorldYearValues(short year, long storeID, long worldID)
{
return(RemoteService.GetEstWorldYearValues(year, storeID, worldID));
}
public MyService()
{
// Create a new instance of proxy class for
// the XML Web service to be called.
remoteService = new RemoteService();
}
public void ClearEstimation(long storeid, short year)
{
RemoteService.ClearEstimation(storeid, year);
}
private async void RegisterButton_Click(object sender, RoutedEventArgs e)
{
try
{
if (txtFullName.Text.Trim() == "")
{
MessageDialog md = new MessageDialog("Please enter full name");
await md.ShowAsync();
return;
}
else if (txtPhoneNumber.Text.Trim() == "")
{
MessageDialog md = new MessageDialog("Please enter phone Number");
await md.ShowAsync();
return;
}
else if (txtCompanyName.Text.Trim() == "")
{
MessageDialog md = new MessageDialog("Please enter company Name");
await md.ShowAsync();
return;
}
else if (photoString == "")
{
MessageDialog md = new MessageDialog("Please Select Photo");
await md.ShowAsync();
return;
}
else if (txtEmail.Text.Trim() == "")
{
MessageDialog md = new MessageDialog("Please enter Email");
await md.ShowAsync();
return;
}
else if (!txtEmail.Text.Contains('@') || !txtEmail.Text.Contains('.'))
{
MessageDialog md = new MessageDialog("Please Enter a Valid Email");
await md.ShowAsync();
return;
}
else
{
fullname = txtFullName.Text;
emailAddress = txtEmail.Text;
companyName = txtCompanyName.Text;
phoneNumber = Convert.ToInt64(txtPhoneNumber.Text);
RemoteService service = new RemoteService();
VisitorDataPayLoad payload = new VisitorDataPayLoad
{
PhoneNumber = phoneNumber
};
var response = await service.CheckIfVisitorExistService(payload);
if (response.ResponseStatusCode == System.Net.HttpStatusCode.Found)
{
MessageDialog checkInMsg = new MessageDialog("User already exist");
await checkInMsg.ShowAsync();
return;
}
else if (response.ResponseStatusCode == System.Net.HttpStatusCode.NotFound)
{
//Send to Registration DB
newVisitor();
}
else
{
MessageDialog checkInMsg = new MessageDialog("Server error");
await checkInMsg.ShowAsync();
}
}
//After Registration
clearContents();
}
catch (Exception ex)
{
MessageDialog msg = new MessageDialog(ex.Message + " Void - RegisterButton_Click");
//msg.ShowAsync();
}
}
public List <StoreWorldDetail> GetStoreWorldDetail(short year)
{
return(FillWorldName(RemoteService.GetStoreWorldDetail(year)));
}
/// <summary>
/// The methods provided in this section are simply used to allow
/// NavigationHelper to respond to the page's navigation methods.
/// Page specific logic should be placed in event handlers for the
/// <see cref="Common.NavigationHelper.LoadState"/>
/// and <see cref="Common.NavigationHelper.SaveState"/>.
/// The navigation parameter is available in the LoadState method
/// in addition to page state preserved during an earlier session.
/// </summary>
#endregion
private async void loginDetail()
{
try
{
string userName = await VisitorAppUserProcess.CreateUserName(txtUserName.Text);
RemoteService service = new RemoteService();
UserLoginDataPayLoad userDetail = new UserLoginDataPayLoad
{
username = userName,
userPassword = txtPassword.Password
};
var response = await service.CheckIfUserExistService(userDetail);
if (response.ResponseStatusCode == System.Net.HttpStatusCode.Found)
{
//MessageDialog Msg = new MessageDialog("User already exist");
//await Msg.ShowAsync();
//return;
_activePage.UserStaffId = response.StaffId;
var staffId = _activePage.UserStaffId;
var ThisStaff = new List <StaffGlobal>();
#region MyRegion
//RemoteService serviceThisStaff = new RemoteService();
//StaffDataPayload ThisStaffPayLoad = new StaffDataPayload()
//{
// StaffId = staffId
//};
//var responseThisStaff = service.GetThisStaffControllerService(ThisStaffPayLoad);
//ThisStaff = responseThisStaff.StaffList;
#endregion
var responseThisStaff = GetDataFromDB.GetDataThisStaff(staffId).Result;
ThisStaff = responseThisStaff.StaffList;
string staffStatus = "";
foreach (var item in ThisStaff)
{
_activePage.UserStaffId = item.StaffId;
_activePage.UserStaffRole = item.Roles;
_activePage.UserStaffName = item.StaffName;
_activePage.UserStaffPhotoString = item.StaffPhoto;
_activePage.CompanyId = item.CompanyId;
_activePage.UserDepartmentId = item.DepartmentId;
_activePage.UserStaffIdNumber = item.StaffIdNumber;
_activePage.UserStaffPhoneNumber = item.StaffPhoneNumber;
_activePage.UserStaffPhoto = await VisitorAppHelper.Base64StringToBitmap(item.StaffPhoto);
staffStatus = item.StaffStatus;
}
if (staffStatus.ToUpper() == StaffStatus.Suspended.ToString().ToUpper())
{
MessageDialog msh = new MessageDialog("You are suspended and cannot currently access this application", "Alert!");
await msh.ShowAsync();
return;
}
var CompanyId = _activePage.CompanyId;
var ThisCompany = new List <CompanyGlobal>();
#region MyRegion
////RemoteService serviceThisCompany = new RemoteService();
//CompanyDataPayLoad ThisCompanyPayLoad = new CompanyDataPayLoad()
//{
// CompanyId = CompanyId
//};
#endregion
var responseThisCompany = GetDataFromDB.GetDataThisCompany(CompanyId).Result;
ThisCompany = responseThisCompany.CompanyList;
foreach (var item in ThisCompany)
{
_activePage.CompanyName = item.CompanyName;
_activePage.CompanyLogoString = item.CompanyLogo;
_activePage.CompanyLogo = await VisitorAppHelper.Base64StringToBitmap(item.CompanyLogo);
_activePage.CompanyPhoneNumber = item.CompanyPhoneNumber;
_activePage.CompanyAddress = item.CompanyAddress;
_activePage.CompanyEmail = item.CompanyEmailAddress;
_activePage.CompanyStatus = item.CompanyStatus;
}
if (_activePage.CompanyStatus.ToUpper() == CompanyStatus.Suspend.ToString().ToUpper())
{
MessageDialog msgComp = new MessageDialog("Company License is not found.\n" + "Contact +234-XXX", "Alert!!!");
msgComp.ShowAsync();
return;
}
if (_activePage.CompanyStatus.ToUpper() == CompanyStatus.Deleted.ToString().ToUpper())
{
MessageDialog msgComp = new MessageDialog("Company is not registered", "Alert!!!");
msgComp.Commands.Add(new UICommand("Register Company")
{
Id = 0
});
msgComp.Commands.Add(new UICommand("Cancel")
{
Id = 1
});
msgComp.CancelCommandIndex = 1;
var result = await msgComp.ShowAsync();
if (Convert.ToInt32(result.Id) == 0)
{
this.Frame.Navigate(typeof(RegisterNewCompany));
}
}
var DepartmentId = _activePage.UserDepartmentId;
var ThisDepartment = new List <DepartmentGlobal>();
#region MyRegion
//RemoteService serviceThisDepartment = new RemoteService();
//DepartmentDataPayload ThisDepartmentPayLoad = new DepartmentDataPayload()
//{
// DepartmentId = DepartmentId
//};
#endregion
var responseThisDepartment = GetDataFromDB.GetDataThisDepartment(DepartmentId).Result;
ThisDepartment = responseThisDepartment.DepartmentList;
foreach (var item in ThisDepartment)
{
_activePage.UserDepartmentName = item.DepartmentName;
//_activePage.de = item.CompanyLogo;
}
if (_activePage.UserStaffRole.ToUpper() == StaffRoles.Staff.ToString().ToUpper())
{
this.Frame.Navigate(typeof(Appointment), _activePage);
}
else
{
this.Frame.Navigate(typeof(FrontDeskHome), _activePage);
//this.Frame.Navigate(typeof(CheckInWithInvitationPage), _activePage);
}
}
else
{
MessageDialog msg = new MessageDialog("Details not Correct");
await msg.ShowAsync();
//this.Frame.Navigate(typeof(RegisterNewCompany));
}
}
catch (Exception ex)
{
MessageDialog msgd = new MessageDialog(ex.Message);
MessageDialog msg = new MessageDialog("Try Again", "Hello");
await msg.ShowAsync();
}
}
public List <StoreWorldDetail> GetStoreWorldDetail(short year, long storeID, long store_worldID)
{
return(FillWorldName(RemoteService.GetStoreWorldDetail(year, storeID, store_worldID)));
}
private RemoteService TryStartProcess(CancellationToken cancellationToken)
{
Process newProcess = null;
int newProcessId = -1;
Semaphore semaphore = null;
try
{
string semaphoreName;
while (true)
{
semaphoreName = "HostSemaphore-" + Guid.NewGuid();
bool semaphoreCreated;
semaphore = new Semaphore(0, 1, semaphoreName, out semaphoreCreated);
if (semaphoreCreated)
{
break;
}
semaphore.Close();
cancellationToken.ThrowIfCancellationRequested();
}
var currentProcessId = Process.GetCurrentProcess().Id;
var remoteServerPort = "HostChannel-" + Guid.NewGuid();
var processInfo = new ProcessStartInfo(HostPath)
{
Arguments = remoteServerPort + " " + semaphoreName + " " + currentProcessId,
WorkingDirectory = _initialWorkingDirectory,
CreateNoWindow = true,
UseShellExecute = false
};
newProcess = new Process {
StartInfo = processInfo
};
newProcess.Start();
cancellationToken.ThrowIfCancellationRequested();
try
{
newProcessId = newProcess.Id;
}
catch
{
newProcessId = 0;
}
// sync:
while (!semaphore.WaitOne(MillisecondsTimeout))
{
if (!newProcess.IsAlive())
{
return(null);
}
cancellationToken.ThrowIfCancellationRequested();
}
// instantiate remote service
IService newService;
try
{
newService = DuplexChannelFactory <IService> .CreateChannel(
new InstanceContext(new ServiceCallback(OnDumped)),
CreateBinding(),
new EndpointAddress(GetAddress(remoteServerPort)));
// ReSharper disable once SuspiciousTypeConversion.Global
((ICommunicationObject)newService).Open();
cancellationToken.ThrowIfCancellationRequested();
newService.Initialize(_references.ToArray(), _imports.ToArray(), _nuGetConfiguration, _initialWorkingDirectory);
}
catch (CommunicationException) when(!newProcess.IsAlive())
{
return(null);
}
return(new RemoteService(newProcess, newProcessId, newService));
}
catch (OperationCanceledException)
{
if (newProcess != null)
{
RemoteService.InitiateTermination(newProcess, newProcessId);
}
return(null);
}
finally
{
semaphore?.Close();
}
}
public List <StoreToWorld> FindAllForStore(long storeID)
{
return(FillWorldName(RemoteService.FindAllForStore(storeID)));
}
private async Task GetLoginResponse()
{
var remoteResult = new RemoteService();
// var result = await remoteResult.GetRemoteService(param);
}
private void bgThread_GetServices(object sender, DoWorkEventArgs e)
{
e.Result = RemoteService.GetServices();
}
public void SecureDoorEvent(RemoteService.DoorEventType evttype, RemoteService.DoorBindingData doorBindingData)
{
if (this.OnDoorEvent != null)
this.OnDoorEvent(evttype, doorBindingData);
// throw new NotImplementedException();
}
public ParallelController(RemoteService remoteService)
{
_remoteService = remoteService;
}
