public static int SaveEntityCollection(IEntityCollection2 entitiesToSave)
{
using (DataAccessAdapterBase dataAccessAdapterBase = new DataAccessAdapter(ManageBase.ConnectionString))
{
return(dataAccessAdapterBase.SaveEntityCollection(entitiesToSave, true, false));
}
}
/// <summary>
/// Saves the orders passed in
/// </summary>
/// <param name="orders">The orders.</param>
public void SaveOrders(IEntityCollection2 orders)
{
using (DataAccessAdapter adapter = new DataAccessAdapter())
{
adapter.SaveEntityCollection(orders, false, true);
}
}
public OrderItem GetOrderItem(long orderItemId)
{
IOrderItemTraits orderItemTraits;
long itemId;
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
var linqMetaData = new LinqMetaData(myAdapter);
var orderItemType = (OrderItemType)linqMetaData.OrderItem.Single(oi => oi.OrderItemId == orderItemId).Type;
orderItemTraits = _orderItemTraitsFactory.CreateTraits(orderItemType);
if (orderItemType == OrderItemType.CancellationFee)
{
return(orderItemTraits.CreateOrderItem(orderItemId, orderItemId));
}
IPredicate orderItemPredicate = orderItemTraits.OrderItemIdPredicate(orderItemId);
IEntityCollection2 itemEntities = orderItemTraits.CreateItemEntityCollection();
myAdapter.FetchEntityCollection(itemEntities, new RelationPredicateBucket(orderItemPredicate));
if (itemEntities.HasSingleItem())
{
itemId = orderItemTraits.GetItemId(itemEntities[0]);
}
else
{
throw new DuplicateObjectException <OrderItem>();
}
}
return(orderItemTraits.CreateOrderItem(orderItemId, itemId));
}
protected void ExpectLinqFetchEntityCollection(IEntityCollection2 entitiesToReturn)
{
_entitiesToReturn = entitiesToReturn;
Expect.Call(_dataAccessAdapter.FunctionMappings).Return(new FunctionMappingStore());
Expect.Call(() => _dataAccessAdapter.FetchEntityCollection(null, null, 0, null, null, null, 0, 0)).
IgnoreArguments().Callback(new FetchLinqEntityCollectionDelegate(FetchEntityCollection));
}
public void CreateItemEntityCollectionReturnsEmptyEntityCollection()
{
const int expectedNumberOfEntities = 0;
IEntityCollection2 entityCollection = _testOrderItemTraits.CreateItemEntityCollection();
Assert.AreEqual(expectedNumberOfEntities, entityCollection.Count, "CreateItemEntityCollection returned nonempty collection of entities.");
}
private bool FetchEntityCollection(IEntityCollection2 collection, IRelationPredicateBucket bucket)
{
if (_entitiesToReturn != null)
{
foreach (IEntity2 entity in _entitiesToReturn)
{
collection.Add(entity);
}
}
return(true);
}
private bool SaveData(IEntityCollection2 customerHealthInfoEntitities)
{
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
if (myAdapter.SaveEntityCollection(customerHealthInfoEntitities) > 0)
{
return(true);
}
return(false);
}
}
private bool FetchEntityCollection(IEntityCollection2 collection, IRelationPredicateBucket bucket)
{
if (collection != null)
{
collection.Add(new GlobalConfigurationEntity
{
Name = ConfigurationSettingName.EpochDate.ToString(), Value = _expectedDateString
});
}
return(true);
}
private bool FetchEntityCollectionWithSortExpression(IEntityCollection2 collection,
IRelationPredicateBucket bucket, int maxNumberOfItemsToReturn, ISortExpression sortExpression)
{
if (_entitiesToReturnForSortExpression != null)
{
foreach (IEntity2 entity in _entitiesToReturnForSortExpression)
{
collection.Add(entity);
}
}
return(true);
}
/// <summary>
/// CTor
/// </summary>
public CustomersByProduct(INorthwindService service)
{
InitializeComponent();
_dalService = service;
// load products, sort them on ProductName asc.
IEntityCollection2 products = _dalService.GetProductsSortedBy(ProductFields.ProductName, SortOperator.Ascending);
// bind it to the combo box
productSelectComboBox.DataSource = products;
productSelectComboBox.DisplayMember = ProductFields.ProductName.Name;
productSelectComboBox.SelectedIndex = 0;
}
private bool FetchEntityCollection(IEntityCollection2 collection, IRelationPredicateBucket bucket,
int maxNumberOfItemsToReturn, ISortExpression sortExpression, IPrefetchPath2 prefetchPath,
ExcludeIncludeFieldsList excludeIncludeFieldsList, int pageNumber, int pageSize)
{
if (_entitiesToReturn != null)
{
foreach (IEntity2 entity in _entitiesToReturn)
{
collection.Add(entity);
}
}
return(true);
}
public OrderItem SaveOrderItem(long itemId, OrderItemType orderItemType)
{
long orderItemId;
IOrderItemTraits orderItemTraits = _orderItemTraitsFactory.CreateTraits(orderItemType);
IPredicate itemIdPredicate = orderItemTraits.ItemIdPredicate(itemId);
IEntityCollection2 itemEntityCollection = orderItemTraits.CreateItemEntityCollection();
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
// Check to make sure that this item isn't already mapped to another OrderItem.
myAdapter.FetchEntityCollection(itemEntityCollection, new RelationPredicateBucket(itemIdPredicate));
if (itemEntityCollection.Count > 0)
{
IEntity2 entity = itemEntityCollection[0];
// Get order item ID based off of item ID.
return(orderItemTraits.CreateOrderItem(orderItemTraits.GetOrderItemId(entity), itemId));
}
myAdapter.StartTransaction(IsolationLevel.ReadCommitted, "SaveNewOrderItemTransaction");
try
{
// Insert a new entry into the OrderItem table.
var orderItemEntity = new OrderItemEntity {
Type = (short)orderItemType
};
if (!myAdapter.SaveEntity(orderItemEntity))
{
throw new PersistenceFailureException();
}
// Insert a new entry into the corresponding mapping Item table.
orderItemId = orderItemEntity.OrderItemId;
IEntity2 itemEntityToSave = orderItemTraits.CreateItemEntity(orderItemId, itemId);
if (!myAdapter.SaveEntity(itemEntityToSave))
{
throw new PersistenceFailureException();
}
myAdapter.Commit();
}
catch (Exception)
{
myAdapter.Rollback();
throw;
}
}
return(orderItemTraits.CreateOrderItem(orderItemId, itemId));
}
private void productSelectComboBox_SelectedIndexChanged(object sender, System.EventArgs e)
{
// get the selected product
if (productSelectComboBox.SelectedItem == null)
{
return;
}
var selectedProduct = (ProductEntity)productSelectComboBox.SelectedItem;
IEntityCollection2 customers = _dalService.GetAllCustomersFilteredOnProduct(selectedProduct.ProductId);
customers.AllowNew = false;
// bind them
customersDataGrid.DataSource = customers;
_amountUnitsSoldTextBox.Text = _dalService.GetNumerOfTimesProductWasSold(selectedProduct.ProductId).ToString();
}
/// <summary>
/// CTor
/// </summary>
public CustomerSelector(INorthwindService service)
{
InitializeComponent();
// get all customers
_allCustomers = service.GetAllCustomers();
// bind to grid.
customersDataGrid.DataSource = _allCustomers;
if (_allCustomers.Count > 0)
{
// there are customers, enable select button
selectButton.Enabled = true;
// select first row.
customersDataGrid.Select(0);
}
}
/// <summary>
/// Supprime la collection d'entités passé en paramètre
/// </summary>
/// <param name="collection"></param>
public void Delete(IEntityCollection2 collection)
{
// La prorpriété RemovedEntitiesTracker des collections n'étant pas toujours renseignée, je préfère faire un test pour que cela ne plante pas
// plutôt que :
// 1) d'être obligé de faire ce test à chaque appel
// 2) obligé de renseigner les propriétés RemovedEntitiesTracker de toutes les collections à chaque récupération d'une entité
if (collection != null)
{
try
{
this.adapter.DeleteEntityCollection(collection);
}
catch (Exception e)
{
throw new ApplicationException(MessageSuppressionImpossible, e);
}
}
}
public IEnumerable <OrderItem> GetOrderItems(long[] orderItemId)
{
IOrderItemTraits orderItemTraits;
long itemId;
var orderItems = new List <OrderItem>();
using (var myAdapter = PersistenceLayer.GetDataAccessAdapter())
{
var linqMetaData = new LinqMetaData(myAdapter);
var orderItemEntities = linqMetaData.OrderItem.Where(oi => orderItemId.Contains(oi.OrderItemId)).ToList();
if (orderItemEntities.IsNullOrEmpty())
{
throw new ObjectNotFoundInPersistenceException <OrderItem>();
}
var orderItemTypes = orderItemEntities.Select(oi => oi.Type).Distinct();
foreach (var itemType in orderItemTypes)
{
var orderItemType = (OrderItemType)itemType;
orderItemTraits = _orderItemTraitsFactory.CreateTraits(orderItemType);
orderItemEntities.Where(oi => oi.Type == itemType).ToList().
ForEach(oi =>
{
IPredicate orderItemPredicate = orderItemTraits.OrderItemIdPredicate(oi.OrderItemId);
IEntityCollection2 itemEntities = orderItemTraits.CreateItemEntityCollection();
myAdapter.FetchEntityCollection(itemEntities, new RelationPredicateBucket(orderItemPredicate));
if (itemEntities.HasSingleItem())
{
itemId = orderItemTraits.GetItemId(itemEntities[0]);
}
else
{
throw new DuplicateObjectException <OrderItem>();
}
orderItems.Add(orderItemTraits.CreateOrderItem(oi.OrderItemId, itemId));
});
}
return(orderItems);
}
}
protected void ExpectFetchEntityCollectionWithSortExpression(IEntityCollection2 entityCollectionToReturn)
{
_entitiesToReturnForSortExpression = entityCollectionToReturn;
ExpectFetchEntityCollectionWithSortExpression();
}
public void FetchEntityCollection(IEntityCollection2 collectionToFill, IRelationPredicateBucket filterBucket, int maxNumberOfItemsToReturn, ISortExpression sortClauses)
{
adapter.FetchEntityCollection(collectionToFill, filterBucket, maxNumberOfItemsToReturn, sortClauses);
}
public int SaveEntity(IEntityCollection2 entities)
{
return(Adapter.SaveEntityCollection(entities));
}
public void CreateItemEntityCollectionReturnsEntityCollectionOfGiftCertificateOrderItemEntities()
{
IEntityCollection2 entityCollection = _giftCertificateOrderItemTraits.CreateItemEntityCollection();
Assert.IsInstanceOf <EntityCollection <GiftCertificateOrderItemEntity> >(entityCollection, "CreateItemEntityCollection returned collection of wrong type.");
}
public static PagedDataSource GetPaging(IEntityCollection2 view, string page, int PageSize)
{
return GetPaging(view.DefaultView, page, PageSize);
}
public void CreateItemEntityCollectionReturnsEntityCollectionOfTestOrderItemEntities()
{
IEntityCollection2 entityCollection = _testOrderItemTraits.CreateItemEntityCollection();
Assert.IsInstanceOf <EntityCollection <EventTestOrderItemEntity> >(entityCollection, "CreateItemEntityCollection returned collection of wrong type.");
}
protected void ExpectFetchEntityCollection(IEntityCollection2 entityCollectionToReturn)
{
_entitiesToReturn = entityCollectionToReturn;
ExpectFetchEntityCollection();
}
private void ExpectGetInstrumentsForPayment(IEntityCollection2 checkEntitiesToReturn)
{
ExpectGetDataAccessAdapterAndDispose();
ExpectFetchEntityCollection(checkEntitiesToReturn);
ExpectGetPaymentInstrumentsFromCheckEntities();
}