private async Task <OrderResponseItem[]> HandleErrorUnexpectedAsync(OrderCriteria orderCriteria, [CallerMemberName] string callerMemberName = "")
{
var result = new List <OrderResponseItem>();
var prevPageSize = orderCriteria.PageSize;
var prevPageNumber = orderCriteria.PageNumberFilter;
var pageNumberBy1 = prevPageSize * (prevPageNumber - 1);
for (var i = 1; i <= prevPageSize; i++)
{
orderCriteria.PageSize = 1;
orderCriteria.PageNumberFilter = pageNumberBy1 + i;
var numberAttempt = 0;
while (numberAttempt < MaxUnexpectedAttempt)
{
var answer = await this._client.GetOrderListAsync(this._credentials, this.AccountId, orderCriteria).ConfigureAwait(false);
if (answer.GetOrderListResult.Status == ResultStatus.Success)
{
result.AddRange(answer.GetOrderListResult.ResultData);
break;
}
numberAttempt++;
this.LogUnexpectedError(orderCriteria, answer.GetOrderListResult, orderCriteria.PageNumberFilter, callerMemberName, numberAttempt);
await this.DoDelayUnexpectedAsync(new TimeSpan( 0, 2, 0 ), numberAttempt).ConfigureAwait(false);
}
}
orderCriteria.PageSize = prevPageSize;
orderCriteria.PageNumberFilter = prevPageNumber;
return(result.ToArray());
}
/// <summary>
/// Gets the orders.
/// </summary>
/// <typeparam name="T">Type of order response.</typeparam>
/// <param name="orderCriteria">The order criteria.</param>
/// <returns>Orders matching supplied criteria.</returns>
public IEnumerable <T> GetOrders <T>(OrderCriteria orderCriteria)
where T : OrderResponseItem
{
if (string.IsNullOrEmpty(orderCriteria.DetailLevel))
{
orderCriteria.DetailLevel = "High";
}
int pageSize;
orderCriteria.PageSize = this._pageSizes.TryGetValue(orderCriteria.DetailLevel, out pageSize) ? pageSize : 20;
orderCriteria.PageNumberFilter = 1;
var orders = new List <T>();
while (true)
{
var ordersFromPage = this.GetOrdersPage(orderCriteria);
if (ordersFromPage == null || ordersFromPage.Length == 0)
{
break;
}
orders.AddRange(ordersFromPage.OfType <T>());
orderCriteria.PageNumberFilter += 1;
}
this.CheckFulfillmentStatus(orders);
return(orders);
}
private void DataPortal_Fetch(OrderCriteria criteria)
{
bool cancel = false;
OnFetching(criteria, ref cancel);
if (cancel) return;
string commandText = String.Format("SELECT [OrderId], [UserId], [OrderDate], [ShipAddr1], [ShipAddr2], [ShipCity], [ShipState], [ShipZip], [ShipCountry], [BillAddr1], [BillAddr2], [BillCity], [BillState], [BillZip], [BillCountry], [Courier], [TotalPrice], [BillToFirstName], [BillToLastName], [ShipToFirstName], [ShipToLastName], [AuthorizationNumber], [Locale] FROM [dbo].[Orders] {0}", ADOHelper.BuildWhereStatement(criteria.StateBag));
using (var connection = new SqlConnection(ADOHelper.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand(commandText, connection))
{
command.Parameters.AddRange(ADOHelper.SqlParameters(criteria.StateBag));
using(var reader = new SafeDataReader(command.ExecuteReader()))
{
if (reader.Read())
Map(reader);
else
throw new Exception(String.Format("The record was not found in 'dbo.Orders' using the following criteria: {0}.", criteria));
}
}
}
OnFetched();
}
///<summary>
/// Based on the class definition and the orderByString an <see cref="OrderCriteria"/> object is created.
/// The orderCriteria object is a set of order by fields including information on their
/// business object properties and their dataSource.
///</summary>
///<param name="classDef">The class definition to use for building the order criteria</param>
///<param name="orderByString">The orderby string to use for creating the <see cref="OrderCriteria"/>.</param>
///<returns>the newly created <see cref="OrderCriteria"/> object.</returns>
public static IOrderCriteria CreateOrderCriteria(IClassDef classDef, string orderByString)
{
if (classDef == null)
{
throw new ArgumentNullException("classDef");
}
IOrderCriteria orderCriteria = OrderCriteria.FromString(orderByString);
try
{
//TODO Mark 20 Mar 2009: Souldn't the following code be stripped out into a PrepareOrderBy method that is called before loading? (Similar to PrepareCriteria)
foreach (OrderCriteriaField field in orderCriteria.Fields)
{
Source source = field.Source;
IClassDef relatedClassDef;
IClassDef classDefOfField = classDef;
if (classDef.IsUsingClassTableInheritance())
{
classDefOfField = classDef.GetPropDef(field.PropertyName).ClassDef;
}
PrepareSource(classDefOfField, ref source, out relatedClassDef);
field.Source = source;
IPropDef propDef = relatedClassDef.GetPropDef(field.PropertyName);
field.FieldName = propDef.DatabaseFieldName;
field.Source.ChildSourceLeaf.EntityName = relatedClassDef.GetTableName(propDef);
}
return(orderCriteria);
}
catch (InvalidPropertyNameException)
{
throw new InvalidOrderCriteriaException("The orderByString '" + orderByString
+ "' is not valid for the classDef '" + classDef.ClassNameFull);
}
}
private void DataPortal_Fetch(OrderCriteria criteria)
{
bool cancel = false;
OnFetching(criteria, ref cancel);
if (cancel) return;
RaiseListChangedEvents = false;
// Fetch Child objects.
string commandText = String.Format("SELECT [OrderId], [UserId], [OrderDate], [ShipAddr1], [ShipAddr2], [ShipCity], [ShipState], [ShipZip], [ShipCountry], [BillAddr1], [BillAddr2], [BillCity], [BillState], [BillZip], [BillCountry], [Courier], [TotalPrice], [BillToFirstName], [BillToLastName], [ShipToFirstName], [ShipToLastName], [AuthorizationNumber], [Locale] FROM [dbo].[Orders] {0}", ADOHelper.BuildWhereStatement(criteria.StateBag));
using (var connection = new SqlConnection(ADOHelper.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand(commandText, connection))
{
command.Parameters.AddRange(ADOHelper.SqlParameters(criteria.StateBag));
using(var reader = new SafeDataReader(command.ExecuteReader()))
{
if(reader.Read())
{
do
{
this.Add(PetShop.Tests.ParameterizedSQL.Order.GetOrder(reader));
} while(reader.Read());
}
}
}
}
RaiseListChangedEvents = true;
OnFetched();
}
public void Sort_TwoFieldsAscending()
{
//---------------Set up test pack-------------------
var resultSet = new QueryResult();
resultSet.AddField("Name");
resultSet.AddField("Age");
resultSet.AddResult(new object[] { "Bob", 21 });
resultSet.AddResult(new object[] { "Bob", 19 });
resultSet.AddResult(new object[] { "Peter", 40 });
resultSet.AddResult(new object[] { "Peter", 30 });
var orderCriteria = OrderCriteria.FromString("Name, Age");
var sorter = new QueryResultSorter();
//---------------Execute Test ----------------------
sorter.Sort(resultSet, orderCriteria);
//---------------Test Result -----------------------
var rows = resultSet.Rows.ToList();
Assert.AreEqual("Bob", rows[0].Values[0]);
Assert.AreEqual(19, rows[0].Values[1]);
Assert.AreEqual("Bob", rows[1].Values[0]);
Assert.AreEqual(21, rows[1].Values[1]);
Assert.AreEqual("Peter", rows[2].Values[0]);
Assert.AreEqual(30, rows[2].Values[1]);
Assert.AreEqual("Peter", rows[3].Values[0]);
Assert.AreEqual(40, rows[3].Values[1]);
}
protected void btnSearch_Click(object sender, EventArgs e)
{
OrderCriteria criteria = ComposeCriteria();
PerformSearch(criteria);
LoadSearchResult();
}
private void DataPortal_Fetch(OrderCriteria criteria)
{
bool cancel = false;
OnFetching(criteria, ref cancel);
if (cancel) return;
using (var connection = new SqlConnection(ADOHelper.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand("[dbo].[CSLA_Order_Select]", connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddRange(ADOHelper.SqlParameters(criteria.StateBag));
command.Parameters.AddWithValue("@p_ShipAddr2HasValue", criteria.ShipAddr2HasValue);
command.Parameters.AddWithValue("@p_BillAddr2HasValue", criteria.BillAddr2HasValue);
using(var reader = new SafeDataReader(command.ExecuteReader()))
{
if(reader.Read())
Map(reader);
else
throw new Exception(String.Format("The record was not found in 'dbo.Orders' using the following criteria: {0}.", criteria));
}
}
}
OnFetched();
}
public async Task <IEnumerable <Document> > GetDocumentsAsync(OrderCriteria criteria)
{
var userId = this.userProvider.User.Id;
var documents = await this.documentRepository.GetDocumentsAsync(userId, criteria);
return(documents);
}
/// <summary>
/// Fetch OrderList.
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
public OrderList Fetch(OrderCriteria criteria)
{
OrderList item = (OrderList)Activator.CreateInstance(typeof(OrderList), true);
bool cancel = false;
OnFetching(criteria, ref cancel);
if (cancel) return item;
// Fetch Child objects.
string commandText = String.Format("SELECT [OrderId], [UserId], [OrderDate], [ShipAddr1], [ShipAddr2], [ShipCity], [ShipState], [ShipZip], [ShipCountry], [BillAddr1], [BillAddr2], [BillCity], [BillState], [BillZip], [BillCountry], [Courier], [TotalPrice], [BillToFirstName], [BillToLastName], [ShipToFirstName], [ShipToLastName], [AuthorizationNumber], [Locale] FROM [dbo].[Orders] {0}", ADOHelper.BuildWhereStatement(criteria.StateBag));
using (var connection = new SqlConnection(ADOHelper.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand(commandText, connection))
{
command.Parameters.AddRange(ADOHelper.SqlParameters(criteria.StateBag));
using(var reader = new SafeDataReader(command.ExecuteReader()))
{
if (reader.Read())
{
do
{
item.Add(new OrderFactory().Map(reader));
} while(reader.Read());
}
}
}
}
MarkOld(item);
MarkAsChild(item);
OnFetched();
return item;
}
private void DataPortal_Fetch(OrderCriteria criteria)
{
bool cancel = false;
OnFetching(criteria, ref cancel);
if (cancel) return;
RaiseListChangedEvents = false;
// Fetch Child objects.
using (var connection = new SqlConnection(ADOHelper.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand("[dbo].[CSLA_Order_Select]", connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddRange(ADOHelper.SqlParameters(criteria.StateBag));
command.Parameters.AddWithValue("@p_ShipAddr2HasValue", criteria.ShipAddr2HasValue);
command.Parameters.AddWithValue("@p_BillAddr2HasValue", criteria.BillAddr2HasValue);
using(var reader = new SafeDataReader(command.ExecuteReader()))
{
if(reader.Read())
{
do
{
this.Add(PetShop.Tests.StoredProcedures.Order.GetOrder(reader));
} while(reader.Read());
}
}
}
}
RaiseListChangedEvents = true;
OnFetched();
}
public IEnumerable <OrderBriefInfoData> GetOrdersInProcess(OrderCriteria criteria)
{
IEnumerable <OrderBriefInfoData> result = null;
RepositoryExceptionWrapper.Wrap(GetType(), () =>
{
IQuery query = CurrentSession.GetNamedQuery("GetOrdersInProcess");
if (criteria.SupplierId != null)
{
query.SetParameter("SupplierId", criteria.SupplierId);
}
else
{
query.SetString("SupplierId", null);
}
if (criteria.CustomerId != null)
{
query.SetParameter("CustomerId", criteria.CustomerId);
}
else
{
query.SetString("CustomerId", null);
}
result = query.List <OrderBriefInfoData>();
});
return(result);
}
/// <summary>
/// This call to delete is for immediate deletion and doesn't keep track of any entity state.
/// </summary>
/// <param name="criteria">The Criteria.</param>
private void DoDelete(OrderCriteria criteria)
{
bool cancel = false;
OnDeleting(criteria, ref cancel);
if (cancel)
{
return;
}
using (var connection = new SqlConnection(ADOHelper.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand("[dbo].[CSLA_Order_Delete]", connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddRange(ADOHelper.SqlParameters(criteria.StateBag));
//result: The number of rows changed, inserted, or deleted. -1 for select statements; 0 if no rows were affected, or the statement failed.
int result = command.ExecuteNonQuery();
if (result == 0)
{
throw new DBConcurrencyException("The entity is out of date on the client. Please update the entity and try again. This could also be thrown if the sql statement failed to execute.");
}
}
}
OnDeleted();
}
private void PerformSearch(OrderCriteria criteria)
{
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey))
{
OrderFacade facade = new OrderFacade(uow);
Orders = facade.SearchOrders(criteria, new OrderBriefInfoConverter());
}
}
private void LogUnexpectedError(OrderCriteria orderCriteria, APIResultOfArrayOfOrderResponseItem orderList, int?pageNumberBy1, string callerMemberName, int attempt)
{
var additionalLogInfo = ExtensionsInternal.CreateMethodCallInfo(this.AdditionalLogInfo, callerMemberName)();
var criteria = string.Format("StatusUpdateFilterBeginTimeGMTField: {0}. StatusUpdateFilterEndTimeGMTField: {1}. Number in sequence for pageSize equal 1 : {2}", orderCriteria.StatusUpdateFilterBeginTimeGMT.GetValueOrDefault(), orderCriteria.StatusUpdateFilterEndTimeGMT.GetValueOrDefault(), pageNumberBy1);
var message = "Unexpected Error. Attempt: {0}. Additional info: {1} {2}".FormatWith(attempt, additionalLogInfo, criteria);
var exception = new ChannelAdvisorException(orderList.MessageCode, message);
ChannelAdvisorLogger.LogTraceException(exception);
}
/// <summary>
/// Constructor to create a new single relationship definition
/// </summary>
/// <param name="relationshipName">A name for the relationship</param>
/// <param name="relatedObjectAssemblyName">The assembly name of the related object</param>
/// <param name="relatedObjectClassName">The class name of the related object</param>
/// <param name="relKeyDef">The related key definition</param>
/// <param name="keepReferenceToRelatedObject">Whether to keep a
/// reference to the related object. Could be false for memory-
/// intensive applications.</param>
/// <param name="orderBy">The sql order-by clause</param>
/// <param name="deleteParentAction">Provides specific instructions
/// with regards to deleting a parent object. See the DeleteParentAction
/// enumeration for more detail.</param>
/// <param name="insertParentAction"></param>
/// <param name="relationshipType">Provides specific instructions for adding/removing a child object.</param>
/// <param name="timeout">The timout in milliseconds. The collection will not be automatically refreshed from the DB if the timeout has nto expired</param>
public MultipleRelationshipDef(string relationshipName, string relatedObjectAssemblyName, string relatedObjectClassName, IRelKeyDef relKeyDef, bool keepReferenceToRelatedObject, string orderBy, DeleteParentAction deleteParentAction, InsertParentAction insertParentAction, RelationshipType relationshipType, int timeout)
: base(relationshipName, relatedObjectAssemblyName, relatedObjectClassName, relKeyDef,
keepReferenceToRelatedObject, deleteParentAction, insertParentAction, relationshipType)
{
ArgumentValidationHelper.CheckArgumentNotNull(orderBy, "orderBy");
TimeOut = timeout;
OrderCriteriaString = orderBy;
OrderCriteria = new OrderCriteria();
OrderCriteria = Base.OrderCriteria.FromString(orderBy);
}
public async Task <IEnumerable <T> > GetOrdersAsync <T>(DateTime startDate, DateTime endDate)
where T : OrderResponseItem
{
var orderCriteria = new OrderCriteria
{
StatusUpdateFilterBeginTimeGMT = startDate,
StatusUpdateFilterEndTimeGMT = endDate
};
return(await this.GetOrdersAsync <T>(orderCriteria).ConfigureAwait(false));
}
public List <TDto> SearchOrders <TDto>(OrderCriteria criteria, IDataConverter <OrderBriefInfoData, TDto> converter)
where TDto : class
{
List <TDto> instances = OrderSystem.RetrieveOrdersBySearch(criteria, converter);
if (instances == null)
{
instances = new List <TDto>();
}
return(instances);
}
public IEnumerable <T> GetOrders <T>(DateTime startDate, DateTime endDate)
where T : OrderResponseItem
{
var orderCriteria = new OrderCriteria
{
StatusUpdateFilterBeginTimeGMT = startDate,
StatusUpdateFilterEndTimeGMT = endDate
};
return(this.GetOrders <T>(orderCriteria));
}
public void TestFromString_BlankString()
{
//---------------Set up test pack-------------------
//---------------Assert PreConditions---------------
//---------------Execute Test ----------------------
IOrderCriteria orderCriteria = OrderCriteria.FromString(" ");
//---------------Test Result -----------------------
Assert.IsNotNull(orderCriteria);
Assert.AreEqual(0, orderCriteria.Fields.Count);
//---------------Tear Down -------------------------
}
public async Task GetOrdersAsync()
{
var criteria = new OrderCriteria
{
StatusUpdateFilterBeginTimeGMT = DateTime.Now.AddHours( -1 ),
StatusUpdateFilterEndTimeGMT = DateTime.Now,
DetailLevel = DetailLevelTypes.Complete
};
var result = await this.OrdersService.GetOrdersAsync< OrderResponseDetailComplete >( criteria );
result.Should().NotBeEmpty();
}
public async Task <List <Document> > GetDocumentsAsync(string userId, OrderCriteria criteria)
{
var container = this.Client.GetContainer(DatabaseId, this.CollectionId);
var query = container.GetItemLinqQueryable <Document>(true)
.Where(c => c.UserId == userId)
.SortBy(criteria.Field, criteria.IsDesc);
var results = await this.ExecuteQueryAsync(query);
return(results);
}
public List <TDto> RetrieveOrdersInProcess <TDto>(IDataConverter <OrderBriefInfoData, TDto> converter)
where TDto : class
{
OrderCriteria criteria = new OrderCriteria();
List <TDto> instances = OrderSystem.RetrieveOrdersInProcess(criteria, converter);
if (instances == null)
{
instances = new List <TDto>();
}
return(instances);
}
public async Task GetOrdersAsync()
{
var criteria = new OrderCriteria
{
StatusUpdateFilterBeginTimeGMT = DateTime.Now.AddHours(-1),
StatusUpdateFilterEndTimeGMT = DateTime.Now,
DetailLevel = DetailLevelTypes.Complete
};
var result = await this.OrdersService.GetOrdersAsync <OrderResponseDetailComplete>(criteria);
result.Should().NotBeEmpty();
}
public void TestAdd_Field()
{
//---------------Set up test pack-------------------
OrderCriteriaField orderCriteriaField = new OrderCriteriaField("TestProp", SortDirection.Descending);
//---------------Execute Test ----------------------
IOrderCriteria orderCriteria = new OrderCriteria().Add(orderCriteriaField);
//---------------Test Result -----------------------
Assert.AreEqual(1, orderCriteria.Fields.Count);
Assert.Contains(orderCriteriaField, orderCriteria.Fields);
//---------------Tear Down -------------------------
}
public void TestFromString_Desc()
{
//---------------Set up test pack-------------------
//---------------Assert PreConditions---------------
//---------------Execute Test ----------------------
IOrderCriteria orderCriteria = OrderCriteria.FromString("TestProp DESC");
//---------------Test Result -----------------------
Assert.AreEqual(1, orderCriteria.Fields.Count);
Assert.AreEqual("TestProp", orderCriteria.Fields[0].PropertyName);
Assert.AreEqual(SortDirection.Descending, orderCriteria.Fields[0].SortDirection);
//---------------Tear Down -------------------------
}
public void TestFromString_SortOrder_IsCaseInsensitive()
{
//---------------Set up test pack-------------------
//---------------Execute Test ----------------------
IOrderCriteria orderCriteria = OrderCriteria.FromString("TestProp dEsc, TestProp2 aSc");
//---------------Test Result -----------------------
Assert.AreEqual(2, orderCriteria.Fields.Count);
Assert.AreEqual(SortDirection.Descending, orderCriteria.Fields[0].SortDirection);
Assert.AreEqual(SortDirection.Ascending, orderCriteria.Fields[1].SortDirection);
//---------------Tear Down -------------------------
}
public void TestAdd_Field()
{
//---------------Set up test pack-------------------
OrderCriteriaField orderCriteriaField = new OrderCriteriaField("TestProp", SortDirection.Descending);
//---------------Execute Test ----------------------
IOrderCriteria orderCriteria = new OrderCriteria().Add(orderCriteriaField);
//---------------Test Result -----------------------
Assert.AreEqual(1, orderCriteria.Fields.Count);
Assert.Contains(orderCriteriaField, orderCriteria.Fields);
//---------------Tear Down -------------------------
}
/// <summary>
/// Request order data.
/// </summary>
/// <param name="request">Order request message.</param>
/// <returns>Order response message.</returns>
public OrderResponse GetOrders(OrderRequest request)
{
OrderResponse response = new OrderResponse();
response.CorrelationId = request.RequestId;
// Validate client tag, access token, and user credentials
if (!ValidRequest(request, response, Validate.All))
{
return(response);
}
OrderCriteria criteria = request.Criteria as OrderCriteria;
if (request.LoadOptions.Contains("Order"))
{
Order order = orderDao.GetOrder(criteria.OrderId);
if (request.LoadOptions.Contains("Customer"))
{
order.Customer = customerDao.GetCustomerByOrder(order.OrderId);
}
if (request.LoadOptions.Contains("OrderDetails"))
{
order.OrderDetails = orderDao.GetOrderDetails(order.OrderId);
}
response.Order = Mapper.ToDataTransferObject(order);
}
if (request.LoadOptions.Contains("Orders"))
{
Customer customer = customerDao.GetCustomer(criteria.CustomerId);
IList <Order> orders = orderDao.GetOrders(customer.CustomerId);
if (request.LoadOptions.Contains("OrderDetails"))
{
foreach (Order order in orders)
{
order.OrderDetails = orderDao.GetOrderDetails(order.OrderId);
}
}
response.Orders = Mapper.ToDataTransferObjects(orders);
}
return(response);
}
public void TestMultiple()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
IOrderCriteria orderCriteria = new OrderCriteria().Add("TestProp");
//---------------Assert PreConditions---------------
//---------------Execute Test ----------------------
orderCriteria.Add("TestProp2", SortDirection.Descending);
//---------------Test Result -----------------------
Assert.AreEqual(2, orderCriteria.Fields.Count);
Assert.Contains(new OrderCriteriaField("TestProp2", SortDirection.Descending), orderCriteria.Fields);
//---------------Tear Down -------------------------
}
public QueryCriteria Concat(QueryCriteria queryCriteria)
{
if (queryCriteria == null)
{
return(this);
}
Dictinct = queryCriteria.Dictinct;
SelectCriteria.AddRange(queryCriteria.SelectCriteria);
JoinCriteria.AddRange(queryCriteria.JoinCriteria);
WhereCriteria.AddRange(queryCriteria.WhereCriteria);
InternalWhere.AddRange(queryCriteria.InternalWhere);
OrderCriteria.AddRange(queryCriteria.OrderCriteria);
return(this);
}
public void TestToString()
{
//---------------Set up test pack-------------------
IOrderCriteria orderCriteria = new OrderCriteria().Add("TestProp");
orderCriteria.Add("TestProp2", SortDirection.Descending);
//---------------Assert PreConditions---------------
//---------------Execute Test ----------------------
string orderCriteriaString = orderCriteria.ToString();
//---------------Test Result -----------------------
StringAssert.AreEqualIgnoringCase("TestProp ASC, TestProp2 DESC", orderCriteriaString);
//---------------Tear Down -------------------------
}
public void TestSetOrderCriteria()
{
//---------------Set up test pack-------------------
var selectQuery = new SelectQuery {
Source = new Source(TestUtil.GetRandomString())
};
//---------------Execute Test ----------------------
var orderCriteria = new OrderCriteria().Add("testfield");
selectQuery.OrderCriteria = orderCriteria;
//---------------Test Result -----------------------
Assert.AreSame(orderCriteria, selectQuery.OrderCriteria);
Assert.AreEqual(0, selectQuery.Source.Joins.Count);
//---------------Tear Down -------------------------
}
public QueryParams Join(QueryParams queryParams)
{
if (queryParams == null)
{
return(this);
}
Dictinct = queryParams.Dictinct;
TakeRows = queryParams.TakeRows;
SkipRows = queryParams.SkipRows;
InternalWhere.AddRange(queryParams.InternalWhere);
WhereCriteria.AddRange(queryParams.WhereCriteria);
JoinCriteria.AddRange(queryParams.JoinCriteria);
OrderCriteria.AddRange(queryParams.OrderCriteria);
return(this);
}
public void TestMultiple()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
IOrderCriteria orderCriteria = new OrderCriteria().Add("TestProp");
//---------------Assert PreConditions---------------
//---------------Execute Test ----------------------
orderCriteria.Add("TestProp2", SortDirection.Descending);
//---------------Test Result -----------------------
Assert.AreEqual(2, orderCriteria.Fields.Count);
Assert.Contains(new OrderCriteriaField("TestProp2", SortDirection.Descending), orderCriteria.Fields);
//---------------Tear Down -------------------------
}
public void TestFromString_InvalidSortOrder()
{
//---------------Set up test pack-------------------
//---------------Execute Test ----------------------
try
{
OrderCriteria.FromString("TestProp adfe");
Assert.Fail("FromString should have failed due to a badly named sort order");
//---------------Test Result -----------------------
} catch (ArgumentException ex)
{
StringAssert.Contains("is an invalid sort order. Valid options are ASC and DESC", ex.Message);
}
}
public List <TDto> RetrieveOrdersByCustomer <TDto>(object id, IDataConverter <OrderBriefInfoData, TDto> converter)
where TDto : class
{
ArgumentValidator.IsNotNull("id", id);
OrderCriteria criteria = new OrderCriteria();
criteria.CustomerId = id;
List <TDto> instances = OrderSystem.RetrieveOrdersBySearch(criteria, converter);
if (instances == null)
{
instances = new List <TDto>();
}
return(instances);
}
public List <TDto> RetrieveOrdersByOrderNumber <TDto>(string orderNumber, IDataConverter <OrderBriefInfoData, TDto> converter)
where TDto : class
{
ArgumentValidator.IsNotNull("orderNumber", orderNumber);
OrderCriteria criteria = new OrderCriteria();
criteria.OrderNumber = orderNumber;
List <TDto> instances = OrderSystem.RetrieveOrdersBySearch(criteria, converter);
if (instances == null)
{
instances = new List <TDto>();
}
return(instances);
}
public void Sort_OneFieldAscending()
{
//---------------Set up test pack-------------------
var resultSet = new QueryResult();
resultSet.AddField("Name");
const string lastValue = "zzzzz";
const string firstValue = "aaaaa";
resultSet.AddResult(new object[] { lastValue });
resultSet.AddResult(new object[] { firstValue });
var orderCriteria = new OrderCriteria();
orderCriteria.Add("Name");
var sorter = new QueryResultSorter();
//---------------Execute Test ----------------------
sorter.Sort(resultSet, orderCriteria);
//---------------Test Result -----------------------
var rows = resultSet.Rows.ToList();
Assert.AreEqual(firstValue, rows[0].Values[0]);
Assert.AreEqual(lastValue, rows[1].Values[0]);
}
private Order Create(OrderCriteria criteria)
{
var item = (Order)Activator.CreateInstance(typeof(Order), true);
bool cancel = false;
OnCreating(ref cancel);
if (cancel) return item;
var resource = Fetch(criteria);
using (BypassPropertyChecks(item))
{
item.UserId = resource.UserId;
item.OrderDate = resource.OrderDate;
item.ShipAddr1 = resource.ShipAddr1;
item.ShipAddr2 = resource.ShipAddr2;
item.ShipCity = resource.ShipCity;
item.ShipState = resource.ShipState;
item.ShipZip = resource.ShipZip;
item.ShipCountry = resource.ShipCountry;
item.BillAddr1 = resource.BillAddr1;
item.BillAddr2 = resource.BillAddr2;
item.BillCity = resource.BillCity;
item.BillState = resource.BillState;
item.BillZip = resource.BillZip;
item.BillCountry = resource.BillCountry;
item.Courier = resource.Courier;
item.TotalPrice = resource.TotalPrice;
item.BillToFirstName = resource.BillToFirstName;
item.BillToLastName = resource.BillToLastName;
item.ShipToFirstName = resource.ShipToFirstName;
item.ShipToLastName = resource.ShipToLastName;
item.AuthorizationNumber = resource.AuthorizationNumber;
item.Locale = resource.Locale;
}
CheckRules(item);
MarkNew(item);
OnCreated();
return item;
}
/// <summary>
/// Fetch OrderList.
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
public OrderList Fetch(OrderCriteria criteria)
{
OrderList item = (OrderList)Activator.CreateInstance(typeof(OrderList), true);
bool cancel = false;
OnFetching(criteria, ref cancel);
if (cancel) return item;
// Fetch Child objects.
using (var connection = new SqlConnection(ADOHelper.ConnectionString))
{
connection.Open();
using (var command = new SqlCommand("[dbo].[CSLA_Order_Select]", connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddRange(ADOHelper.SqlParameters(criteria.StateBag));
command.Parameters.AddWithValue("@p_ShipAddr2HasValue", criteria.ShipAddr2HasValue);
command.Parameters.AddWithValue("@p_BillAddr2HasValue", criteria.BillAddr2HasValue);
using(var reader = new SafeDataReader(command.ExecuteReader()))
{
if(reader.Read())
{
do
{
item.Add(new OrderFactory().Map(reader));
} while(reader.Read());
}
}
}
}
MarkOld(item);
MarkAsChild(item);
OnFetched();
return item;
}
public void TestCompareGreater()
{
//---------------Set up test pack-------------------
ContactPersonTestBO.LoadDefaultClassDef();
IOrderCriteria orderCriteria = new OrderCriteria().Add("Surname");
ContactPersonTestBO cp1 = new ContactPersonTestBO();
cp1.Surname = "zzzzzz";
ContactPersonTestBO cp2 = new ContactPersonTestBO();
cp2.Surname = "ffffff";
//---------------Execute Test ----------------------
int comparisonResult = orderCriteria.Compare(cp1, cp2);
//---------------Test Result -----------------------
Assert.Greater(comparisonResult, 0);
//---------------Tear Down -------------------------
}
public void TestCompareLess_Desc()
{
//---------------Set up test pack-------------------
ContactPersonTestBO.LoadDefaultClassDef();
IOrderCriteria orderCriteria = new OrderCriteria().Add("Surname", SortDirection.Descending);
ContactPersonTestBO cp1 = new ContactPersonTestBO();
cp1.Surname = "aaaaaa";
ContactPersonTestBO cp2 = new ContactPersonTestBO();
cp2.Surname = "bbbbbb";
//---------------Execute Test ----------------------
int comparisonResult = orderCriteria.Compare(cp1, cp2);
//---------------Test Result -----------------------
Assert.Greater(comparisonResult, 0);
//---------------Tear Down -------------------------
}
public void TestSetOrderCriteria()
{
//---------------Set up test pack-------------------
var selectQuery = new SelectQuery {Source = new Source(TestUtil.GetRandomString())};
//---------------Execute Test ----------------------
var orderCriteria = new OrderCriteria().Add("testfield");
selectQuery.OrderCriteria = orderCriteria;
//---------------Test Result -----------------------
Assert.AreSame(orderCriteria, selectQuery.OrderCriteria);
Assert.AreEqual(0, selectQuery.Source.Joins.Count);
//---------------Tear Down -------------------------
}
//[Transactional(TransactionalTypes.TransactionScope)]
protected void DataPortal_Delete(OrderCriteria criteria, SqlConnection connection)
{
bool cancel = false;
OnDeleting(criteria, ref cancel);
if (cancel) return;
string commandText = String.Format("DELETE FROM [dbo].[Orders] {0}", ADOHelper.BuildWhereStatement(criteria.StateBag));
using (var command = new SqlCommand(commandText, connection))
{
command.Parameters.AddRange(ADOHelper.SqlParameters(criteria.StateBag));
//result: The number of rows changed, inserted, or deleted. -1 for select statements; 0 if no rows were affected, or the statement failed.
int result = command.ExecuteNonQuery();
if (result == 0)
throw new DBConcurrencyException("The entity is out of date on the client. Please update the entity and try again. This could also be thrown if the sql statement failed to execute.");
}
OnDeleted();
}
/// <summary>
/// Constructor to create a new single relationship definition
/// </summary>
/// <param name="relationshipName">A name for the relationship</param>
/// <param name="relatedObjectAssemblyName">The assembly name of the related object</param>
/// <param name="relatedObjectClassName">The class name of the related object</param>
/// <param name="relKeyDef">The related key definition</param>
/// <param name="keepReferenceToRelatedObject">Whether to keep a
/// reference to the related object. Could be false for memory-
/// intensive applications.</param>
/// <param name="orderBy">The sql order-by clause</param>
/// <param name="deleteParentAction">Provides specific instructions
/// with regards to deleting a parent object. See the DeleteParentAction
/// enumeration for more detail.</param>
/// <param name="insertParentAction"></param>
/// <param name="relationshipType">Provides specific instructions for adding/removing a child object.</param>
/// <param name="timeout">The timout in milliseconds. The collection will not be automatically refreshed from the DB if the timeout has nto expired</param>
public MultipleRelationshipDef(string relationshipName, string relatedObjectAssemblyName, string relatedObjectClassName, IRelKeyDef relKeyDef, bool keepReferenceToRelatedObject, string orderBy, DeleteParentAction deleteParentAction, InsertParentAction insertParentAction, RelationshipType relationshipType, int timeout)
: base(relationshipName, relatedObjectAssemblyName, relatedObjectClassName, relKeyDef,
keepReferenceToRelatedObject, deleteParentAction, insertParentAction, relationshipType)
{
ArgumentValidationHelper.CheckArgumentNotNull(orderBy, "orderBy");
TimeOut = timeout;
OrderCriteriaString = orderBy;
OrderCriteria = new OrderCriteria();
OrderCriteria = Base.OrderCriteria.FromString(orderBy);
}
public void TestSetOrderCriteria_AddsJoinToSource()
{
//---------------Set up test pack-------------------
var selectQuery = new SelectQuery();
const string sourceName = "mysource";
selectQuery.Source = new Source(sourceName);
var orderSource = new Source(sourceName);
var expectedSourceName = TestUtil.GetRandomString();
orderSource.JoinToSource(new Source(expectedSourceName));
var orderOrderCriteriaField = new OrderCriteriaField("testfield", "testfield", orderSource, SortDirection.Ascending);
var orderCriteria = new OrderCriteria().Add(orderOrderCriteriaField);
//---------------Execute Test ----------------------
selectQuery.OrderCriteria = orderCriteria;
//---------------Test Result -----------------------
Assert.AreEqual(1, selectQuery.Source.Joins.Count);
Assert.AreEqual(selectQuery.Source, selectQuery.Source.Joins[0].FromSource);
Assert.AreEqual(expectedSourceName, selectQuery.Source.Joins[0].ToSource.Name);
}
public void TestOrderCriteriaWithNoSource()
{
try
{
//---------------Set up test pack-------------------
var selectQuery = new SelectQuery();
//---------------Execute Test ----------------------
var orderCriteria = new OrderCriteria().Add("testfield");
selectQuery.OrderCriteria = orderCriteria;
//---------------Test Result -----------------------
Assert.AreSame(orderCriteria, selectQuery.OrderCriteria);
//---------------Tear Down -------------------------
Assert.Fail("Expected to throw an HabaneroApplicationException");
}
//---------------Test Result -----------------------
catch (HabaneroApplicationException ex)
{
StringAssert.Contains("You cannot set an OrderCriteria for a SelectQuery if no Source has been set", ex.Message);
}
}
private void UpdateOrders()
{
// Protect against SelectedAccount being null
if (this.UserContext.SelectedAccount == null)
return;
OrderCriteria criteria = new OrderCriteria
{
AccountIdSpecified = true,
AccountId = this.UserContext.SelectedAccount.Id,
OrderIdSpecified = OrderId.HasValue,
OrderId = OrderId.HasValue ? OrderId.Value : 0,
Symbol = (string.IsNullOrEmpty(Symbol) || Symbol.Trim().Length == 0) ? null : Symbol,
FromDateSpecified = FromDate.HasValue,
FromDate = FromDate.HasValue ? FromDate.Value : DateTime.MinValue,
ToDateSpecified = ToDate.HasValue,
ToDate = ToDate.HasValue ? ToDate.Value : DateTime.MinValue,
Side = GetSideFilters(),
Status = GetStatusFilters()
};
_tradingService.GetOrdersAsync(criteria);
}
public HttpResponseMessage Search(SearchModel model)
{
if (ModelState.IsValid)
{
string[] productIds = null;
if (!string.IsNullOrWhiteSpace(model.p))
{
var productCatalog = _productCatalogClientFactory.GetProductCatalogClient();
var productSearchResult = productCatalog.Search(new ProductQuery
{
SearchField = ProductQuery.SearchFields.LimitedFields,
SearchTerms = model.p,
PageSize = 50,
});
if (productSearchResult == null || productSearchResult.TotalCount == 0)
return ApiHelpers.JsonResponseMessage(@"{ ""hits"": { ""total"": 0, ""hits"": [] } }");
productIds = productSearchResult.Products.Select(r => r.ProductId).ToArray();
}
var criteria = new OrderCriteria
{
QueryString = model.q,
CustomerId = model.cid,
OrderSource = model.src,
OrderStatus = model.sts,
PaymentStatus = model.ps,
ProductIds = productIds,
MinOrderDateUtc = model.ods.HasValue ? model.ods.Value.ToUniversalTime() : (DateTime?)null,
MaxOrderDateUtc = model.ode.HasValue ? model.ode.Value.ToUniversalTime() : (DateTime?)null,
IsDeleted = model.d,
QueryFields = model.qf,
ResultFields = model.rf,
Page = model.i - 1,
PageSize = model.s,
IsArchived = model.a
};
if (!string.IsNullOrWhiteSpace(model.sf))
criteria.Sort = new[] { new Sort { Field = model.sf, Descending = model.sd ?? false } };
var orderSearch = _clientFactory.GetOrderSearchClient();
var json = orderSearch.Search(criteria);
return ApiHelpers.JsonResponseMessage(json);
}
throw ApiHelpers.ServerError(ModelState);
}
public void TestCompareTwoPropsWithSameFirstValue_Less()
{
//---------------Set up test pack-------------------
ContactPersonTestBO.LoadDefaultClassDef();
IOrderCriteria orderCriteria = new OrderCriteria().Add("Surname").Add("FirstName");
ContactPersonTestBO cp1 = new ContactPersonTestBO();
cp1.Surname = "bbbb";
cp1.FirstName = "aaaa";
ContactPersonTestBO cp2 = new ContactPersonTestBO();
cp2.Surname = cp1.Surname;
cp2.FirstName = "zzzz";
//---------------Execute Test ----------------------
int comparisonResult = orderCriteria.Compare(cp1, cp2);
//---------------Test Result -----------------------
Assert.Less(comparisonResult, 0);
//---------------Tear Down -------------------------
}
public static void GetOrder(string uniqueId, EventHandler<DataPortalResult<Order>> handler)
{
var criteria = new OrderCriteria{UserId = uniqueId};
var dp = new DataPortal< Order >();
dp.FetchCompleted += handler;
dp.BeginFetch(criteria);
}
/// <summary> /// CodeSmith generated stub method that is called when deleting the <see cref="Order"/> object. /// </summary> /// <param name="criteria"><see cref="OrderCriteria"/> object containing the criteria of the object to delete.</param> /// <param name="cancel">Value returned from the method indicating whether the object deletion should proceed.</param> partial void OnDeleting(OrderCriteria criteria, ref bool cancel);
/// <summary> /// CodeSmith generated stub method that is called when fetching the <see cref="Order"/> object. /// </summary> /// <param name="criteria"><see cref="OrderCriteria"/> object containing the criteria of the object to fetch.</param> /// <param name="cancel">Value returned from the method indicating whether the object fetching should proceed.</param> partial void OnFetching(OrderCriteria criteria, ref bool cancel);
protected void DoDelete(ref Order item)
{
// If we're not dirty then don't update the database.
if (!item.IsDirty) return;
// If we're new then don't call delete.
if (item.IsNew) return;
var criteria = new OrderCriteria{OrderId = item.OrderId};
DoDelete(criteria);
MarkNew(item);
}
public void Delete(OrderCriteria criteria)
{
//Note: this call to delete is for immediate deletion and doesn't keep track of any entity state.
DoDelete(criteria);
}
private void DownloadSalesData()
{
try {
this.StatusDescription = string.Format("Creating ChannelAdvisor Client");
//Create OrderService client and ready it for request
string devKey = System.Configuration.ConfigurationManager.AppSettings["CaDevK"];
string devPW = System.Configuration.ConfigurationManager.AppSettings["CaDevPw"];
//int profileID = 32001327;
string accountID = System.Configuration.ConfigurationManager.AppSettings["CaAcct"]; ;
APICredentials cred = new APICredentials();
cred.DeveloperKey = devKey;
cred.Password = devPW;
OrderServiceSoapClient ordClient = new OrderServiceSoapClient();
//Get latest order date in DB, and pull all orders since then
DateTime beginTime;
using (var db = new CheapeesEntities())
{
beginTime = (DateTime)db.MerchantFulfilledSales.OrderByDescending(o => o.OrderTime).FirstOrDefault().OrderTime;
}
OrderCriteria criteria = new OrderCriteria();
criteria.OrderCreationFilterBeginTimeGMT = beginTime;
criteria.OrderCreationFilterEndTimeGMT = DateTime.Now;
criteria.DetailLevel = "High";
List<ChannelAdvisorSale> listOfSales = new List<ChannelAdvisorSale>();
int page = 1;
criteria.PageNumberFilter = page;
//Issue requests
this.StatusDescription = string.Format("Requesting sales data since latest sale ({0})", beginTime);
APIResultOfArrayOfOrderResponseItem response = ordClient.GetOrderList(cred, accountID, criteria);
int numberOfOrders = 0;
//When everything has been retrieved, pages will be returned empty and should exit loop
while (response.ResultData.Length != 0)
{
numberOfOrders += response.ResultData.Length;
this.StatusDescription = string.Format("Downloading sales data: {0} orders retrieved", numberOfOrders);
foreach (OrderResponseDetailHigh order in response.ResultData)
{
foreach (OrderLineItemItem item in order.ShoppingCart.LineItemSKUList)
{
ChannelAdvisorSale sale = new ChannelAdvisorSale();
sale.SKU = item.SKU;
sale.Quantity = item.Quantity;
sale.Marketplace = item.ItemSaleSource;
sale.UnitPrice = item.UnitPrice;
sale.OrderTime = ((DateTime)order.OrderTimeGMT).ToLocalTime();
sale.Invoice = order.OrderID.ToString();
listOfSales.Add(sale);
}
}
//Get next page of results
page++;
criteria.PageNumberFilter = page;
response = ordClient.GetOrderList(cred, accountID, criteria);
}
CommitToDatabase(listOfSales);
}
catch (Exception e)
{
throw new Exception(string.Format("ChannelAdvisorOrderService - {0}", e.Message));
}
}
public void TestToString()
{
//---------------Set up test pack-------------------
IOrderCriteria orderCriteria = new OrderCriteria().Add("TestProp");
orderCriteria.Add("TestProp2", SortDirection.Descending);
//---------------Assert PreConditions---------------
//---------------Execute Test ----------------------
string orderCriteriaString = orderCriteria.ToString();
//---------------Test Result -----------------------
StringAssert.AreEqualIgnoringCase("TestProp ASC, TestProp2 DESC", orderCriteriaString);
//---------------Tear Down -------------------------
}
//[Transactional(TransactionalTypes.TransactionScope)]
protected void DataPortal_Delete(OrderCriteria criteria, SqlConnection connection)
{
bool cancel = false;
OnDeleting(criteria, ref cancel);
if (cancel) return;
using (var command = new SqlCommand("[dbo].[CSLA_Order_Delete]", connection))
{
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddRange(ADOHelper.SqlParameters(criteria.StateBag));
//result: The number of rows changed, inserted, or deleted. -1 for select statements; 0 if no rows were affected, or the statement failed.
int result = command.ExecuteNonQuery();
if (result == 0)
throw new DBConcurrencyException("The entity is out of date on the client. Please update the entity and try again. This could also be thrown if the sql statement failed to execute.");
}
OnDeleted();
}
public void Test_GetCollection_Generic_LoadWithLimit_FirstAtStart_LimitEqualsEnd()
//NoRecords_StartRecords_ContainsAllRecords()
{
const int totalRecords = 3;
const int firstRecord = 0;
const int limit = totalRecords;
SetupDefaultContactPersonBO();
ContactPersonTestBO[] contactPersonTestBOs = CreateSavedContactPeople(totalRecords);
OrderCriteria orderCriteria = new OrderCriteria();
orderCriteria.Add("Surname");
//---------------Assert Precondition----------------
Assert.AreEqual(totalRecords, contactPersonTestBOs.Length);
//---------------Execute Test ----------------------
int totalNoOfRecords;
BusinessObjectCollection<ContactPersonTestBO> col =
BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObjectCollection<ContactPersonTestBO>
(null, orderCriteria, firstRecord, limit, out totalNoOfRecords);
//---------------Test Result -----------------------
AssertLimitedResultsCorrect
(firstRecord, limit, totalRecords, totalRecords, contactPersonTestBOs, col, totalNoOfRecords);
}
