public OrderRequestController(IExportHelper exportHelper, IUserContext userContext, IOrderRequest orderRequestService, IPermissionService permissionService)
: base(userContext, permissionService)
{
m_ExportHelper = exportHelper;
orderRequest = new SCMS.Reports.Orders.OrderRequest();
this.orderRequestService = orderRequestService;
}
public BinCardController(IPermissionService permissionService, IUserContext userContext, IBinCardService _binService,
IOrderRequest _orService)
: base(userContext, permissionService)
{
this._binService = _binService;
this._orService = _orService;
}
public FleetManagerController(IPermissionService permissionService, IUserContext userContext, IFleetDetailsService fleetservice,
IStaffService staffService, InventoryService inventoryService, IOrderRequest ORService, IPurchaseOrderService poService)
: base(userContext, permissionService)
{
this.orService = ORService;
this.staffService = staffService;
this.fleetservice = fleetservice;
this.inventoryService = inventoryService;
this.poService = poService;
}
public GoodsReceivedNoteController(IPermissionService permissionService, IUserContext userContext, IGoodsReceivedNoteService _goodsReceivedNoteService,
IOrderRequest ORService, InventoryService invetService, INotificationService notificationService, IStaffService staffService)
: base(userContext, permissionService)
{
this.gRNService = _goodsReceivedNoteService;
this.ORService = ORService;
this.invetService = invetService;
this.notificationService = notificationService;
this.staffService = staffService;
}
public ProcurementPlanController(IProcurementPlanService ppService, IOrderRequest orService, ICountrySubOfficeService csoService, IUserContext uc,
IPermissionService permService, INotificationService notificationService, IItemService itemService)
: base(uc, permService)
{
this.ppService = ppService;
this.orService = orService;
this.csoService = csoService;
this.notificationService = notificationService;
this.itemService = itemService;
}
public Request4PaymentController(IPermissionService permissionService, IRequest4PaymentService R4PSevice, IOrderRequest OrderrequestService,
IPurchaseOrderService POservice, IStaffService staffService,
IExchangeRateService exchangeRateService, INotificationService notificationService, IUserContext userContext)
: base(userContext, permissionService)
{
this.R4PSevice = R4PSevice;
this.OrderrequestService = OrderrequestService;
this.POservice = POservice;
this.staffService = staffService;
this.exchangeRateService = exchangeRateService;
this.notificationService = notificationService;
}
public BudgetController(IPermissionService permissionService, IBudgetService budgetService, IProjectService projectService, IMasterBudgetService masterBudgetService,
IExchangeRateService exchangeRateService, IStaffService staffService, IUserContext userContext, ICurrencyService currencyService,
IOrderRequest orderRequestService)
: base(userContext, permissionService)
{
this.budgetService = budgetService;
this.masterBudgetService = masterBudgetService;
this.projectService = projectService;
this.exchangeRateService = exchangeRateService;
this.staffService = staffService;
this.currencyService = currencyService;
this.orderRequestService = orderRequestService;
}
public PurchaseOrderController(IPermissionService permissionService, IUserContext userContext, IPurchaseOrderService POService, IOrderRequest ORService,
IExchangeRateService exchangeRateService, INotificationService notificationService, ISupplierService supplierService, ILocationService locationService,
IProcurementPlanService ppService)
: base(userContext, permissionService)
{
this.poService = POService;
this.orService = ORService;
this.ppService = ppService;
this.notificationService = notificationService;
this.exchangeRateService = exchangeRateService;
this.supplierService = supplierService;
this.locationService = locationService;
}
/// <summary>
/// Posts an order on the given account with the given parameters
/// </summary>
/// <param name="account">the account to post on</param>
/// <param name="request">the order request to post</param>
/// <returns>PostOrderResponse with details of the results (throws if if fails)</returns>
public static async Task <OrderPostResponse> PostOrderAsync(string account, IOrderRequest request)
{
string requestString = Server(EServer.Account) + "accounts/" + account + "/orders";
Dictionary <string, IOrderRequest> order = new Dictionary <string, IOrderRequest>();
order.Add("order", request);
string body = ConvertToJSON(order);
var response = await MakeRequestWithJSONBody <OrderPostResponse, OrderPostErrorResponse>("POST", body, requestString);
return(response);
}
public void ShouldBuildCustomMessageWhenReceiveCustomCodes(string expectedCode, string expectedResult)
{
// Given
IOrderRequest orderRequest = Substitute.For <IOrderRequest>();
orderRequest.GetTerminalCode().Returns(expectedCode);
IOrderCookMessageMaker orderCookMessageMaker = new OrderCookMessageMaker();
// When
string expectedMessage = orderCookMessageMaker.CreateMessageToCooks(orderRequest);
// Then
expectedMessage.Should().Be(expectedResult);
}
public void ShouldBuildEmptyMessageWhenReceiveEmptyOrderRequest()
{
// Given
IOrderRequest orderRequest = Substitute.For <IOrderRequest>();
orderRequest.GetTerminalCode().Returns(string.Empty);
IOrderCookMessageMaker orderCookMessageMaker = new OrderCookMessageMaker();
// When
string expectedMessage = orderCookMessageMaker.CreateMessageToCooks(orderRequest);
// Then
expectedMessage.Should().BeEmpty();
}
public OrderRequestController(IPermissionService permissionService, IOrderRequest orderRequestService, IUserContext userContext,
INotificationService notificationService, ILocationService locationService, IItemService itemService, IProcurementPlanService ppService,
IExchangeRateService exchangeRateService, ICurrencyService currencyService, IBudgetService budgetService)
: base(userContext, permissionService)
{
this.orderRequestService = orderRequestService;
this.notificationService = notificationService;
this.locationService = locationService;
this.itemService = itemService;
this.ppService = ppService;
this.exchangeRateService = exchangeRateService;
this.currencyService = currencyService;
this.budgetService = budgetService;
}
public async Task <ICreateOrderResult> CreateOrderAsync(IOrderRequest request, System.Threading.CancellationToken cancellationToken)
{
throw new InvalidOperationException("Not support at this time");
//List<Bittrex.API.Data.TradeBaseOrder> stock = new List<Bittrex.API.Data.TradeBaseOrder>();
//stock.Add(new Bittrex.API.Data.TradeBaseOrder
//{
// Pair = request.Pair.Name,
// Amount = request.Amount.ToString("0.00000000", System.Globalization.CultureInfo.InvariantCulture),
// Price = request.Rate.ToString("0.00000000", System.Globalization.CultureInfo.InvariantCulture),
// Type = request.RequestType == OrderType.buy ? Bittrex.API.Data.TradeOrderType.buy : Bittrex.API.Data.TradeOrderType.sell
//});
//_logger.Trace($"Request: {Newtonsoft.Json.JsonConvert.SerializeObject(stock)}");
//Bittrex.API.Data.TradeMyOrder[] orders = await _market.SetOrdersAsync(stock.ToArray());
//_logger.Trace($"Response: {Newtonsoft.Json.JsonConvert.SerializeObject(orders)}");
//return new BittrexCreateOrderResult(orders != null && orders.Length > 0 && orders[0].Id > 0);
}
public async Task <ICreateOrderResult> CreateOrderAsync(IOrderRequest request, System.Threading.CancellationToken cancellationToken)
{
List <PROFITBEST.API.Data.TradeBaseOrder> stock = new List <PROFITBEST.API.Data.TradeBaseOrder>();
stock.Add(new PROFITBEST.API.Data.TradeBaseOrder
{
Pair = request.Pair.Name,
Amount = request.Amount.ToString("0.00000000", System.Globalization.CultureInfo.InvariantCulture),
Price = request.Rate.ToString("0.00000000", System.Globalization.CultureInfo.InvariantCulture),
Type = request.RequestType == OrderType.buy ? PROFITBEST.API.Data.TradeOrderType.buy : PROFITBEST.API.Data.TradeOrderType.sell
});
_logger.Trace($"Request: {Newtonsoft.Json.JsonConvert.SerializeObject(stock)}");
PROFITBEST.API.Data.TradeMyOrder[] orders = await _market.SetOrdersAsync(stock.ToArray());
_logger.Trace($"Response: {Newtonsoft.Json.JsonConvert.SerializeObject(orders)}");
return(new ProfitBestCreateOrderResult(orders != null && orders.Length > 0 && orders[0].Id > 0));
}
public static IQueryable <TEntity> SortQuery <TEntity>(IOrderRequest request, IQueryable <TEntity> query, IEntityTypeMetadata entityTypeMetadata)
where TEntity : class
{
var ordered = false;
if (request.Order != null)
{
foreach (var order in request.Order)
{
query = query.Order(order.PropertyName, order.IsDescending, ordered);
ordered = true;
}
}
if (!ordered)
{
query = query.Order(entityTypeMetadata.GetPrimaryKey().Name, true, ordered);
}
return(query);
}
public static IQueryable <TEntity> SortQuery <TEntity>(IOrderRequest request, IQueryable <TEntity> query)
where TEntity : class
{
var ordered = false;
if (request.Order != null)
{
foreach (var order in request.Order)
{
query = query.Order(order.PropertyName, order.IsDescending, ordered);
ordered = true;
}
}
if (!ordered)
{
query = query.Order("Id", true, ordered);
}
return(query);
}
public string CreateMessageToCooks(IOrderRequest orderRequest)
{
var orderCode = orderRequest.GetTerminalCode();
if (string.IsNullOrEmpty(orderCode) || orderCode.Equals(NullCode))
{
return(string.Empty);
}
if (IsMenu(orderCode))
{
return(_codeTransformDictionary[orderCode]);
}
else
{
var parser = new OrderParser();
var detailedOrder = parser.GetDetailedOrder(orderCode);
return(detailedOrder.Display());
}
}
public OrderRequestController(IPermissionService permissionService, IOrderRequest orderRequestService, IUserContext userContext)
: base(userContext, permissionService)
{
this.orderRequestService = orderRequestService;
}
/// <summary>
/// Replace an order by simultaneously cancelling it and replacing it with the given order request
/// </summary>
/// <param name="account">the account to post on</param>
/// <param name="orderId">the order to cancel</param>
/// <param name="request">the replacement order request to post</param>
/// <returns>PostOrderResponse with details of the results (throws if if fails)</returns>
public static async Task <OrderCancelReplaceResponse> CancelReplaceOrderAsync(string account, long orderId, IOrderRequest request)
{
string requestString = Server(EServer.Account) + "accounts/" + account + "/orders/" + orderId;
Dictionary <string, IOrderRequest> order = new Dictionary <string, IOrderRequest>();
order.Add("order", request);
string body = ConvertToJSON(order);
var response = await MakeRequestWithJSONBody <OrderCancelReplaceResponse, OrderCancelReplaceErrorResponse>("PUT", body, requestString);
return(response);
}
public async Task <ICreateOrderResult> CreateOrderAsync(IOrderRequest request, System.Threading.CancellationToken cancellationToken)
{
YOBIT.API.Data.Market.Response <YOBIT.API.Data.Market.Order> order = await _trade.CreateOrderAsync(await _getNonceAsync(), request.RequestType.ToString(), request.Pair.Name, request.Rate, request.Amount, cancellationToken);
return(new YobitCreateOrderResult(order.Success > 0));
}
public TenderingTypeController(IPermissionService permissionService, IUserContext userContext, IPurchaseOrderService poService, IOrderRequest orService)
: base(userContext, permissionService)
{
this.poService = poService;
this.orService = orService;
}
/// <summary>
/// Replace an order by simultaneously cancelling it and replacing it with the given order request
/// </summary>
/// <param name="accountID">the identifier of the account to post on</param>
/// <param name="orderSpecifier">the orderSpecifier of the order to cancel</param>
/// <param name="parameters">the parameters for the request</param>
/// <returns>PostOrderResponse with details of the results (throws if if fails)</returns>
public static async Task <OrderReplaceResponse> PutOrderReplaceAsync(string accountID, long orderSpecifier, IOrderRequest request)
{
string uri = ServerUri(EServer.Account) + "accounts/" + accountID + "/orders/" + orderSpecifier;
var order = new Dictionary <string, IOrderRequest> {
{ "order", request }
};
var body = ConvertToJSON(order);
var response = await MakeRequestWithJSONBody <OrderReplaceResponse, OrderReplaceErrorResponse>("PUT", body, uri);
return(response);
}
/// <summary>
/// Posts an order on the given account with the given parameters
/// </summary>
/// <param name="accountID">the identifier of the account to post on</param>
/// <param name="request">the order request to post</param>
/// <returns>PostOrderResponse with details of the results (throws if if fails)</returns>
public static async Task <PostOrderResponse> PostOrderAsync(string accountID, IOrderRequest request)
{
string uri = ServerUri(EServer.Account) + "accounts/" + accountID + "/orders";
var order = new Dictionary <string, IOrderRequest> {
{ "order", request }
};
var body = ConvertToJSON(order);
var response = await MakeRequestWithJSONBody <PostOrderResponse, PostOrderErrorResponse>("POST", body, uri);
return(response);
}
public LocationController(IPermissionService permissionService, IUserContext userContext, ILocationService _locationService, IOrderRequest orService)
: base(userContext, permissionService)
{
this.locationService = _locationService;
this.orService = orService;
}
