/// <summary> /// Create task /// </summary> /// <param name="taskRequest">Body</param> /// <returns>Task</returns> public Task CreateTask(RequestTask taskRequest) { var path = "/public-api/tasks"; path = path.Replace("{format}", "json"); var queryParams = new Dictionary <String, String>(); var headerParams = new Dictionary <String, String>(); var formParams = new Dictionary <String, String>(); var fileParams = new Dictionary <String, FileParameter>(); String postBody = null; postBody = ApiClient.Serialize(taskRequest); // http body (model) parameter // authentication setting, if any String[] authSettings = new String[] { "X-API-Key" }; // make the HTTP request IRestResponse response = (IRestResponse)ApiClient.CallApi(path, Method.POST, queryParams, postBody, headerParams, formParams, fileParams, authSettings); if (((int)response.StatusCode) >= 400) { throw new ApiException((int)response.StatusCode, "Error calling CreateTask: " + response.Content, response.Content); } else if (((int)response.StatusCode) == 0) { throw new ApiException((int)response.StatusCode, "Error calling CreateTask: " + response.ErrorMessage, response.ErrorMessage); } return((Task)ApiClient.Deserialize(response.Content, typeof(Task), response.Headers)); }
public async Task <JsonResult> Post([FromForm] NewRequest newRequest) { RequestTaskToService requestTaskToService = JsonConvert.DeserializeObject <RequestTaskToService>(newRequest.Message); var message = new Message() { MessageText = requestTaskToService.message, Autor = requestTaskToService.user, Date = DateTime.Now.ToString(), Pictures = newRequest.Files != null ? await _imageService.SavePictures(newRequest.Files) : null, }; RequestTask request = new RequestTask() { Theme = requestTaskToService.theme, User = requestTaskToService.user, Messages = new List <Message>() { message }, DateOpen = DateTime.Now.ToString(), ObjectId = requestTaskToService.objectId, DepartmentId = requestTaskToService.departmentId, Phone = requestTaskToService.phone, Admin = "", Status = "new" }; return((await _repository.CreateRequestTaskAsync(request) >= 0) ? new JsonResult(new Status("true")) : new JsonResult(new Status("false"))); }
public IActionResult SelectCondition([FromBody] RequestTask task) { try { List <TaskTable> list = _repository.GetJoinQuery(task); foreach (var taskTable in list) { if (taskTable.ListExec.Count > 0) { foreach (var execTable in taskTable.ListExec) { execTable.ListEvent = _eventRepository.LoadAll(t => t.ExecTaskTableId.Value == execTable.Id).ToList(); } } } return(Json(new { table = list, state = "0", msg = "获取数据成功" })); } catch (Exception ex) { return(Json(new { state = "-1", msg = "非法操作!", error = ex.Message })); } }
public ActionResult DeletarConfirmed(string cpf) { try { _requestTask = new RequestTask(string.Format("{0}{1}{2}", this._address, "/", cpf)); Resultado resultado = _requestTask.DeleteCliente(); if (resultado.erro) { ViewBag.hideerro = string.Empty; ViewBag.mensagem = resultado.mensagem; return View(); } else { ViewBag.hideerro = string.Format("{0}", "hide"); return RedirectToAction("Index"); } } catch (Exception exception) { ViewBag.hideerro = string.Empty; ViewBag.mensagem = string.Format("{0}", "Ocorreu um erro excluir o cliente"); return View(); } }
public string AddClientPackage(string payload) { string ret = string.Empty; RequestTask task = RequestTask.AddClientPackage; return(string.IsNullOrEmpty(ret) ? "Hello" : ret); }
protected void ProcessRequestTask(Package taskPkg) { RequestTask request = taskPkg.Content as RequestTask; try { Console.WriteLine("收到{0}的任务包, Version:{1}", request.ClientId, request.Version); if (request.Version == "1.0.1") { TaskModel tmodel = new TaskModel(); tmodel.ProjectId = "project1"; tmodel.TaskId = "task1"; Package response = new Package() { ConnId = taskPkg.ConnId, PackType = PackType.TaskModel, Content = tmodel }; Networking.NetworkServer.Instance().Send(response); } } catch (Exception ex) { Console.WriteLine("请求任务错误:" + ex.Message); } }
public void TestCsvFileWriter() { AbstractWriter abstractWriter = WritersFactory.GetWriter(src.Entities.ResultWriter.File); DateTime endedAt = DateTime.Now; DateTime staetedAt = endedAt - TimeSpan.FromSeconds(25); FillWriter(ref abstractWriter, staetedAt, endedAt); string fileNameByDate = Path.Combine(PathResolver.GetAbsolutePath(), PathResolver.GetFileNameByDate(staetedAt)); string csvFile = fileNameByDate + ".csv"; string jsonFile = fileNameByDate + ".json"; string[] linesCsv = File.ReadLines(csvFile).ToArray(); int linesCsvCount = linesCsv.Length; Assert.True(Requests.Count + 1 == linesCsvCount); for (int i = 0; i < linesCsvCount; i++) { if (i == 0) { Assert.True(linesCsv[i] == "StartedAt;ResponseTime"); } else { RequestTask request = Requests[i - 1]; Assert.True($"{request.StartedAt};{request.TotalExecutionTime}" == linesCsv[i]); } } File.Delete(jsonFile); File.Delete(csvFile); }
/// <summary> /// Called by <see cref="NetMQPoller"/> when there is an incoming message /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnRequestReceived(object sender, NetMQSocketEventArgs e) { NetMQMessage requestMessage = null; if (!socket.TryReceiveMultipartMessage(ref requestMessage, 5)) { return; } // Move handling request off NetMQPoller thread and onto TaskPool as soon as possible Task.Run(() => { if (!messageFactory.IsValidRequestMessage(requestMessage)) { return; } var(request, address, requestId, serializerName) = messageFactory.ExtractRequest(requestMessage); void SendResponse(object response) { var message = messageFactory.CreateResponseMessage(response, address, requestId, serializerName); socket.SendMultipartMessage(message); } var requestTask = new RequestTask(this, request, SendResponse, SendResponse); requestDispatcher.Handle(ref requestTask); }); }
public ActionResult Cadastrar([Bind(Include = "cpf, nome, email, estadocivil, telefones, logradouro, numero, bairro, cidade, estado")]Cliente cliente) { try { if (ModelState.IsValid) { _requestTask = new RequestTask(this._address); cliente.telefones = verificarTelefone(cliente); Resultado resultado = _requestTask.CadastrarCliente(cliente); if (resultado.erro) { ViewBag.hideerro = string.Empty; ViewBag.mensagem = resultado.mensagem; return View(); } else { ViewBag.hideerro = string.Format("{0}", "hide"); return RedirectToAction("Index"); } } else { ViewBag.hideerro = string.Empty; ViewBag.mensagem = string.Format("{0}", "<div class='alert alert-danger' role='alert'>Ocorreu um erro ao cadastrar cliente</div>"); return View(); } } catch (Exception exception) { ViewBag.hideerro = string.Empty; ViewBag.mensagem = string.Format("{0}", "<div class='alert alert-danger' role='alert'>Ocorreu um erro ao cadastrar cliente</div>"); return View(); } }
public void RequestTask_ConstructorTest() { var message = new DataMessage<DateTime>(DateTime.Now); Action<Message> responseAction = m => { }; var requestMessage = new RequestTask(message, responseAction); AssertException.Throws<ArgumentNullException>(() => new RequestTask(null, responseAction)); AssertException.Throws<ArgumentNullException>(() => new RequestTask(message, null)); }
public List <TaskTable> GetJoinQuery(RequestTask task) { List <TaskTable> list = _dbcontext.TaskTable.Include(t => t.ListExec) .WhereIf(!string.IsNullOrWhiteSpace(task.TaskName), t => t.TaskName.Contains(task.TaskName)) .WhereIf(task.TaskTypeTableId.HasValue, t => t.TaskTypeTableId == task.TaskTypeTableId) .OrderByDescending(t => t.PubTime).ToList(); return(list); }
public async Task <JsonResult> Put([FromRoute] string status, [FromBody] RequestTask requestTask) { if (!ModelState.IsValid) { return(new JsonResult(new Status("bad data"))); } return(new JsonResult(await _repository.UpdateRequestTaskStatusAsync(requestTask))); }
public void RequestTask_WithAllRequiredFields_InitializesObject() { // Arrange var request = new Request(); // Act var requestTask = new RequestTask(receiver, request, SendResponse, SendResponse); // Assert Assert.That(request, Is.EqualTo(requestTask.Request)); }
RequestTask AddRequestTask(UnityWebRequest request, string url, string saveFileFullPath, bool needUnZip, HttpCallback callback, bool first = false, bool isAssetBundle = false, string matchMd5 = null) { RequestTask requestTask = new RequestTask(); requestTask.request = request; requestTask.status = RequestTask.EStatus.Created; requestTask.run = (self) => { self.status = RequestTask.EStatus.Running; float startTime = Time.realtimeSinceStartup; UnityWebRequestAsyncOperation asyncOper = request.SendWebRequest(); asyncOper.completed += (result) => { try { if (isAssetBundle) { OnRequestAssetBundleComplete(self.request, startTime, saveFileFullPath, callback, matchMd5); self.status = RequestTask.EStatus.Completed; } else { Task task = OnRequestComplete(self.request, startTime, needUnZip, saveFileFullPath, callback, matchMd5); if (task == null) { self.status = RequestTask.EStatus.Completed; } else { self.ioTask = task; } } } catch (System.Exception e) { Debug.LogWarning(e); self.status = RequestTask.EStatus.Completed; } }; }; if (first) { _httpRequestList.Insert(0, requestTask); } else { _httpRequestList.Add(requestTask); } return(requestTask); }
public bool CancelRequestTask(RequestTask task) { if (task == null || task.status == RequestTask.EStatus.Completed) { return(false); } task.request.Abort(); task.status = RequestTask.EStatus.Canceled; return(true); }
public DataSet Request(RequestTask CommandText) { using (SqlConnection connection = new SqlConnection(_connectionString)) { connection.Open(); SqlDataAdapter adapter = new SqlDataAdapter(CommandText.GetCommand(), connection); DataSet ds = new DataSet(); adapter.Fill(ds); return(ds); } }
public void ExecuteTest() { // mock task manager var mockTaskManager = new Moq.Mock <ITaskManager>(); mockTaskManager.Setup(manager => manager.RequestTasks()).Returns("xml"); var target = new RequestTask(); target.TaskManager = mockTaskManager.Object; target.Execute(); mockTaskManager.Verify(manager => manager.ParseTasks("xml"), Times.Once); }
public void Handle_WithNoRegisteredHandler_ThrowsRequestHandlerNotFoundException() { // Arrange Exception ex = null; var dispatcher = new DIRequestDispatcher(container); var requestTask = new RequestTask(receiver, request, _ => { }, e => ex = e); // Act dispatcher.Handle(ref requestTask); // Assert Assert.That(ex, Is.TypeOf <RequestHandlerNotFoundException>()); }
public void Handler_WithAsyncHandlerRegistered_CallsHandler() { // Arrange var dispatcher = new RequestDispatcher(); var requestTask = new RequestTask(receiver, request, _ => { }, _ => { }); dispatcher.Register(asyncHandler); // Act dispatcher.Handle(ref requestTask); // Assert mockAsyncHandler.Verify(m => m.Handle(It.IsIn(request)), Times.Once); }
public void Send(Package pkg) { if (Status == ClientStatus.Stopped) { return; } if (pkg != null) { lock (sendLock) { System.IO.MemoryStream msWBuffer = new System.IO.MemoryStream(); Thrift.Transport.TTransport tp = new Thrift.Transport.TStreamTransport(null, msWBuffer); Thrift.Protocol.TCompactProtocol cp = new Thrift.Protocol.TCompactProtocol(tp); switch (pkg.PackType) { case PackType.Command: { cp.WriteI16(PackType.Command); cp.WriteString((string)pkg.Content); } break; case PackType.ResultModel: { cp.WriteI16(PackType.ResultModel); ResultModel rm = (ResultModel)pkg.Content; rm.Write(cp); } break; case PackType.RequestTask: { cp.WriteI16(PackType.RequestTask); RequestTask rm = (RequestTask)pkg.Content; rm.Write(cp); } break; default: break; } tp.Flush(); byte[] buffer = msWBuffer.ToArray(); client.Send(buffer, buffer.Length); msWBuffer.Flush(); } } }
public void Handle_WithBaseClassHandlerFunctionRegistered_ThrowsRequestHandlerNotFoundException() { // Arrange Exception ex = null; var dispatcher = new RequestDispatcher(); var request = new RequestTask(receiver, new SubRequest(), _ => { }, e => ex = e); dispatcher.Register <Request, Response>(r => response); // Act dispatcher.Handle(ref request); // Assert Assert.That(ex, Is.TypeOf <RequestHandlerNotFoundException>()); }
public void Handle_WithHandlerFunctionRegistered_CallsHandler() { // Arrange var handled = false; var dispatcher = new RequestDispatcher(); var requestTask = new RequestTask(receiver, request, _ => { }, _ => { }); dispatcher.Register <Request, Response>(dt => { handled = true; return(response); }); // Act dispatcher.Handle(ref requestTask); // Assert Assert.That(handled, Is.True); }
public void Handle_WithHandlerRegistered_CallsHandler() { // Arrange Response ret = null; var dispatcher = new DIRequestDispatcher(container); var requestTask = new RequestTask(receiver, request, r => ret = (Response)r, _ => { }); dispatcher.Register(handler); // Act dispatcher.Handle(ref requestTask); // Assert mockHandler.Verify(m => m.Handle(It.IsIn(request)), Times.Once); }
public void Handle_WithHandlerClassRegistered_ReturnsResponse() { // Arrange Response ret = null; var dispatcher = new DIRequestDispatcher(container); var requestTask = new RequestTask(receiver, request, r => ret = (Response)r, _ => { }); dispatcher.Register(handler); // Act dispatcher.Handle(ref requestTask); // Assert Assert.That(ret is Response, Is.True); Assert.That(ret, Is.SameAs(response)); }
public void Handle_WithExceptionThrown_CallsErrorSender() { // Arrange Exception ex = null; var dispatcher = new RequestDispatcher(); var requestTask = new RequestTask(receiver, request, _ => { }, e => ex = e); RequestHandlerDelegate <Request, Response> handler = request => throw new Exception(); dispatcher.Register(handler); // Act dispatcher.Handle(ref requestTask); // Assert Assert.That(ex, Is.Not.Null); }
private void InitDifferenceExecutor() { DifferenceExecutor = new RequestTask(async delegate { await session.Established; logger.info("get difference from state: pts {0}, qts {1}, date {2}", pts, qts, date); updates_Difference difference = await this.session.Api.updates_getDifference(pts, date, qts); while (difference.Constructor == Constructor.updates_differenceSlice || difference.Constructor == Constructor.updates_difference) { List <Message> new_messages; List <Update> other_updates; List <Chat> chats; List <User> users; Updates_stateConstructor state; logger.debug("processing difference: {0}", difference); if (difference.Constructor == Constructor.updates_difference) { Updates_differenceConstructor diff = (Updates_differenceConstructor)difference; new_messages = diff.new_messages; other_updates = diff.other_updates; chats = diff.chats; users = diff.users; state = (Updates_stateConstructor)diff.state; ProcessUpdatesDifference(new_messages, other_updates, chats, users, state); break; } else { Updates_differenceSliceConstructor diff = (Updates_differenceSliceConstructor)difference; new_messages = diff.new_messages; other_updates = diff.other_updates; chats = diff.chats; users = diff.users; state = (Updates_stateConstructor)diff.intermediate_state; ProcessUpdatesDifference(new_messages, other_updates, chats, users, state); difference = await this.session.Api.updates_getDifference(pts, date, qts); } } logger.info("get difference completed successfully"); }); }
private static void OnUpdate(float delta) { //Debug.Log("gogogoog"); if (Time.frameCount % 5 != 1) { return; } bool needreduce = false; if (requests.size > ListLimit) { needreduce = true; } foreach (BGHttpRequest request in requests) { if (request.idle) { if (needreduce) { request.dispose(); requests.Remove(request); continue; } if (tasks.size > 0) { RequestTask task = tasks[0]; request.requestBody = task.requestResult; request.type = task.inType; request.taskid = task.taskid; request.httpTimeOut = task.inHttpTimeOut; request.requestSuccessed = task.requestResult.requestSuccessed; request.requestSuccessedTexture = task.requestResult.requestSuccessedTexture; request.requestFail = task.requestResult.requestFail; request.requestURLN(task.url, task.tag); tasks.Remove(task); } } else { request.check(delta); } } }
public void Handle_WithResolvableAsyncHandlerClassRegistered_ResolvesFromContainer() { // Arrange Response ret = null; var dispatcher = new DIRequestDispatcher(container); var requestTask = new RequestTask(receiver, request, r => ret = (Response)r, _ => { }); mockContainer.Setup(m => m.IsRegistered <IAsyncRequestHandler <Request, Response> >()).Returns(true); mockContainer.Setup(m => m.Resolve <IAsyncRequestHandler <Request, Response> >()).Returns(asyncHandler); dispatcher.RegisterAsync <Request, Response, IAsyncRequestHandler <Request, Response> >(); // Act dispatcher.Handle(ref requestTask); // Assert mockContainer.Verify(m => m.Resolve <IAsyncRequestHandler <Request, Response> >(), Times.Once); }
public void Handle_WithAsyncHandlerRegistered_ReturnsResponse() { // Arrange Response ret = null; var dispatcher = new DIRequestDispatcher(container); var requestTask = new RequestTask(receiver, request, r => ret = (Response)r, _ => { }); AsyncRequestHandlerDelegate <Request, Response> handler = request => Task.FromResult(response); dispatcher.RegisterAsync(handler); // Act dispatcher.Handle(ref requestTask); // Assert Assert.That(ret is Response, Is.True); Assert.That(ret, Is.SameAs(response)); }
public void Handle_WithResolvableHandlerClassRegistered_ReturnsResponse() { // Arrange Response ret = null; var dispatcher = new DIRequestDispatcher(container); var requestTask = new RequestTask(receiver, request, r => ret = (Response)r, _ => { }); mockContainer.Setup(m => m.IsRegistered <IRequestHandler <Request, Response> >()).Returns(true); mockContainer.Setup(m => m.Resolve <IRequestHandler <Request, Response> >()).Returns(handler); dispatcher.Register <Request, Response, IRequestHandler <Request, Response> >(); // Act dispatcher.Handle(ref requestTask); // Assert Assert.That(ret is Response, Is.True); Assert.That(ret, Is.SameAs(response)); }
/// <summary> /// Dispatches a request and returns the result to the client through the receiver /// </summary> /// <param name="receiver"><see cref="IReceiver"/> that the request was sent to</param> /// <param name="requestTask">Combines all details needed to handle the incoming request</param> public void Handle(ref RequestTask requestTask) { try { var requestType = requestTask.Request.GetType(); if (!requestHandlers.TryGetValue(requestType, out var handler)) { throw new RequestHandlerNotFoundException(requestType); } var response = handler(requestTask.Request); requestTask.ResponseSender(response); } catch (Exception ex) { requestTask.ErrorSender(ex); } }
public void RequestTaskReward(MsgPack msgPack) { RequestTask data = msgPack.Msg.RequestTask; NetMsg netMsg = new NetMsg { cmd = (int)Command.ResponseTask }; PlayerData playerData = _cacheSvc.GetPlayerDataBySession(msgPack.Session); TaskRewardCfg taskCfg = _resCfgSvc.GetTaskData(data.TaskId); TaskRewardData taskData = CalcTaskRewardData(playerData, data.TaskId); if (taskData.Prangs == taskCfg.Count && !taskData.Tasked) { playerData.Coin += taskCfg.Coin; PeRoot.CalcExp(playerData, taskCfg.Exp); playerData.Diamond += taskCfg.Diamond; taskData.Tasked = true; CalcTaskArray(playerData, taskData); if (!_cacheSvc.UpdatePlayerData(playerData.Id, playerData)) { netMsg.err = (int)ErrorCode.UpdateDbError; } else { ResponseTask responseTask = new ResponseTask { Coin = playerData.Coin, Level = playerData.Level, Diamond = playerData.Diamond, Exp = playerData.Exp, TaskArray = playerData.TaskArray, }; netMsg.ResponseTask = responseTask; } } else { netMsg.err = (int)ErrorCode.ClientDataError; } msgPack.Session.SendMsg(netMsg); }
/// <summary> /// 完成阅读文章及亲友聊天任务 /// </summary> /// <returns></returns> async static Task DoTaskAsync(string uid) { var tasks = default(TaskType).GetFieldValues <TaskType>(); var result = new ResultRest <ResultTask>(); foreach (var t in tasks) { //完成文章阅读 var data = new RequestTask(t, uid); if (t == TaskType.Info) { await DoTaskByTypeAsync(t, uid, 5); } else { await DoTaskByTypeAsync(t, uid); } } }
public ActionResult Editar([Bind(Include = "_id, cpf, nome, email, estadocivil, telefones, logradouro, numero, bairro, cidade, estado")]Cliente cliente) { try { if (ModelState.IsValid) { _requestTask = new RequestTask(string.Format("{0}{1}{2}", this._address, "/", cliente.cpf)); cliente.telefones = verificarTelefone(cliente); Resultado resultado = _requestTask.EditarCliente(cliente); if (resultado.erro) { ViewBag.hideerro = string.Empty; ViewBag.mensagem = resultado.mensagem; return View(); } else { ViewBag.hideerro = string.Format("{0}", "hide"); return RedirectToAction("Index"); } } } catch (Exception exception) { ViewBag.hideerro = string.Empty; ViewBag.mensagem = string.Format("{0}", "Ocorreu um erro ao alterar o cliente"); return View(); } return View(cliente); }
public ActionResult GetCliente(string cpf) { if (!string.IsNullOrEmpty(cpf)) { _requestTask = new RequestTask(string.Format("{0}{1}{2}", this._address, "/", cpf)); Resultado resultado = _requestTask.BuscarClientes(); if (resultado.erro) { ViewBag.hideerro = string.Empty; ViewBag.mensagem = resultado.mensagem; return View(); } else { if (resultado.lista != null && resultado.lista.Count > 0) { if (resultado.lista[0].telefones.Count == 2) { resultado.lista[0].telefones.Add(new Telefone()); } else if (resultado.lista[0].telefones.Count == 1) { resultado.lista[0].telefones.Add(new Telefone()); resultado.lista[0].telefones.Add(new Telefone()); } else if (resultado.lista[0].telefones.Count == 0) { resultado.lista[0].telefones.Add(new Telefone()); resultado.lista[0].telefones.Add(new Telefone()); resultado.lista[0].telefones.Add(new Telefone()); } ViewBag.hideerro = string.Format("{0}", "hide"); return View(resultado.lista[0]); } else { ViewBag.hideerro = string.Empty; ViewBag.mensagem = string.Format("{0}", "Cliente não está cadastrado no sistema"); return View(); } } } else { return RedirectToAction("Index"); } }
public ActionResult Index() { _requestTask = new RequestTask(this._address); Resultado resultado = _requestTask.BuscarClientes(); if (resultado.erro) { ViewBag.hideerro = string.Empty; ViewBag.mensagem = resultado.mensagem; return View(); } else { ViewBag.hideerro = string.Format("{0}", "hide"); return View(resultado.lista); } }