public void UpdateOrder(OrderOptions options)
{
if (options == null)
{
throw new ArgumentNullException();
}
var existingOrder = SearchOrders
(
new OrderOptions()
{
OrderId = options.OrderId
}
).SingleOrDefault();
if (existingOrder == null)
{
throw new ArgumentNullException();
}
var existingCustomer = _customerService.SearchCustomers(
new CustomerOptions()
{
CustomerId = options.CustomerId
}
).SingleOrDefault();
existingOrder.CustomerId = existingCustomer.Id;
existingOrder.DeliveryAddress = options.DeliveryAddress;
_context.SaveChanges();
}
public HttpResponseMessage VivaCreateOrder(OrderOptions options)
{
var cl = new RestClient("http://demo.vivapayments.com/");
var req = new RestRequest("api/orders", Method.POST);
options.SourceCode = "4308";
req.AddObject(options);
string vivaPaymentFormURL = "http://demo.vivapayments.com/web/newtransaction.aspx?ref=";
//string vivaPaymentFormURL = "https://www.vivapayments.com/web/newtransaction.aspx?ref="; // production URL
// class that contains the order options that will be sent
var apiKey = "4661510a-989d-47fd-84d6-a4128b9a3544";
var apiPassword = "******";
cl.Authenticator = new HttpBasicAuthenticator(apiKey, apiPassword);
// Do the post
var res = cl.Execute <OrderResult>(req);
res.Data.RedirectUrl = vivaPaymentFormURL + res.Data.OrderCode.ToString();
// once the order code is successfully created, redirect to payment form to complete the payment
if (res.Data.ErrorCode == 0)
{
return(Request.CreateResponse(HttpStatusCode.OK, res.Data));
//Response.Redirect(this.vivaPaymentFormURL + res.Data.OrderCode.ToString());
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "The Order failed"));
}
}
public IOrder makeSpecificOrder(OrderOptions requestedOrder)
{
switch (requestedOrder)
{
//case OrderOptions.BYNAME:
// {
// return new OrderByName(chooseRandomDrink());
// }
//case OrderOptions.BYFLAVOR:
// {
// return new OrderByFlavor(chooseRandomDrink().ThisDrinksFlavor);
// }
case OrderOptions.BYCOLOR:
{
return(new OrderByIngredent(chooseRandomIngredentFromKnownIngredents()));
}
case OrderOptions.BYWITHOUTCOLOR:
{
return(new OrderByLackOfIngredient());
}
default:
{
return(new OrderByName(chooseRandomDrink()));
}
}
}
public void Generate_XML_File_Missing_Directories()
{
var options = new OrderOptions();
var result = this._fileGenerator.Execute(options);
Assert.AreEqual(-1, result);
}
internal OrderExpression(Type type, Expression source, Expression orderSelector, OrderOptions options)
{
Type = type;
Source = source;
OrderSelector = orderSelector;
Options = options;
}
public void AddOrderByOption(string propertyPath, bool isAscending)
{
OrderOptions.Add(new OrderByExpression.OrderOption()
{
PropertyPath = propertyPath,
IsAscending = isAscending
});
}
public CartPlacesRepository(IOptions <OrderOptions> options, ILogger <CartPlacesRepository> logger)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_options = options.Value;
_logger = logger;
}
public PaymentMethodRepository(IOptions <OrderOptions> options, ILogger <DeliveryTypeRepository> logger)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_options = options.Value;
_logger = logger;
}
public void Generate_XML_File_Missing_Source_Directory()
{
var options = new OrderOptions {
Output = this._outputDir
};
var result = this._fileGenerator.Execute(options);
Assert.AreEqual(-1, result);
}
public void Generate_XML_File_Output_Directory_Not_Exist()
{
var options = new OrderOptions {
Output = $"{this._outputDir}wrong"
};
var result = this._fileGenerator.Execute(options);
Assert.AreEqual(-1, result);
}
public void Generate_XML_File_Missing_CSV_Files()
{
var options = new OrderOptions {
Source = this._sourceDir, Output = this._outputDir
};
var result = this._fileGenerator.Execute(options);
Assert.AreEqual(-1, result);
}
/// <summary>
/// 扩展方法：获取枚举中最后一个值
/// </summary>
/// <param name="pCaller">调用者</param>
/// <param name="pOrderOption">排序的方式</param>
/// <returns></returns>
public static Enum GetLast(this Enum pCaller, OrderOptions pOrderOption)
{
var values = pCaller.GetValues();
if (pOrderOption == OrderOptions.ByValue)
{
values = values.OrderBy(item => item);
}
return(values.Last());
}
public void Generate_XML_File_Success()
{
File.Copy(Path.Combine(Directory.GetCurrentDirectory(), "Data", _testFileName), Path.Combine(this._sourceDir, _testFileName));
var options = new OrderOptions {
Source = this._sourceDir, Output = this._outputDir
};
var result = this._fileGenerator.Execute(options);
Assert.AreEqual(0, result);
Assert.IsTrue(File.Exists(Path.Combine(this._outputDir, "Orders.xml")));
}
public ISqlExpressionBuilder Order(string column, OrderOptions options, ExpressionOptions expOptions)
{
ColumnExpression col = _CreateColumnByName(column);
if (expOptions == ExpressionOptions.Overwrite)
{
_stmtOrder.Columns.Clear();
}
_stmtOrder.Columns.Add(col, options);
return(this);
}
public void DefaultClick()
{
Finder.Explore(new ExploreOptions(QueryName)
{
OrderOptions = OrderOptions.ToList(),
FilterOptions = FilterOptions.ToList(),
ColumnOptions = ColumnOptions.ToList(),
ColumnOptionsMode = ColumnOptionsMode,
SearchOnLoad = true,
});
}
async Task <VivaResponse> IDataClient.VivaCreateOrder(OrderOptions model)
{
var response = await ApiClient.PostJsonEncodedContent(vivaUri, model);
var orderResponse = await CreateJsonResponse <VivaResponse>(response);
var orderResult = await DecodeContent <OrderResult>(response);
orderResponse.Data = orderResult;
return(orderResponse);
}
public void ClearResults()
{
ResultTable = null;
gvResults.Columns.Clear();
lvResult.ItemsSource = null;
lvResult.Background = Brushes.WhiteSmoke;
lastRequest = null;
var keys = Request.Columns.Select(a => a.Token?.Token).Where(a => a != null && !(a is AggregateToken)).Select(a => a.FullKey()).ToHashSet();
OrderOptions.RemoveAll(a => !(a.Token is AggregateToken) && !keys.Contains(a.Token.FullKey()));
}
public QueryRequest ToQueryRequest()
{
var qd = DynamicQueryManager.Current.QueryDescription(QueryName);
return(new QueryRequest
{
QueryName = QueryName,
Filters = FilterOptions.Select(fo => fo.ToFilter()).ToList(),
Orders = OrderOptions.Select(fo => fo.ToOrder()).ToList(),
Columns = ColumnOptions.Select(co => co.ToColumn(qd)).ToList(),
Pagination = pagination ?? FindOptions.DefaultPagination,
});
}
public ISqlExpressionBuilder Order(ColumnExpression column, OrderOptions options, ExpressionOptions expOptions)
{
if (!_IsTablePresent(column.Table))
{
throw new Exception("The table of the order column doesn't exist in this context.");
}
if (expOptions == ExpressionOptions.Overwrite)
{
_stmtOrder.Columns.Clear();
}
_stmtOrder.Columns.Add(column, options);
return(this);
}
/// <summary>
/// 扩展方法：获取下一个枚举
/// </summary>
/// <param name="pCaller">调用者</param>
/// <param name="pOrderOption">排序的方式</param>
/// <param name="pIsCyclely">是否循环获取</param>
/// <returns></returns>
public static Enum GetNext(this Enum pCaller, OrderOptions pOrderOption, bool pIsCyclely)
{
Enum[] values = pCaller.GetValues().ToArray();
if (pOrderOption == OrderOptions.ByValue)
{
values = values.OrderBy(item => item).ToArray();
}
var next = values.SkipWhile(item => Convert.ToInt32(item) != Convert.ToInt32(pCaller)).Skip(1).FirstOrDefault();
if (next == null && pIsCyclely)
{
next = values.First();
}
return(next);
}
public Order CreateOrder(OrderOptions options)
{
if (options == null)
{
return(null);
}
var order = new Order()
{
DeliveryAddress = options.DeliveryAddress,
Created = DateTime.Now
};
foreach (var productid in options.ProductIds)
{
var product = _productService.SearchById(productid);
if (product != null)
{
order.OrderProducts.Add(new OrderProduct()
{
Product = product,
ProductId = product.ProductId
});
order.TotalAmmount += product.Price;
}
}
var findCustomer = _customerService.SearchCustomerById(options.CustomerId);
if (findCustomer == null)
{
return(null);
}
findCustomer.Orders.Add(order);
_context.Add(order);
if (_context.SaveChanges() > 0)
{
return(order);
}
return(null);
}
public IQueryable <Order> SearchOrders(OrderOptions options)
{
if (options == null)
{
return(null);
}
var query = _context
.Set <Order>()
.Where(o => o.CustomerId == options.CustomerId)
.Include(s => s.OrderProducts)
.AsQueryable();
query = query.Take(500);
return(query);
}
public QueryRequest GetQueryRequest(bool updateSimpleFilters)
{
if (updateSimpleFilters)
{
RefreshSimpleFilters();
}
var request = new QueryRequest
{
QueryName = QueryName,
Filters = FilterOptions.Select(f => f.ToFilter()).ToList(),
Orders = OrderOptions.Select(o => o.ToOrder()).ToList(),
Columns = gvResults.Columns.Select(gvc => ((SortGridViewColumnHeader)gvc.Header).RequestColumn).ToList(),
Pagination = Pagination,
};
return(request);
}
public void can_create_session_query_for_select_all_over_object()
{
session.CreateQueryFor <Account>()
.Select(SelectionOptions.FieldFrom <AccountTransaction>(t => t.Description),
SelectionOptions.AvgOnFieldFrom <Account>(a => a.AccountNumber, "avg_accounts"))
.LeftJoinOn <AccountTransaction>(t => t.Account.Id, a => a.Id)
.CreateCriteria(Restrictions.CreateDisjunctionOn(
Restrictions.EqualTo <Account>(a => a.Id, 1),
Restrictions.GreaterThan <Account>(a => a.AccountNumber, "12344")),
Restrictions.Like <Account>(a => a.Description, "completed"))
.AddOrder(OrderOptions.Asc <Account>(a => a.Id))
.GroupBy(GroupByOptions.AliasField <Account>("avg_accounts"),
GroupByOptions.FieldFrom <AccountTransaction>(t => t.Description))
.SingleOrDefault();
}
public void Reinitialize(IEnumerable <FilterOption> filters, List <ColumnOption> columns, ColumnOptionsMode columnOptionsMode, List <OrderOption> orders)
{
if (qd == null)
{
qd = DynamicQueryServer.GetQueryDescription(QueryName);
}
ColumnOptions.Clear();
ColumnOptions.AddRange(columns);
ColumnOptionsMode = columnOptionsMode;
FilterOptions.Clear();
FilterOptions.AddRange(filters);
FilterOption.SetFilterTokens(FilterOptions, qd);
OrderOptions.Clear();
OrderOptions.AddRange(orders);
OrderOption.SetOrderTokens(OrderOptions, qd);
}
public override string ToString()
{
if (FilterOptions.Any())
{
QueryDescription queryDescription = DynamicQueryManager.Current.QueryDescription(QueryName);
FilterOption.SetFilterTokens(FilterOptions, queryDescription, canAggregate: false);
}
var elements = Pagination != null?Pagination.GetElementsPerPage() : null;
string options = new Sequence <string>
{
Pagination != null ? "pagination=" + pagination.GetMode().ToString() : null,
elements != null ? "elems=" + elements : null,
SearchOnLoad ? "searchOnLoad=true" : null,
!Create ? "create=false": null,
!Navigate ? "navigate=false": null,
!AllowSelection ? "allowSelection=false" : null,
!AllowChangeColumns ? "allowChangeColumns=false" : null,
!AllowOrder ? "allowOrder=false" : null,
!showHeader ? "showHeader=false" : null,
!showFilters ? "showFilters=false" : null,
!showFilterButton ? "showFilterButton=false" : null,
!showFooter ? "showFooter=false" : null,
!showContextMenu ? "showContextMenu=false" : null,
(FilterOptions != null && FilterOptions.Count > 0) ? ("filters=" + FilterOptions.ToString(";")) : null,
(OrderOptions != null && OrderOptions.Count > 0) ? ("orders=" + OrderOptions.ToString(";")) : null,
(ColumnOptions != null && ColumnOptions.Count > 0) ? ("columns=" + ColumnOptions.ToString(";")) : null,
(ColumnOptionsMode != ColumnOptionsMode.Add ? ("columnMode=" + ColumnOptionsMode.ToString()) : null),
!SelectedItemsContextMenu ? "selectedItemsContextMenu=false" : null
}.NotNull().ToString("&");
if (options.HasText())
{
return(Finder.FindRoute(QueryName) + "?" + options);
}
else
{
return(Finder.FindRoute(QueryName));
}
}
private Task <QueryResult <TItem> > InternalDataSource(QueryOptions <TItem> queryOptions)
{
var result = new QueryResult <TItem>();
var orderOption = OrderOptions.FirstOrDefault(x => x.Id == queryOptions.Order);
Func <IEnumerable <TItem>, IOrderedEnumerable <TItem> > orderFunction = null;
if (orderOption != null)
{
if (orderOption is OrderOption <TItem> genericOrderOption)
{
orderFunction = genericOrderOption.OrderFunction;
}
}
IEnumerable <TItem> orderedData;
if (orderFunction != null)
{
orderedData = orderFunction.Invoke(FixedData);
}
else
{
orderedData = FixedData;
}
if (IsPageable)
{
var pagedData = orderedData.Skip((queryOptions.PageNumber - 1) * queryOptions.PageSize).Take(queryOptions.PageSize + 1).ToArray();
result.ResultData = pagedData.Take(queryOptions.PageSize).ToArray();
result.HasMoreData = pagedData.Length == queryOptions.PageSize + 1;
}
else
{
result.ResultData = orderedData.ToArray();
result.HasMoreData = false;
}
return(Task.FromResult(result));
}
private IEnumerable <ProductDto> GetData(PagingOptions pagingOptions, OrderOptions orderOptions)
{
var data = GetData();
if (pagingOptions.Skip.HasValue)
{
data = data.Skip(pagingOptions.Skip.Value);
}
if (pagingOptions.Take.HasValue)
{
data = data.Take(pagingOptions.Take.Value);
}
if (orderOptions != null && orderOptions.Fields != null && orderOptions.Fields.Count() > 0)
{
string orderExpr = orderOptions.Fields.Select(f => string.Format("{0} {1}", f.FieldName, f.Ascending ? "ASC" : "DESC")).Aggregate((f1, f2) => string.Format("{0},{1}", f1, f2));
data = data.OrderBy(orderExpr);
}
return(data);
}
public void Reinitialize(List <FilterOption> filters, List <ColumnOption> columns, ColumnOptionsMode columnOptionsMode, List <OrderOption> orders, Pagination pagination)
{
try
{
avoidPaginationChange = true;
ColumnOptions.Clear();
ColumnOptions.AddRange(columns);
ColumnOption.SetColumnTokens(ColumnOptions, Description);
ColumnOptionsMode = columnOptionsMode;
GenerateListViewColumns();
if (!filters.SequenceEqual(FilterOptions))
{
if (SimpleFilterBuilder != null)
{
SimpleFilterBuilder = null;
}
FilterOptions.Clear();
FilterOption.SetFilterTokens(filters, Description);
FilterOptions.AddRange(filters);
}
OrderOptions.Clear();
OrderOptions.AddRange(orders);
OrderOption.SetOrderTokens(OrderOptions, Description);
SortGridViewColumnHeader.SetColumnAdorners(gvResults, OrderOptions);
UpdateMultiplyMessage(true);
Pagination = pagination;
}
finally
{
avoidPaginationChange = false;
}
}
internal void UpdateFiltersOrdersUserInterface()
{
FilterOptions.Clear();
if (Request.Filters != null)
{
FilterOptions.AddRange(Request.Filters.Select(f => new FilterOption
{
Token = f.Token,
Operation = f.Operation,
Value = f.Value
}));
}
OrderOptions.Clear();
if (Request.Orders != null)
{
OrderOptions.AddRange(Request.Orders.Select(o => new OrderOption
{
Token = o.Token,
OrderType = o.OrderType,
}));
}
}
public IEnumerable<byte[]> Find(string nameSpace, string objectName, string constraint, uint limit, OrderOptions order)
{
_ValidateArguments(nameSpace, objectName);
var objectFullName = ObjectNaming.CreateFullObjectName(nameSpace, objectName);
var metadata = _objectMetadata.GetMetadata(objectFullName);
if (null == metadata)
{
throw new InvalidOperationException("Metadata not found for object: " + objectFullName);
}
var objectIds = _objectIndexer.Find(objectFullName, constraint, limit, order, metadata.Indexes);
foreach (var objectId in objectIds)
{
yield return _objectStore.Get(objectFullName, objectId);
}
}
public byte[][] Find(string constraint, uint limit, OrderOptions order)
{
return _service.Find(_nameSpace, _objectName, constraint, limit, order).ToArray();
}
public override int[] Find(string objectFullName, string constraint, uint limit, OrderOptions order, ObjectIndexMetadata[] indexes)
{
using (var db = OpenData())
{
var tableName = _CreateTableName(db, objectFullName);
var compiledConstraint = CreateSQLConstraint(db, indexes, constraint);
var sqlConstraint = compiledConstraint.SQL;
if (!string.IsNullOrEmpty(sqlConstraint))
{
sqlConstraint = "WHERE " + sqlConstraint;
}
var orderBySql = _CreateOrderBySQL(db, order);
var limitSql = (0 == limit) ? SQLStatements.NoLimit : string.Format(SQLStatements.Limit, limit);
return db.GetValues<int>(string.Format(SQLStatements.Find, tableName, sqlConstraint, orderBySql, limitSql), compiledConstraint.Parameters.ToArray());
}
}
public int[] Find(string objectFullName, string constraint, uint limit, OrderOptions order, ObjectIndexMetadata[] indexes)
{
int[] returnValue = null;
if (null != _cache)
{
var parameters = new object[5 + ((null == indexes) ? 0 : indexes.Length)];
parameters[0] = objectFullName;
parameters[1] = constraint;
parameters[2] = limit;
parameters[3] = order;
parameters[4] = "F";
if (null != indexes)
{
for (int i = 0; indexes.Length > i; i++)
{
parameters[i + 5] = indexes[i];
}
}
returnValue = _cache.Get(parameters);
if (null == returnValue)
{
_ValidateOrderOptions(indexes, order);
returnValue = _indexer.Find(objectFullName, constraint, limit, order, indexes);
_cache.Set(returnValue, parameters);
}
}
else
{
returnValue = _indexer.Find(objectFullName, constraint, limit, order, indexes);
}
return returnValue;
}
public IEnumerable<IDataRecord> Iterate(string objectFullName, string constraint, uint limit, OrderOptions order, string[] iterateIndexes, ObjectIndexMetadata[] indexes)
{
_ValidateOrderOptions(indexes, order);
if (null != iterateIndexes && 0 == iterateIndexes.Length)
{
_ValidateIndexNames(indexes, iterateIndexes);
}
return _indexer.Iterate(objectFullName, constraint, limit, order, iterateIndexes, indexes);
}
private void _ValidateOrderOptions(ObjectIndexMetadata[] indexes, OrderOptions order)
{
if (null != order && null != order.Indexes)
{
if (!_ValidateIndexNames(indexes, order.Indexes))
{
throw new ArgumentException("Invalid index name supplied in OrderOptions.");
}
}
}
public override IEnumerable<IDataRecord> Iterate(string objectFullName, string constraint, uint limit, OrderOptions order, string[] iterateIndexes, ObjectIndexMetadata[] indexes)
{
using (var db = OpenData())
{
var tableName = _CreateTableName(db, objectFullName);
var whereSql = string.Empty;
IDataParameter[] parameters = null;
if (!string.IsNullOrEmpty(constraint))
{
var sqlConstraint = CreateSQLConstraint(db, indexes, constraint);
whereSql = " WHERE " + sqlConstraint.SQL;
parameters = sqlConstraint.Parameters.ToArray();
}
var orderBySql = _CreateOrderBySQL(db, order);
var limitSql = (0 == limit) ? SQLStatements.NoLimit : string.Format(SQLStatements.Limit, limit);
string[] selectNames = null;
// if no iterate indexes are specified, then iterate overall index names from the metadata
if (null == iterateIndexes || 0 == iterateIndexes.Length)
{
if (null == indexes || 0 == indexes.Length)
{
// If not iterate indexes or metadataColumns provided, then only select the ID column
selectNames = new string[] { db.MakeQuotedName(IDColumn) };
}
else
{
selectNames = new string[indexes.Length + 1];
selectNames[0] = db.MakeQuotedName(IDColumn);
for (int i = 0; indexes.Length > i; i++)
{
selectNames[i + 1] = db.MakeQuotedName(indexes[i].Name);
}
}
}
else
{
selectNames = new string[iterateIndexes.Length];
for (int i = 0; iterateIndexes.Length > i; i++)
{
selectNames[i] = db.MakeQuotedName(iterateIndexes[i]);
}
}
string selectNamesSql = string.Join(",", selectNames);
using (var reader = db.ExecuteReader(string.Format(SQLStatements.Iterate, tableName, selectNamesSql, whereSql, orderBySql, limitSql), parameters))
{
while (reader.Read())
{
yield return reader;
}
}
}
}
private static string _CreateOrderBySQL(IDatabaseService db, OrderOptions order)
{
var orderBySql = SQLStatements.NoOrder;
if (null != order)
{
string orderColSql = string.Join(",", order.Indexes.Select(i => db.MakeQuotedName(i)).ToArray());
if (order.Descending)
{
orderBySql = string.Format(SQLStatements.OrderDesc, orderColSql);
}
else
{
orderBySql = string.Format(SQLStatements.OrderAsc, orderColSql);
}
}
return orderBySql;
}
