public void TestCloseOrder()
{
CreateOrderEuResponse response = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(TestingTool.CreateExVatBasedOrderRow())
.AddCustomerDetails(Item.IndividualCustomer()
.SetNationalIdNumber(TestingTool.DefaultTestIndividualNationalIdNumber))
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber)
.SetOrderDate(TestingTool.DefaultTestDate)
.SetCurrency(TestingTool.DefaultTestCurrency)
.UseInvoicePayment()
.DoRequest();
Assert.That(response.ResultCode, Is.EqualTo(0));
Assert.That(response.Accepted, Is.True);
CancelOrderResponse closeResponse = WebpayAdmin.CancelOrder(SveaConfig.GetDefaultConfig())
.SetOrderId(response.CreateOrderResult.SveaOrderId)
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.CancelInvoiceOrder()
.DoRequest();
Assert.That(closeResponse.ResultCode, Is.EqualTo(0));
Assert.That(response.Accepted, Is.True);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
CancelOrderResponse response = new CancelOrderResponse();
return(response);
}
public void Handle(PayedOrderRequest message)
{
var response = new CancelOrderResponse();
var service = new HotelOrderService();
try
{
var order = service.GetModel(message.OrderId);
if (CheckStatus(order))
{
response.Success = service.Update(message.OrderId,
HotelStatusManager.OrderStatus.Payed.StatusId.ToString());
}
else
{
response.Success = false;
}
}
catch
{
response.Success = false;
}
_bus.Reply(response);
}
public async Task <ApiResult <CancelOrderResponse> > CancelOrder(string userId, TradeCancelType cancelType, int?orderId, string market)
{
try
{
var result = await TradeService.QueueCancel(new CancelTradeModel
{
UserId = userId,
Market = market,
OrderId = orderId,
CancelType = cancelType,
IsApi = true
});
if (result.HasError)
{
return(new ApiResult <CancelOrderResponse>(false, result.Error));
}
var response = new CancelOrderResponse
{
CanceledOrders = result.CanceledOrders
};
return(new ApiResult <CancelOrderResponse>(true, response));
}
catch (Exception ex)
{
return(new ApiResult <CancelOrderResponse>(ex));
}
}
public async Task <ActionResult <CancelOrderResponse> > Cancel([FromRoute] CancelOrderRequest request)
{
_logger.LogInformation($"Cancel order service call for {request.OrderNumber}...");
var response = new CancelOrderResponse();
try
{
var order = await _orderProcessingService.GetOrderAsync(request.OrderNumber);
await _orderProcessingService.CancelOrderAsync(order);
response.OperationSucceded = true;
}
catch (OrderNotFoundException ex)
{
_logger.LogWarning($"{ex.Message}");
return(NotFound(ex.Message));
}
catch (ValidationException ex)
{
_logger.LogWarning($"Validations failures: {ex.Message}");
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
_logger.LogError($"Exception occured while canceling order: {ex.Message} {ex.StackTrace}");
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
return(Ok(response));
}
public override Task <CancelOrderResponse> CancelOrder(CancelOrderRequest request, grpc::ServerCallContext context)
{
Console.WriteLine("Handling Order cancellation request");
var result = new CancelOrderResponse();
try
{
var exists = orderManagementClient.OrderExists(new GetOrderRequest {
OrderID = request.OrderID
});
if (!exists.Exists)
{
result.Canceled = false;
return(Task.FromResult(result));
}
var originalOrder = orderManagementClient.GetOrder(new GetOrderRequest {
OrderID = request.OrderID
});
var evt = new OrderCanceledEvent
{
OrderID = request.OrderID,
UserID = request.UserID,
CreatedOn = (ulong)DateTime.UtcNow.Ticks,
ActivityID = Guid.NewGuid().ToString(),
};
if (eventEmitter.EmitOrderCanceledEvent(evt))
{
result.ConfirmationCode = Guid.NewGuid().ToString();
result.Canceled = true;
foreach (var li in originalOrder.LineItems)
{
eventEmitter.EmitInventoryReleasedEvent(new InventoryReleasedEvent
{
SKU = li.SKU,
ReleasedOn = (ulong)DateTime.UtcNow.Ticks,
Quantity = li.Quantity,
OrderID = request.OrderID,
UserID = request.UserID,
EventID = Guid.NewGuid().ToString()
});
}
}
else
{
result.Canceled = false;
}
return(Task.FromResult(result));
}
catch (Exception ex)
{
Console.WriteLine($"Failed to handle order cancellation {ex.ToString()}");
result.Canceled = false;
return(Task.FromResult(result));
}
}
/// <summary>
/// 取消接口
/// </summary>
/// <param name="requestData"></param>
/// <returns></returns>
public string CancelOrder(RequestData requestData)
{
var request = _tongChengGateway.CheckCancelOrder(requestData.RequestBody);
var data = request.Data;
var response = _ticketGateway.CancelOrder(new OrderCancelRequest
{
Body = new OrderCancelBody
{
OrderInfo = new OrderCancelInfo
{
OrderId = data.partnerOrderId,
OrderPrice = 0,
OrderQuantity = data.tickets,
reason = data.reason,
Seq = data.orderSerialId
}
}
});
if (response.Head.Code == "000000")
{
var tongChengResponse = new CancelOrderResponse
{
refundStatus = 1,
remark = "成功"
};
return(_tongChengGateway.CancelOrder(tongChengResponse));
}
else if (response.Head.Code == "114007")
{
var tongChengResponse = new CancelOrderResponse
{
refundStatus = 3,
remark = "订单取消失败，不支持部分取消"
};
return(_tongChengGateway.CancelOrder(tongChengResponse));
}
else if (response.Head.Code == "114004")
{
return(_tongChengGateway.ErrorResult(ResultCode.OrderNumberNotExist, response.Head.Describe));
}
else if (response.Head.Code == "114009" || response.Head.Code == "114013")
{
return(_tongChengGateway.ErrorResult(ResultCode.CancelOrderForConsume, response.Head.Describe));
}
else if (response.Head.Code == "114010")
{
return(_tongChengGateway.ErrorResult(ResultCode.CancelOrderForCancel, response.Head.Describe));
}
else if (response.Head.Code == "114011")
{
return(_tongChengGateway.ErrorResult(ResultCode.CancelOrderForExpired, response.Head.Describe));
}
else if (response.Head.Code == "114012")
{
return(_tongChengGateway.ErrorResult(ResultCode.Error, response.Head.Describe));
}
return(_tongChengGateway.ErrorResult(ResultCode.DataError, response.Head.Describe));
}
public CancelOrderResponse CancelOrder(int order_id)
{
CancelOrderRequest req = new CancelOrderRequest(Nonce, order_id);
string response = SendRequest(req, "POST");
CancelOrderResponse resp = CancelOrderResponse.FromJSON(response);
return(resp);
}
public void SendCancelOrderRequest_IfValidOrderAndTraderIdProvided_ReceiveResponseAndCommandShouldBePublishedOnDisruptor()
{
CancelOrderResponse response =
_orderseService.CancelOrder(new CancelOrderCommand(new OrderId("12"), new TraderId("12")));
_manualResetEvent.WaitOne(3000);
Assert.NotNull(response);
Assert.NotNull(_cancellation);
}
public static CancelOrderResponse Unmarshall(UnmarshallerContext context)
{
CancelOrderResponse cancelOrderResponse = new CancelOrderResponse();
cancelOrderResponse.HttpResponse = context.HttpResponse;
cancelOrderResponse.RequestId = context.StringValue("CancelOrder.RequestId");
cancelOrderResponse.ClusterId = context.StringValue("CancelOrder.ClusterId");
return(cancelOrderResponse);
}
private BaseResponse ParseRawData(ByteBuffer buf)
{
MessageType msgType;
try
{
msgType = (MessageType)lastHeader.msgId;
}
catch
{
return(null);
}
BaseResponse resp = null;
if (msgType == MessageType.RejectResponse)
{
resp = RejectResponse.ReadFromBuffer(lastHeader, buf, offset);
}
else if (msgType == MessageType.NewOrderReport)
{
resp = OrderResponse.ReadFromBuffer(lastHeader, buf, offset);
}
else if (msgType == MessageType.CancelReport)
{
resp = CancelOrderResponse.ReadFromBuffer(lastHeader, buf, offset);
}
else if (msgType == MessageType.ExecutionReport)
{
resp = ExecutionReport.ReadFromBuffer(lastHeader, buf, offset);
}
else if (msgType == MessageType.MassCancelReport)
{
resp = MassCancelResponse.ReadFromBuffer(lastHeader, buf, offset);
}
if (resp != null)
{
if (!messagesParsedByType.TryGetValue(resp.GetType(), out var count))
{
messagesParsedByType.Add(resp.GetType(), 1);
}
else
{
messagesParsedByType[resp.GetType()] = count + 1;
}
}
return(resp);
}
public IMessageIn Visit(CancelOrderResponse msg)
{
Condition.Requires(_data, "data").IsNotNull();
// {"order_id":"1476459990","result":"true"}
if ((string)_data["result"] != "true")
{
_log.Error("Unexpected response to new future request. Ignoring it.");
return(null);
}
msg.OrderId = (long)_data["order_id"];
return(msg);
}
public async Task Consume(ConsumeContext <CancelOrderRequest> context)
{
var request = context.Message;
Domain.Order order = await repo.GetOrder(request.OrderId);
order.Cancel();
order = await repo.SaveAsync(order);
var response = new CancelOrderResponse(true, ResponseAction.Updated);
await context.RespondAsync(response);
}
/// <summary>
/// 成功返回
/// </summary>
/// <param name="responseBody"></param>
/// <returns></returns>
public static string SuccessResult(CancelOrderBodyRespose responseBody)
{
var responseData = new CancelOrderResponse
{
header = new HeaderResponse
{
resultCode = ResultCode.Success,
resultMessage = "成功"
},
body = responseBody
};
return(Helper.SerializeToXml(responseData));
}
public async Task <CancelOrderResponse> CancelOrderAsync()
{
(_, var returnWallet) = GetReturnWallet(_machineWallet, _depositMoney);
_depositMoney = 0;
var response = new CancelOrderResponse()
{
Wallet = returnWallet.ToWalletDto(),
Message = $"Order is cancelled.",
IsSuccess = true
};
return(await Task.FromResult(response));
}
public static CancelOrderResponse Unmarshall(UnmarshallerContext context)
{
CancelOrderResponse cancelOrderResponse = new CancelOrderResponse();
cancelOrderResponse.HttpResponse = context.HttpResponse;
cancelOrderResponse.RequestId = context.StringValue("CancelOrder.RequestId");
cancelOrderResponse.Code = context.StringValue("CancelOrder.Code");
cancelOrderResponse.Message = context.StringValue("CancelOrder.Message");
cancelOrderResponse.SubCode = context.StringValue("CancelOrder.SubCode");
cancelOrderResponse.SubMessage = context.StringValue("CancelOrder.SubMessage");
cancelOrderResponse.LogsId = context.StringValue("CancelOrder.LogsId");
cancelOrderResponse.Success = context.BooleanValue("CancelOrder.Success");
return(cancelOrderResponse);
}
public async Task <bool> SfCancelOrder(string orderId)
{
Logger.InfoFormat("正在向顺丰取消订单，订单号:{0}", orderId);
CancelOrderRequest request = new CancelOrderRequest();
request.Head = await _settingManager.GetSettingValueAsync(Settings.ShunFeng.ClientCode);
request.OrderConfirm.OrderId = orderId;
request.OrderConfirm.DealType = "2";
request.ServiceName = "OrderConfirmService";
request.Lang = "zh-CN";
var url = await _settingManager.GetSettingValueAsync(Settings.ShunFeng.Url);
var checkword = await _settingManager.GetSettingValueAsync(Settings.ShunFeng.CheckWord);
var result = await DoPostAsync(url, request.ToXml(), GetVerifyCode(request.ToXml(), checkword));
var response = CancelOrderResponse.Parse(result);
if (response.Head == "OK")
{
if (response.Body.ConfirmResponse.ResStatus == "2")
{
Logger.InfoFormat("订单号:{0}取消寄件成功!", orderId);
return(true);
}
else
{
Logger.ErrorFormat("订单号:{0}取消寄件失败，失败原因:{1}", orderId, "客户订单号与顺丰运单不匹配");
return(false);
}
}
else
{
if (response.Error == "已消单")
{
Logger.InfoFormat("订单号:{0}已消单", orderId);
return(true);
}
else
{
Logger.ErrorFormat("订单号:{0}取消寄件失败，失败原因:{1}", orderId, response.Error);
return(false);
}
}
}
public static CancelOrderResponse Unmarshall(UnmarshallerContext context)
{
CancelOrderResponse cancelOrderResponse = new CancelOrderResponse();
cancelOrderResponse.HttpResponse = context.HttpResponse;
cancelOrderResponse.RequestId = context.StringValue("CancelOrder.RequestId");
cancelOrderResponse.Success = context.BooleanValue("CancelOrder.Success");
cancelOrderResponse.Code = context.StringValue("CancelOrder.Code");
cancelOrderResponse.Message = context.StringValue("CancelOrder.Message");
CancelOrderResponse.CancelOrder_Data data = new CancelOrderResponse.CancelOrder_Data();
data.HostId = context.StringValue("CancelOrder.Data.HostId");
cancelOrderResponse.Data = data;
return(cancelOrderResponse);
}
public override Task <CancelOrderResponse> CancelOrder(CancelOrderRequest request, grpc::ServerCallContext context)
{
logger.LogInformation("Handling Order cancellation request");
var result = new CancelOrderResponse();
try
{
var agg = new OrderAggregate(request.OrderID);
// TODO: load aggregate with order events
var exists = orderManagementClient.OrderExists(new GetOrderRequest {
OrderID = request.OrderID
});
if (!exists.Exists)
{
result.Canceled = false;
return(Task.FromResult(result));
}
var originalOrder = orderManagementClient.GetOrder(new GetOrderRequest {
OrderID = request.OrderID
});
var productAggregates = GetProductAggregates(originalOrder.LineItems.ToArray());
IList <DomainEvent> evts = agg.Cancel(request.UserID, productAggregates);
foreach (var evt in evts)
{
this.eventEmitter.Emit(evt);
}
result.Canceled = true;
result.ConfirmationCode = Guid.NewGuid().ToString(); // unused
return(Task.FromResult(result));
}
catch (Exception ex)
{
logger.LogError(ex, "Failed to cancel order");
result.Canceled = false;
return(Task.FromResult(result));
}
}
/// <summary>
/// Cancel order for specified symbol by clientOrderId
/// </summary>
/// <param name="symbol">Optional parameter to filter active orders by symbol</param>
public OrderInformation SetCancelOrder(string clientOrderId, string symbol = "")
{
CancelOrderResponse response = hitbtcClient.SetCancelOrder(clientOrderId, symbol);
OrderInformation result = new OrderInformation()
{
Id = response.Id,
ClientOrderId = response.ClientOrderId,
Symbol = response.Symbol,
Side = response.Side,
Status = response.Status,
TypeOrder = response.TypeOrder,
TimeInForce = response.TimeInForce,
Quantity = response.Quantity,
Price = response.Price,
CumQuantity = response.CumQuantity,
CreatedAt = response.CreatedAt,
UpdatedAt = response.UpdatedAt
};
return(result);
}
public override void CancelOrder(Order order)
{
string timeStamp = TimeManager.GetUnixTimeStampSeconds().ToString();
var headers = new Dictionary <string, string>();
headers.Add("Timestamp", timeStamp);
headers.Add("KEY", _publicKey);
headers.Add("SIGN", _signer.GetSignStringRest("DELETE", _path + _wallet + $"/orders/{order.NumberMarket}", "", "", timeStamp));
var result = _requestREST.SendGetQuery("DELETE", _host + _path + _wallet, $"/orders/{order.NumberMarket}", headers);
CancelOrderResponse cancelResponse = JsonConvert.DeserializeObject <CancelOrderResponse>(result);
if (cancelResponse.FinishAs == "canceled")
{
SendLogMessage($"Order num {order.NumberUser} canceled.", LogMessageType.Trade);
order.State = OrderStateType.Cancel;
OnOrderEvent(order);
}
else
{
SendLogMessage($"Error on order cancel num {order.NumberUser}", LogMessageType.Error);
}
}
public void SendCancelOrderRequest_IfOrderIdIsNull_ReceiveInvalidOperationException()
{
CancelOrderResponse response =
_orderseService.CancelOrder(new CancelOrderCommand(null, null));
}
/// <summary>
/// 取消接口
/// </summary>
/// <param name="response"></param>
/// <returns></returns>
public string CancelOrder(CancelOrderResponse response)
{
return(Api.SuccessResult(response));
}
public void CancelTrade(int order_id)
{
CancelOrderResponse cancel = api.CancelOrder(order_id);
}
/// <summary>
/// Process the incoming messages
/// </summary>
/// <param name="message">Incoming message</param>
private void processMessage(string message)
{
// Deserialize the incoming command to check wich message has just arrived
// The action property brings the command name
switch (Command.Deserialize(message).action)
{
case KeepAlive.CLASSNAME:
{ // If it is a KeepAlive message, just answer Quantsis Conneciton Box another KeepAlive message
//CheckAsyncTaskInProgress
this.send(new KeepAlive().Serialize());
break;
}
case NewOrderResponse.CLASSNAME:
{ // If it is an NewOrderResponse message and it contains error, show the error message
var cmd = NewOrderResponse.Deserialize(message);
if (!cmd.success)
{
NotifyOMS(cmd.ToString());
}
break;
}
case NewStopOrderResponse.CLASSNAME:
{ // If it is an NewStopOrderResponse message and it contains error, show the error message
var cmd = NewStopOrderResponse.Deserialize(message);
if (!cmd.success)
{
NotifyOMS(cmd.ToString());
}
break;
}
case NewStopGainLossOrderResponse.CLASSNAME:
{ // If it is an NewStopGainLossOrderResponse message and it contains error, show the error message
var cmd = NewStopGainLossOrderResponse.Deserialize(message);
if (!cmd.success)
{
NotifyOMS(cmd.ToString());
}
break;
}
case CancelOrderResponse.CLASSNAME:
{ // If it is an CancelOrderResponse message and it contains error, show the error message
var cmd = CancelOrderResponse.Deserialize(message);
if (!cmd.success)
{
NotifyOMS(cmd.ToString());
}
break;
}
case ExecutionReport.CLASSNAME:
{ // If it is an ExecutionReport message, check if it was successful and updates the order list or show error message
var cmd = ExecutionReport.Deserialize(message);
if (cmd.success)
{
NotifyOMS(cmd.ToString());
}
else
{
NotifyOMS(cmd.ToString());
}
break;
}
case OrderListResponse.CLASSNAME:
{ // If it is an OrderListResponse, check if it was successful. In negative case show error message.
var cmd = OrderListResponse.Deserialize(message);
if (!cmd.success)
{
NotifyOMS(cmd.ToString());
}
break;
}
case PositionResponse.CLASSNAME:
{ // If it is a Position Response, check if it was successful and updates the position list. In case of failure, show error messasge
var cmd = PositionResponse.Deserialize(message);
if (cmd.success)
{
NotifyOMS(cmd.ToString());
}
else
{
NotifyOMS(cmd.ToString());
}
break;
}
case QuoteResponse.CLASSNAME:
{ // If it is a Quote Response, check if it was successful and logs the message
var cmd = QuoteResponse.Deserialize(message);
if (cmd.success)
{
OnQuoteResponse(cmd);
}
else
{
NotifyQCB(cmd.ToString());
}
break;
}
case QuoteUpdate.CLASSNAME:
{ // If it is a Quote Update, check if it was successful and logs the message
var cmd = QuoteUpdate.Deserialize(message);
if (cmd.success)
{
OnQuoteUpdate(cmd);
}
else
{
NotifyQCB(cmd.ToString());
}
break;
}
case QuoteUnsubscribeResponse.CLASSNAME:
{ // If it is a Quote Unsubscribe Response, check if it was successful
var cmd = QuoteUnsubscribeResponse.Deserialize(message);
if (cmd.success)
{
NotifyOMS(cmd.ToString());
}
else
{
NotifyOMS(cmd.ToString());
}
break;
}
case CandleResponse.CLASSNAME:
{ // If it is a Quote Update, check if it was successful and logs the message
var cmd = CandleResponse.Deserialize(message);
if (cmd.success)
{
if (cmd.candles != null)
{
if (cmd.candles.Count <= 0)
{
NotifyOMS("Nenhum foi possivel retornar nenhum candle para " + cmd.security + " - Timeframe: " + cmd.timeframe);
}
else
{
NotifyOMS("Dados Historicos Intraday para: " + cmd.security + " - Qtd de Candles: " + cmd.candles.Count + " - Timeframe: " + cmd.timeframe);
//foreach (Candle candle in cmd.candles)
// this.mainForm.log(candle.ToString());
}
}
}
else
{
NotifyOMS(cmd.ToString());
}
break;
}
// Candle Update
case CandleUpdate.CLASSNAME:
{ // If it is a Candle Update, check if it was successful and logs the message
var cmd = CandleUpdate.Deserialize(message);
if (cmd.success)
{
if (cmd.candle != null)
{
switch (cmd.timeframe)
{
case CandleUpdate.TIMEFRAME_INTRADAY_1_MIN:
NotifyOMS("Candle Intraday Update: " + cmd.security + " - Last: " + cmd.candle.close + " - Time: " + cmd.candle.date);
break;
case CandleUpdate.TIMEFRAME_DAILY:
NotifyOMS("Candle Daily Update: " + cmd.security + " - Last: " + cmd.candle.close + " - Time: " + cmd.candle.date);
break;
}
}
}
//this.mainForm.updatePositions(cmd);
else
{
NotifyOMS(cmd.ToString());
}
break;
}
// QCB has disconnected (shut down)
case Disconnect.CLASSNAME:
this.disconnect();
break;
}
}
private void DisplayCancelOrderResponse(CancelOrderResponse cancelOrderResponse)
{
AppendReceiverBox($"CancelOrderResponse - OrdID: {cancelOrderResponse.OrderID}, ResultCode: {cancelOrderResponse.ResultCode}");
}
public string Visit(CancelOrderResponse msg)
{
return(CancelOrder(msg.ProductType, msg.Currency));
}
public override async Task <CancelOrderResponse> CancelAllOrders(CancelOrdersRequest request, ServerCallContext context)
{
MeResponseModel response;
if (!string.IsNullOrEmpty(request.AssetPairId))
{
var result = await _validationService.ValidateAssetPairAsync(request.AssetPairId);
if (result != null)
{
var res = new CancelOrderResponse
{
Error = new ErrorResponseBody {
Code = ErrorCode.InvalidField, Message = result.Message
}
};
res.Error.Fields.Add(result.FieldName, result.Message);
}
bool?isBuy;
if (request.OptionalSideCase == CancelOrdersRequest.OptionalSideOneofCase.None)
{
isBuy = null;
}
else
{
switch (request.Side)
{
case Side.Buy:
isBuy = true;
break;
case Side.Sell:
isBuy = false;
break;
default:
isBuy = null;
break;
}
}
var model = new LimitOrderMassCancelModel
{
Id = Guid.NewGuid().ToString(),
AssetPairId = request.AssetPairId,
ClientId = context.GetClientId(),
IsBuy = isBuy
};
response = await _matchingEngineClient.MassCancelLimitOrdersAsync(model);
}
else
{
var orders = await GetOrders(new LimitOrdersRequest(), context);
if (orders.Body?.Orders.Any() ?? false)
{
var orderIds = orders.Body.Orders.Select(x => x.Id).ToList();
response = await _matchingEngineClient.CancelLimitOrdersAsync(orderIds);
}
else
{
response = new MeResponseModel {
Status = MeStatusCodes.Ok
};
}
}
if (response == null)
{
return(new CancelOrderResponse
{
Error = new ErrorResponseBody {
Code = ErrorCode.Runtime, Message = ErrorMessages.MeNotAvailable
}
});
}
if (response.Status == MeStatusCodes.Ok)
{
return new CancelOrderResponse
{
Body = new CancelOrderResponse.Types.Body
{
Payload = true
}
}
}
;
return(new CancelOrderResponse
{
Error = new ErrorResponseBody {
Code = ErrorCode.Runtime, Message = response.Message ?? response.Status.ToString()
}
});
}
