public void CategoriesShouldBeReturnedNested()
        {
            using (new TransactionScope())
            {
                var connectionStringProvider = new ConnectionStringProvider("<my connection string>");
                var dataContextProvider = new DataContextProvider(connectionStringProvider);

                // first insert a new graph into the database
                var categoryRepository = new Repository<Category>(dataContextProvider);

                // use the object graph created by the mock category repository
                var root = MockRepositoryBuilder.CreateCategoryRepository().GetRootCategory();

                // add the root into the real database
                categoryRepository.InsertOnSubmit(root);

                categoryRepository.SubmitChanges();

                // try to get the root again (note we need the actual id because we don't want the real root,
                // which will have a different graph of categories, from the database)
                var rootFromDb = categoryRepository.GetById(root.CategoryId);

                MockRepositoryBuilder.AssertCategoryGraphIsCorrect(rootFromDb);
            }
        }
        public static void CreateCollectionData(int locationId, int userId)
        {
            CheckoutDataContextProvider dcp = CheckoutDataContextProvider.Instance;

            Repository<CollectionData> rep = new Repository<CollectionData>(dcp);

            CollectionData collectionData = new CollectionData();
            collectionData.LocationID = locationId;

            rep.InsertOnSubmit(collectionData);
            dcp.CommitChanges(userId);
        }
        public static List<string> SaveOrders(List<OrderDO> orders, int userId)
        {
            List<string> savedOrderCodes = new List<string>();
            using (TransactionScope tran = TransactionScopeFactory.CreateTransactionScope())
            {
                Repository<Order> rep = new Repository<Order>(CheckoutDataContextProvider.Instance);
                foreach (var orderDO in orders)
                {
                    string validationProblem = string.Empty;
                    bool isOrderValid = ValidateIncomingOrder(orderDO, ref validationProblem);
                    if (isOrderValid == false)
                    {
                        ElmahLogger.Warn(string.Format("{0} kaydedilemiyor. Valid değil : {1}", orderDO.Code, validationProblem));
                        continue;
                    }

                    Order existingOrder = rep.GetAll().FirstOrDefault(x => x.Code == orderDO.Code);
                    if (existingOrder != null)
                    {
                        ElmahLogger.Warn(string.Format("{0} sipariş zaten var. Atlanıyor", orderDO.Code));
                        savedOrderCodes.Add(existingOrder.Code);
                        continue;
                    }

                    Order orderToSave = MapOrderDOToOrder(orderDO);
                    List<OrderItem> orderItemListToSave = MapOrderItemDOListToOrderItem(orderDO.ItemList);

                    var defaultPackagingLocation = LocationBL.GetDefaultPackagingLocation(orderToSave.StoreID);

                    orderItemListToSave.ForEach(x =>
                    {
                        if (string.IsNullOrEmpty(x.ItemIdentifier) == false)
                        {
                            x.PackagingLocationID = defaultPackagingLocation.ID;
                        }

                        x.StatusCode = OrderItemStatus.LocationWaiting.ToString();
                        x.StatusCodeUpdateTime = DateTime.UtcNow;
                    });

                    orderToSave.OrderItems.AddRange(orderItemListToSave);

                    rep.InsertOnSubmit(orderToSave);
                    savedOrderCodes.Add(orderToSave.Code);
                }

                rep.DCP.CommitChanges(userId);
                tran.Complete();
            }
            return savedOrderCodes;
        }
Example #4
0
        public static void SaveUserListMovie(int ListID, int MovieID, int SortOrder, int UserID)
        {
            Repository <USR_ListMovie> rep = new Repository <USR_ListMovie>(MArchiveDataContextProvider.Instance);

            USR_ListMovie objectToAdd = null;

            objectToAdd           = new USR_ListMovie();
            objectToAdd.ListID    = ListID;
            objectToAdd.MovieID   = MovieID;
            objectToAdd.SortOrder = SortOrder;

            rep.InsertOnSubmit(objectToAdd);
            rep.DCP.CommitChanges(UserID);

            InvalidateCache(CacheAreaKey);
        }
Example #5
0
        public static MovieTypeDO Save(MovieTypeDO inputDO, int userID)
        {
            Repository <MOV_M_Type> rep = new Repository <MOV_M_Type> (MArchiveDataContextProvider.Instance);

            MOV_M_Type objectToAdd = null;

            objectToAdd = new MOV_M_Type( );
            ObjectMapper.MapObjects(inputDO, objectToAdd, AuditInfo.Fields);
            rep.InsertOnSubmit(objectToAdd);

            rep.DCP.CommitChanges(userID);

            InvalidateCache(CacheAreaKey);

            ObjectMapper.MapObjects(objectToAdd, inputDO);
            return(inputDO);
        }
        public static int Save(ColorMappingDO colorMappingDO, int userID)
        {
            Repository<ColorMapping> repColor = new Repository<ColorMapping>(BeymenDataContextProvider.Instance);
            ColorMapping colorMapping;

            if (colorMappingDO.ID == 0)
            {
                colorMapping = new ColorMapping();
                ObjectMapper.MapObjects<ColorMappingDO, ColorMapping>(colorMappingDO, colorMapping);
                repColor.InsertOnSubmit(colorMapping);
            }
            else
            {
                colorMapping = repColor.GetAll().Where(x => x.ID == colorMappingDO.ID).SingleOrDefault();
                ObjectMapper.MapObjects<ColorMappingDO, ColorMapping>(colorMappingDO, colorMapping);
                repColor.UpdateByIdOnSubmit(colorMapping);
            }

            repColor.DCP.CommitChanges(userID);

            return colorMapping.ID;
        }
        public static void Save(Store_LocationDO model, int userID)
        {
            Repository<Store_Location> rep = new Repository<Store_Location>(CheckoutDataContextProvider.Instance);
            Store_Location dbObject;
         
            if (model.ID == 0)
            {
                dbObject = new Store_Location();
                Mapper.Map<Store_LocationDO, Store_Location>(model, dbObject);
                rep.InsertOnSubmit(dbObject);
            }
            else
            {
                dbObject = rep.GetAll().Where(x => x.ID == model.ID).SingleOrDefault();
                Mapper.Map<Store_LocationDO, Store_Location>(model, dbObject);
            }

            rep.DCP.CommitChanges(userID);
            
            Mapper.Map<Store_Location, Store_LocationDO>(dbObject, model);
                        
        }
Example #8
0
        public static void Save(MovieNameDO dataObj, int userID)
        {
            Repository <MOV_M_Name> rep = new Repository <MOV_M_Name>(MArchiveDataContextProvider.Instance);

            MOV_M_Name objectToAdd = null;

            if (dataObj.ID == 0)
            {
                objectToAdd = new MOV_M_Name( );
                ObjectMapper.MapObjects(dataObj, objectToAdd, AuditInfo.Fields);
                rep.InsertOnSubmit(objectToAdd);
            }
            else
            {
                objectToAdd = rep.GetAll( ).Single(x => x.ID == dataObj.ID);
                ObjectMapper.MapObjects(dataObj, objectToAdd, AuditInfo.Fields);
            }
            rep.DCP.CommitChanges(userID);

            InvalidateCache(CacheAreaKey);

            ObjectMapper.MapObjects(objectToAdd, dataObj);
        }
        public static void Save(MovieUserRatingDO dataObj, int userID)
        {
            Repository <MOV_M_UserRating> rep = new Repository <MOV_M_UserRating> (MArchiveDataContextProvider.Instance);

            MOV_M_UserRating rating = null;

            if (dataObj.ID == 0)
            {
                rating = new MOV_M_UserRating( );
                ObjectMapper.MapObjects(dataObj, rating, AuditInfo.Fields);
                rep.InsertOnSubmit(rating);
            }
            else
            {
                rating = rep.GetAll( ).Single(x => x.ID == dataObj.ID);
                ObjectMapper.MapObjects(dataObj, rating, AuditInfo.Fields);
            }
            rep.DCP.CommitChanges(userID);

            InvalidateCache(CacheAreaKey);

            ObjectMapper.MapObjects(dataObj, rating);
        }
Example #10
0
        private static void SaveFriendRequest(UserFriendRequestDO dataObj, int userID)
        {
            Repository <USR_FriendRequest> rep = new Repository <USR_FriendRequest>(MArchiveDataContextProvider.Instance);

            USR_FriendRequest objectToAdd = null;

            if (dataObj.ID == 0)
            {
                objectToAdd = new USR_FriendRequest();
                ObjectMapper.MapObjects(dataObj, objectToAdd, AuditInfo.Fields);
                rep.InsertOnSubmit(objectToAdd);
            }
            else
            {
                objectToAdd = rep.GetAll().Single(x => x.ID == dataObj.ID);
                ObjectMapper.MapObjects(dataObj, objectToAdd, AuditInfo.Fields);
            }
            rep.DCP.CommitChanges(userID);

            InvalidateCache(CacheAreaKey);

            ObjectMapper.MapObjects(objectToAdd, dataObj);
        }
Example #11
0
        public static ArchiveDO Save(ArchiveDO inputDO, int userID)
        {
            Repository <USR_Archive> rep = new Repository <USR_Archive>(MArchiveDataContextProvider.Instance);

            USR_Archive objectToAdd = null;

            if (inputDO.ID == 0)
            {
                objectToAdd = new USR_Archive();
                ObjectMapper.MapObjects(inputDO, objectToAdd, AuditInfo.Fields);
                rep.InsertOnSubmit(objectToAdd);
            }
            else
            {
                objectToAdd = rep.GetAll().Single(x => x.ID == inputDO.ID);
                ObjectMapper.MapObjects(inputDO, objectToAdd, AuditInfo.Fields);
            }
            rep.DCP.CommitChanges(userID);

            InvalidateCache(CacheAreaKey);

            ObjectMapper.MapObjects(objectToAdd, inputDO);
            return(inputDO);
        }
Example #12
0
        public static int Save(MovieDO movieDO, int userID)
        {
            Repository <MOV_M_Movie> rep = new Repository <MOV_M_Movie>(MArchiveDataContextProvider.Instance);

            MOV_M_Movie movieToAdd = null;

            if (movieDO.ID == 0)
            {
                movieToAdd = new MOV_M_Movie( );
                ObjectMapper.MapObjects(movieDO, movieToAdd, AuditInfo.Fields);
                rep.InsertOnSubmit(movieToAdd);
            }
            else
            {
                movieToAdd = rep.GetAll( ).Single(x => x.ID == movieDO.ID);
                ObjectMapper.MapObjects(movieDO, movieToAdd, AuditInfo.Fields);
            }
            rep.DCP.CommitChanges(userID);

            InvalidateCache(CacheAreaKey);

            ObjectMapper.MapObjects(movieToAdd, movieDO);
            return(movieDO.ID);
        }
        public static void Save(UserLocationDO model, int userID)
        {
            Repository<UserLocation> rep = new Repository<UserLocation>(CheckoutDataContextProvider.Instance);
            UserLocation dbObject;
            if (rep.GetAll().Where(x => x.UserName == model.UserName && x.LocationID == model.LocationID).SingleOrDefault() != null)
            {
                throw new BusinessException("Bu kullanıcı için bu lokasyon tanımlanmış");
            }

            if (model.ID == 0)
            {
                dbObject = new UserLocation();
                Mapper.Map<UserLocationDO, UserLocation>(model, dbObject);
                rep.InsertOnSubmit(dbObject);
            }
            else
            {
                dbObject = rep.GetAll().Where(x => x.ID == model.ID).SingleOrDefault();
                Mapper.Map<UserLocationDO, UserLocation>(model, dbObject);
            }

            rep.DCP.CommitChanges(userID);
            Mapper.Map<UserLocation, UserLocationDO>(dbObject, model);
        }
Example #14
0
        public static UserListDO SaveUserList(UserListDO inputDO)
        {
            Repository <USR_List> rep = new Repository <USR_List>(MArchiveDataContextProvider.Instance);

            USR_List objectToAdd = null;

            if (inputDO.ID == 0)
            {
                objectToAdd = new USR_List();
                ObjectMapper.MapObjects(inputDO, objectToAdd);
                rep.InsertOnSubmit(objectToAdd);
            }
            else
            {
                objectToAdd = rep.GetAll().Single(x => x.ID == inputDO.ID);
                ObjectMapper.MapObjects(inputDO, objectToAdd);
            }
            rep.DCP.CommitChanges(inputDO.UserID);

            InvalidateCache(CacheAreaKey);

            ObjectMapper.MapObjects(objectToAdd, inputDO);
            return(inputDO);
        }
        public static void AddOrderItemToNotFoundList(OrderItemDO orderItemDO, int locationId, int userId)
        {
            CollectionDataDO collectionDataDO = CollectionDataBL.CreateCollectionDataIfNotExist(locationId, userId);

            ValidateLocation(locationId, collectionDataDO.Location.ID);

            CheckoutDataContextProvider dcp = CheckoutDataContextProvider.Instance;

            OrderItemDO orderItem = CheckoutBL.GetOrderItemById(orderItemDO.ID);

            if (SupplyRuleEngine.CanOrderItemBeAddedToNotFoundList(collectionDataDO, orderItem))
            {
                Repository<CollectionOrderItem> rep = new Repository<CollectionOrderItem>(dcp);
                CollectionOrderItem collectionOrderItem = new CollectionOrderItem();
                collectionOrderItem.OrderItemID = orderItemDO.ID;
                collectionOrderItem.StatusCode = OrderItemStatus.NotFound.ToString();
                collectionOrderItem.CollectionDataID = collectionDataDO.ID;
                collectionOrderItem.NotFoundReasonID = orderItemDO.NotFoundReasonID;
                rep.InsertOnSubmit(collectionOrderItem);
                dcp.CommitChanges(userId);
            }
        }
        public static void AddOrderItemListToFoundList(List<int> orderItemIdList, int locationId, int userId)
        {
            CollectionDataDO collectionDataDO = CollectionDataBL.CreateCollectionDataIfNotExist(locationId, userId);
            ValidateLocation(locationId, collectionDataDO.Location.ID);
            CheckoutDataContextProvider dcp = CheckoutDataContextProvider.Instance;
            List<OrderItemDO> orderItemList = CheckoutBL.GetOrderItemListByIdList(orderItemIdList);

            foreach (var orderItem in orderItemList)
            {
                if (SupplyRuleEngine.CanOrderItemBeAddedToFoundList(collectionDataDO, orderItem))
                {
                    Repository<CollectionOrderItem> rep = new Repository<CollectionOrderItem>(dcp);
                    CollectionOrderItem collectionOrderItem = new CollectionOrderItem();
                    collectionOrderItem.OrderItemID = orderItem.ID;
                    collectionOrderItem.StatusCode = OrderItemStatus.Found.ToString();
                    collectionOrderItem.CollectionDataID = collectionDataDO.ID;
                    rep.InsertOnSubmit(collectionOrderItem);
                }
            }

            dcp.CommitChanges(userId);
        }