private void processing(ExecuteInfo info)
{
StatusClient client = new StatusClient();
info.Message = string.Format("start with agent={0} state={1}", info.AgentId, info.Message);
client.Status(info);
for (int i = 0; i < 99000000; i++)
{
if (i % 10000000 == 0)
{
System.Threading.Thread.Sleep(100);
//info.Message = i.ToString() ;
//client.Status(info);
}
}
//info.Message = string.Format("end with agent={0} state={1}", info.AgentId, info.Message);
//client.Status(info);
info.Message = "Done";
client.Status(info);
client.Close();
}
public SettlementProcessController()
{
SessionModel.Initialize();
client = new Client <Overdraft>(SessionModel.AuthorizationHeader, ClientConfiguration.GetAdapterFromConfig());
settlementProcessClient = new SettlementProcessClient(SessionModel.AuthorizationHeader, ClientConfiguration.GetAdapterFromConfig());
employeeClient = new Client <Employee>(SessionModel.AuthorizationHeader, ClientConfiguration.GetAdapterFromConfig());
statusClient = new StatusClient <Employee>(SessionModel.AuthorizationHeader, ClientConfiguration.GetAdapterFromConfig());
}
public void OnDataPointClick(string ctxName, string dtpName)
{
StatusClient.ToggleDebugMessagesAsync(ctxName, dtpName, response =>
{
Console.WriteLine(response);
ViewModel.ContextsStatus[ctxName].DataPointStatus[dtpName].DebugMessages = response;
StateHasChanged();
});
}
//обрабатывает завершение соединение
public void HandlerEndSession()
{
ThreadOfHandlerMsg.Abort();
ThreadOfHandlerMsg = null;
StreamWithServer.Close();
Status = StatusClient.EndSession;
//уведомляем о завершении соединения
EventEndSession();
}
public async Task PostStatus()
{
// Arrange
var client = new StatusClient(new RestClient());
// Act
await client.PostStatusMessageAsync(_authToken, "Hello from Alexa Unit Tests...");
// Assert
// shouldn't blow up....
}
void CreateMonye()
{
//Destroy(transform.parent.GetComponent<SavedItem>().objOnTable);
transform.parent.GetComponent <OrderProcessing>().CreateEmptyPlate();
transform.parent.GetComponent <SavedItem>().objOnTable = null;
transform.parent.GetComponent <NewObject>().CreateObj(money);
transform.parent.GetComponent <OrderProcessing>().eatFood = false;
transform.parent.GetComponent <OrderProcessing>().CreateEmptyPlate();
mood.status = true;
status = StatusClient.waitPay;
}
public void SetUp()
{
var httpClient = new HttpClient();
_audioClient = new AudioJobClient(httpClient)
{
BaseUrl = ServiceUri
};
_statusClient = new StatusClient(httpClient)
{
BaseUrl = ServiceUri
};
}
public ApiWrapper(string apiUri, ILogger logger, CancellationToken ct)
{
_taskClient = new TaskClient(HttpClient)
{
BaseUrl = apiUri
};
_statusClient = new StatusClient(HttpClient)
{
BaseUrl = apiUri
};
_logger = logger;
_cancellationToken = ct;
}
//закрывает подлючение
public void Close()
{
if (client != null)
{
client?.Close();
client.EventEndSession -= Handler_EndSession;
Status = StatusClient.EndSession;
}
else
{
throw new Exception("Невозможно выполнить операцию до создания подключения");
}
}
void Start()
{
money = Resources.Load("Money") as GameObject;
order = Resources.Load("Order") as GameObject;
mood = new Mood();
//MOODrES = mood.MoodOriginal;
status = StatusClient.createClient;
canvas = Instantiate(canvas);
canvas.transform.SetParent(transform);
slider = canvas.transform.Find("Slider").gameObject;
slider.GetComponent <Slider>().maxValue = mood.maxValue;
}
public async Task Should_Change_Status_To_UnregisteredUsingClient()
{
var txOptions = new System.Transactions.TransactionOptions();
txOptions.IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted;
using var scope = new TransactionScope(TransactionScopeOption.Required, txOptions, TransactionScopeAsyncFlowOption.Enabled);
//Act
Guid identityWorkId = Guid.NewGuid(); //Guid.Parse("7535C4E6-4712-4DD6-955D-FCA86E054D49");
Guid instanceId = Guid.NewGuid(); //Guid.Parse("33D7CA50-39E9-4B14-B482-5FCBEC07E8DB");
var employees = await new EmployeeManagerUT().CreateDefaultAsync <Employee>(identityWorkId, instanceId, randomValues: true);
var middlewareManager = new MiddlewareManager <Employee>(new BaseRecordManager <Employee>(), new EmployeeValidator());
//Asserts
//Get
var result = await middlewareManager
.GetByIdsAsync(employees.Select(p => p.ID).ToList(), identityWorkId);
Assert.True(result.Any());
var employeeFromDB = result.FirstOrDefault();
Assert.Equal(CotorriaStatus.Active, employeeFromDB.LocalStatus);
Assert.Equal(DateTime.Now.Date, employeeFromDB.LastStatusChange.Date);
//Set inactive
DateTime?unregisteredDate = DateTime.Now.AddDays(1);
var employeeId = employeeFromDB.ID;
var statusClient = new StatusClient <Employee>("", ClientConfiguration.ClientAdapter.Local);
await statusClient.SetUnregistered(new List <Guid>() { employeeId }, identityWorkId, unregisteredDate);
//Asserts
//GetAggain
result = await middlewareManager
.GetByIdsAsync(employees.Select(p => p.ID).ToList(), identityWorkId);
Assert.True(result.Any());
employeeFromDB = result.FirstOrDefault();
//Asserts
Assert.Equal(CotorriaStatus.Unregistered, employeeFromDB.LocalStatus);
Assert.Equal(DateTime.Now.Date, employeeFromDB.LastStatusChange.Date);
Assert.Equal(unregisteredDate.GetValueOrDefault().Date, employeeFromDB.UnregisteredDate.GetValueOrDefault().Date);
}
private void OnGUI()
{
if (client[0] != null)
{
StatusClient status = client[0].transform.GetComponentInParent <NewClient>().status;
if (status == StatusClient.setClient || status == StatusClient.createOrder || status == StatusClient.readyOrder)
{
GUIStyle style = new GUIStyle();
style.fontSize = 20;
style.normal.textColor = Color.green;
Vector3 bufCamera = Camera.main.WorldToScreenPoint(this.transform.position);
GUI.Label(new Rect(bufCamera.x - 15, Screen.height - bufCamera.y - 20, 100, 20), id.ToString(), style);
}
}
}
void Update()
{
Slider();
mood.LowerMood();
if (mood.MoodOriginal <= 0) //настроение испортилось, удаление клиента
{
DeleteClient();
return;
}
if (status == StatusClient.setClient)
{
Money.SetClient();
mood.AddMood(10);
ClientMyClass.MoveClient(placeInLine); //вызов события на опускание очереди
status = StatusClient.createOrder;
time = 0;
mood.status = false;
}
else if (status == StatusClient.createOrder)
{
time += Time.deltaTime;
if (time > 1)
{
status = StatusClient.readyOrder;
CreateOrder();
time = 0;
mood.status = true;
}
}
else if (status == StatusClient.eat)
{
mood.status = false;
time += Time.deltaTime;
if (time > 2)
{
CreateMonye();
}
}
else if (status == StatusClient.leaveClient)
{
Destroy(gameObject);
}
}
//подключаемся к серверу
public void ConnectToServer()
{
if (client == null)
{
try
{
TcpClient newConnection = new TcpClient();
newConnection.Connect(IPAdress, Port);
client = new ConnectedClient <T>(newConnection, this);
client.EventEndSession += Handler_EndSession;
Status = StatusClient.Connect;
}
catch (Exception e)
{
Status = StatusClient.FailConect;
}
}
}
//подключаемся к серверу
public bool ConnectToServer()
{
if (StreamWithServer == null)
{
StreamWithServer = new TcpClient();
}
try
{
StreamWithServer.Connect(IPAdress, Port);
}
catch (Exception)
{
Status = StatusClient.FailConect;
return(false);
}
//обработка сообщений производитсва в отдельном потоке
ThreadOfHandlerMsg = new Thread(StartReadMessage);
ThreadOfHandlerMsg.Start();
Status = StatusClient.Connect;
formatter = new BinaryFormatter();
return(true);
}
protected override async Task OnInitializedAsync()
{
await StatusClient.GetAsync(
response =>
{
ViewModel.UpdateViewModel(response);
});
BlazorTimer.OnElapsed += () =>
{
Console.WriteLine("Timer Elapsed.");
StatusClient.GetAsync(
response =>
{
ViewModel.UpdateViewModel(response);
});
BlazorTimer.SetTimer(5000);
};
BlazorTimer.SetTimer(5000);
}
public FFMpegService(string uri, int threadsPerMachine, IAudioPresetProvider audioPresetProvider, ITimeProvider timeProvider)
{
_httpClient = new HttpClient {
Timeout = TimeSpan.FromSeconds(60)
};
_serviceUri = uri;
_audioClient = new AudioJobClient(_httpClient)
{
BaseUrl = _serviceUri
};
_audioMuxClient = new MuxJobClient(_httpClient)
{
BaseUrl = _serviceUri
};
_hardSubtitlesClient = new HardSubtitlesJobClient(_httpClient)
{
BaseUrl = _serviceUri
};
_statusClient = new StatusClient(_httpClient)
{
BaseUrl = _serviceUri
};
_healthClient = new HealthCheckClient(_httpClient)
{
BaseUrl = _serviceUri
};
_jobClient = new JobClient(_httpClient)
{
BaseUrl = _serviceUri
};
_timeProvider = timeProvider;
_threadsPerMachine = threadsPerMachine;
_tasksPerAudioJob = audioPresetProvider.AsDictionary()[StateFormat.audio_od_standard].Count;
RetryCount = 3;
RetrySleepMs = 10 * 1000;
}
/// <summary>
/// Get the controller class responsible for handing the request namespace
/// </summary>
/// <param name="requestNamespace"></param>
/// <param name="restClient"></param>
/// <returns></returns>
public static IAlexaSmartHomeController GetController(string requestNamespace, ITinamousRestClient restClient)
{
var devicesClient = new DevicesClient(restClient);
var measurementsClient = new MeasurementsClient(restClient);
var statusClient = new StatusClient(restClient);
switch (requestNamespace)
{
case "Alexa":
return(new StateReportHelper(devicesClient));
case "Alexa.Discovery":
return(new DiscoveryHelper(devicesClient));
case "Alexa.PowerController":
return(new PowerController(devicesClient, measurementsClient, statusClient));
case "Alexa.PowerLevelController":
return(new PowerLevelController(devicesClient, measurementsClient, statusClient));
case "Alexa.SceneController":
return(new SceneController(devicesClient, measurementsClient, statusClient));
case "Alexa.PercentageController":
return(new PercentageController(devicesClient, measurementsClient, statusClient));
case "Alexa.BrightnessController":
return(new BrightnessController(devicesClient, measurementsClient, statusClient));
case "Alexa.ColorController":
return(new ColorController(devicesClient, measurementsClient, statusClient));
case "Alexa.LockController":
return(new LockController(devicesClient, measurementsClient, statusClient));
case "Alexa.ThermostatController":
return(new ThermostatController(devicesClient, measurementsClient, statusClient));
case "Alexa.Authorization":
// https://developer.amazon.com/docs/device-apis/alexa-authorization.html
// AcceptGrant
// TODO: Implement Authorization Controller
LambdaLogger.Log("Alexa.Authorization not implemented");
throw new NotImplementedException(requestNamespace);
return(new NotSupportedYetController(devicesClient, measurementsClient, statusClient));
case "Alexa.TemperatureSensor":
return(new TemperatureSensorController(devicesClient, measurementsClient, statusClient));
case "Alexa.Cooking":
return(new CookingController(devicesClient, measurementsClient, statusClient));
case "Alexa.Cooking.TimeController":
return(new CookingTimeController(devicesClient, measurementsClient, statusClient));
case "Alexa.Cooking.PresetController":
return(new CookingPresetController(devicesClient, measurementsClient, statusClient));
case "Alexa.TimeHoldController":
return(new CookingTimeHoldController(devicesClient, measurementsClient, statusClient));
default:
LambdaLogger.Log("*** Unknown namespace: " + requestNamespace);
return(new NotSupportedYetController(devicesClient, measurementsClient, statusClient));
}
}
public void FixtureSetup()
{
var httpClient = new HttpClient();
_audioJobClient = new AudioJobClient(httpClient)
{
BaseUrl = ffmpegFarmUrl
};
_loudnessJobClient = new LoudnessJobClient(httpClient)
{
BaseUrl = ffmpegFarmUrl
};
_muxJobClient = new MuxJobClient(httpClient)
{
BaseUrl = ffmpegFarmUrl
};
_statusClient = new StatusClient(httpClient)
{
BaseUrl = ffmpegFarmUrl
};
_sourceMuxTestVideoFile = string.Format(_sourceMuxTestVideoFile, Environment.MachineName);
_sourceMuxTestAudioFile = string.Format(_sourceMuxTestAudioFile, Environment.MachineName);
_sourceAudioTestFile = string.Format(_sourceAudioTestFile, Environment.MachineName);
_sourceAudioLoudnessTestFile = string.Format(_sourceAudioLoudnessTestFile, Environment.MachineName);
_sourceAudioIntroFile = string.Format(_sourceAudioIntroFile, Environment.MachineName);
_sourceAudioOutroFile = string.Format(_sourceAudioOutroFile, Environment.MachineName);
_targetTestPath = string.Format(_targetTestPath, Environment.MachineName, DateTime.Now.Ticks);
_targetFileAudioPrefix = string.Format(_targetFileAudioPrefix, Environment.MachineName);
_targetFileAudioLoudnessPrefix = string.Format(_targetFileAudioLoudnessPrefix, Environment.MachineName);
_targetFileAudioIntroOutroPrefix = string.Format(_targetFileAudioIntroOutroPrefix, Environment.MachineName);
_targetFileMux = string.Format(_targetFileMux, Environment.MachineName);
if (!File.Exists(MuxTestVideoFile))
{
throw new Exception("Test file missing " + MuxTestVideoFile);
}
if (!File.Exists(MuxTestAudioFile))
{
throw new Exception("Test file missing " + MuxTestAudioFile);
}
if (!File.Exists(AudioTestFile))
{
throw new Exception("Test file missing " + AudioTestFile);
}
if (!File.Exists(AudioLoudnessTestFile))
{
throw new Exception("Test file missing " + AudioTestFile);
}
if (!File.Exists(AudioIntroTestFile))
{
throw new Exception("Test file missing " + AudioIntroTestFile);
}
if (!File.Exists(AudioOutroTestFile))
{
throw new Exception("Test file missing " + AudioOutroTestFile);
}
CleanUp();
}
//конструктор
public BaseClient(string ipAdress, int port)
{
IPAdress = ipAdress;
Port = port;
Status = StatusClient.Initialize;
}
public static IEnumerable<TwitterStatus> SelectMany(string[] ids)
{
// validate the id's by converting to a long array, also limit request to 50 id's
var idList = new long[ids.Length];
var maxLength = (ids.Length < 50) ? ids.Length : 50;
for (int i = 0; i < maxLength; i++)
{
idList[i] = long.Parse(ids[i]);
}
using (var db = new ToketeeData().Context)
{
var tweets = (from a in db.TwitterStatuses
where idList.Contains(a.Id)
select a).Distinct().ToArray().ToList();
var notFound = (from a in idList
where !tweets.Select(status => status.Id).Contains(a)
select a);
if (notFound.Any())
{
using (var queue = new Queue())
{
var statusClient = new StatusClient(TwitterDelegates.GetOAuth, 117547746);
foreach (var value in notFound)
{
var statusResult = statusClient.Show(value.ToString());
if (statusResult != null)
{
var result = TranslateStatus.ToInternal(statusResult.Data);
DbTwitterStatus.Insert(result.Id, result.CreatedAt.FromEpoch(), Json.Serialize(result));
tweets.Add(new TwitterStatus
{
Id = Parse.Long(result.Id),
Data = Encoding.UTF8.GetBytes(Json.Serialize(result)),
Sent = result.CreatedAt.FromEpoch()
});
//var result = queue.GetBrowser("id = " + value.ToString());
//foreach (var item in result)
//{
// var msg = (Apache.NMS.ActiveMQ.Commands.ActiveMQTextMessage) item;
// msg.Acknowledge();
// Queue.SingleSend(msg.Text, MsgPriority.Highest);
//}
}
}
}
}
return tweets;
}
}
public TemperatureSensorController(DevicesClient devicesClient, MeasurementsClient measurementsClient, StatusClient statusClient)
: base(devicesClient, measurementsClient, statusClient)
{
}
public FactoryContext(StatusClient statusClient)
{
this.statusClient = statusClient;
tokenSource = new CancellationTokenSource();
}
private void CommandStatus()
{
SendMessage(StatusClient.ToString());
}
