/// <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);
}
}
