private int SyncProducts(ConnectsterUser user)
        {
            int returnCount = 0;

            //Ask the db for credentials
            ShopifyStoreAuth shopifyAuth = _database.SelectShopifyUserDetails(user);
            ShopsterUser shopsterUser = _database.SelectShopsterUserDetails(user);

            var apiContext = new ConnectsterApiContext
                                 {
                                     AccessToken = shopsterUser.AuthToken,
                                     AccessTokenSecret = shopsterUser.AuthSecret
                                 };

            List<InventoryItemType> shopsterList;
            ConnectsterProductMap productMap;
            List<ShopifyProduct> shopifyItems;
            ShopifyMetafieldMap shopifyMapping;

            //Todo: Decide the lowest DetailGroup needed
            try
            {
                shopsterList =
                    _shopsterComm.GetAllInventoryItemsForUser(apiContext, "All").Where(
                        item => item.IsStoreVisible == true).Select(item => item).ToList();
                productMap = new ConnectsterProductMap(user);
                shopifyItems = _shopifyComm.GetAllProducts(shopifyAuth);
                shopifyMapping = new ShopifyMetafieldMap(_shopifyComm, shopifyAuth);
            }
            catch (Exception e)
            {
                logger.FatalFormat(
                    "ConnectsterController::SyncProducts(): Exception while creating lists. Exception is ({0}).",
                    e.Message);
                return 0;
                //todo : throw our own exception class to the program to indicate the user should be disabled or ignored for a while.
            }

            if (shopifyItems == null)
            {
                //todo : again we need to throw our own exception class to indicate the user should be disabled or ignored for a while.
                return 0;
            }

            //create these lists here to reduce redundancy in proceeding calls.
            List<int> shopsterIds = shopsterList.Select(item => Convert.ToInt32(item.ItemId)).ToList();
            List<int> shopifyIds = shopifyItems.Select(item => (int) item.Id).ToList();
            _database.UpdateShopsterProductTimeStamps(shopsterList, DateTime.UtcNow);

            #if DEBUG
            //Some debugging info
            foreach (ConnectsterProduct mappedItem in productMap.GetMappedItems())
            {
                logger.DebugFormat(
                    "ConnectsterController::CreateListsAndBegin(): ShopsterifyDB has ShopsterId({0}, Date({1:yyyy-MM-dd HH:mm:ss}) \tMapped to \t ShopifyId({2}, Date({3:yyyy-MM-dd HH:mm:ss})",
                    mappedItem.SourceId, mappedItem.SourceDate, mappedItem.DestinationId, mappedItem.DestinationDate);
            }

            foreach (ShopifyProduct item in shopifyItems)
            {
                logger.DebugFormat(
                    "ConnectsterController::CreateListsAndBegin(): Shopify has shopifyItem({0}, Date:{1: yyyy-MM-dd HH:mm:ss})",
                    item.Id, ((DateTime) item.Variants[0].UpdatedAt));
            }

            foreach (ShopifyMetafieldMapping mapping in shopifyMapping.GetMappedItems())
            {
                logger.DebugFormat("Shopify has Item({0}) --> ShopsterId({1})", mapping.SourceId, mapping.DestinationId);
            }
            #endif

            //Now do the actual syncronizing actions

            //This will ensure that all shopster products are in the db and on shopify
            returnCount += PushProductToShopify(shopsterList, productMap, shopifyMapping, shopifyIds, shopifyItems,
                                                shopifyAuth, apiContext);

            //This will clean up all the broken Maps
            returnCount += FixOrphanedMappings(shopsterIds, productMap, shopifyMapping, shopifyIds, shopifyAuth);

            //This will delete all orphaned shopify items (not mapped at all, but tagged as shopster items).
            return (returnCount +
                    DeleteOrphanedShopifyProducts(shopsterList, productMap, shopifyMapping, shopifyAuth));
        }
        //End of PushProductToShopify
        /// <summary>
        /// Deals with any orphaned cases with a Mapped remaining. Attempts to clean up any shopify Items in the process.
        /// </summary>
        /// <param name="shopsterIds"></param>
        /// <param name="productMap"></param>
        /// <param name="shopifyMapping"></param>
        /// <param name="shopifyIds"></param>
        /// <param name="shopifyAuth"></param>
        /// <returns>Number of "items" affected</returns>
        private int FixOrphanedMappings(IList<int> shopsterIds, ConnectsterProductMap productMap,
                                        ShopifyMetafieldMap shopifyMapping, IList<int> shopifyIds,
                                        ShopifyStoreAuth shopifyAuth)
        {
            int returnCount = 0;

            //Foreach productMap for which there is no corresponding shopsterItem.
            // Delete the map, and if applicable delete the shopifyItem.
            foreach (ConnectsterProduct shopsterifyProduct in productMap.GetMappedItems()
                .Where(p => !shopsterIds.Contains(p.SourceId)).Select(p => p).ToList())
            {
                //case 2
                if (!shopifyIds.Contains(shopsterifyProduct.DestinationId))
                {
                    productMap.DeleteMapping(shopsterifyProduct);
                    returnCount++;
                }
                else //case 6
                {
                    if (DeleteProductAndDeleteMap(shopifyAuth, productMap, shopsterifyProduct))
                    {
                        shopifyIds.Remove(shopsterifyProduct.DestinationId);
                        ConnectsterProduct product = shopsterifyProduct;
                        ShopifyMetafieldMapping toRemove =
                            shopifyMapping.GetMappedItems().Where(
                                map => map.SourceId == product.DestinationId).Select(map => map).
                                FirstOrDefault();
                        shopifyMapping.GetMappedItems().Remove(toRemove);
                        returnCount++;
                    }
                }
            }
            return returnCount;
        }
        /// <summary>
        /// Pushes all shopster products to shopify. Deals with all error states with an existing shopster Item. Deals with cases 1357, all ending in case7's state (see wiki).
        /// </summary>
        /// <param name="shopsterItems"></param>
        /// <param name="productMap"></param>
        /// <param name="shopifyMap"></param>
        /// <param name="shopifyIds"></param>
        /// <param name="shopifyItems"></param>
        /// <param name="storeAuth"></param>
        /// <param name="apiContext"></param>
        /// <returns>A count of how many products were fixed/changed.</returns>
        private int PushProductToShopify(IEnumerable<InventoryItemType> shopsterItems, ConnectsterProductMap productMap,
                                         ShopifyMetafieldMap shopifyMap, IList<int> shopifyIds,
                                         List<ShopifyProduct> shopifyItems, ShopifyStoreAuth storeAuth,
                                         ApiContext apiContext)
        {
            if (shopifyItems == null) throw new ArgumentNullException("shopifyItems");
            int returnCount = 0;
            //All of these are ending up in a Case7 (All good) state.
            foreach (InventoryItemType shopsterItem in shopsterItems)
            {
                InventoryItemType inventoryItem = shopsterItem;
                IList<ConnectsterProduct> mappings = productMap.GetMappedItems()
                    .Where(p => p.SourceId == Convert.ToInt32(inventoryItem.ItemId)).Select(p => p).ToList();
                if (mappings.Count > 0) //Cases 3,7
                {
                    foreach (ConnectsterProduct mapping in mappings)
                    {
                        if (!shopifyIds.Contains(mapping.DestinationId)) //If we have a broken mapping. (Case3)
                        {
                            //if the metafields have a mapping, fix the mapping
                            if (shopifyMap.GetDestinationIds().Contains(Convert.ToInt32(shopsterItem.ItemId)))
                            {
                                //There is a shopifyItem that wants to be linked to this shopsterItem
                                if (shopifyItems.Count > 0)
                                {
                                    ShopifyProduct shopifyItem = shopifyItems
                                        .Where(item => item.Id ==
                                                       shopifyMap.GetSourcesForDestiation(
                                                           Convert.ToInt32(shopsterItem.ItemId)).Take(1).First())
                                        .Select(item => item).First();
                                    if (shopifyItem.Id != null) mapping.DestinationId = (int) shopifyItem.Id;
                                    productMap.AddMapping(mapping); //Add mapping will update if it is already there.
                                    return returnCount;
                                }

                            }
                            else
                            {
                                //upload the product

                                List<InventoryCategoryType> categories =
                                    (shopsterItem.Categories == null || shopsterItem.Categories.Count < 1)
                                        ? new List<InventoryCategoryType>(1)
                                        : new List<InventoryCategoryType>(shopsterItem.Categories.Count);

                                if (shopsterItem.Categories != null)
                                    categories.AddRange(shopsterItem.Categories.Select(categoryId => _shopsterComm.GetCategory(apiContext, categoryId)));

                                ShopifyProduct sP = ShopsterifyConverter.convertItem(shopsterItem, categories);
                                ShopifyResponse<ShopifyProduct> response = _shopifyComm.CreateProduct(storeAuth, sP);
                                if (response.State == ResponseState.OK)
                                {
                                    _metaFieldShopsterProductId.Value = Convert.ToInt32(shopsterItem.ItemId).ToString();
                                    ShopifyResponse<ShopifyMetafield> responseMetafield =
                                        _shopifyComm.CreateMetafield(storeAuth, _metaFieldShopsterProductId,
                                                                    response.ResponseObject.Id);
                                    if (responseMetafield == null) throw new NotImplementedException();

                                    mapping.DestinationId = response.ResponseObject.Id != null
                                                                ? (int) response.ResponseObject.Id
                                                                : 0;
                                    productMap.AddMapping(mapping); //Add mapping will update if it is already there.
                                    returnCount++;
                                }
                            }
                        }
                        else //Case7 update and ensure metafield map is correct.
                        {
                            //Todo enable the below comparison of Sourcedate and DestinationDate
                            //if (mapping.SourceDate > mapping.DestinationDate)

                            if (mapping.DestinationDate < DateTime.UtcNow.AddMinutes(-5))
                            {
                                List<InventoryCategoryType> categories =
                                    (shopsterItem.Categories == null || shopsterItem.Categories.Count < 1)
                                        ? new List<InventoryCategoryType>(1)
                                        : new List<InventoryCategoryType>(shopsterItem.Categories.Count);
                                if (shopsterItem.Categories != null)
                                    categories.AddRange(shopsterItem.Categories.Select(categoryId => _shopsterComm.GetCategory(apiContext, categoryId)));

                                ShopifyProduct shopifyProduct = ShopsterifyConverter.convertItem(shopsterItem,
                                                                                                 categories);

                                shopifyProduct.Id = productMap.GetProductTable()[Convert.ToInt32(shopsterItem.ItemId)];
                                ShopifyVariant[] shopifyVars =
                                    shopifyItems.Where(item => item.Id == shopifyProduct.Id).Select(
                                        item => item.Variants).FirstOrDefault();

                                foreach (ShopifyVariant sV in shopifyProduct.Variants)
                                {
                                    sV.ProductId = shopifyProduct.Id;
                                    if (shopifyVars != null) sV.Id = shopifyVars[0].Id;
                                }

                                ShopifyResponse<ShopifyProduct> response = _shopifyComm.UpdateProduct(storeAuth,
                                                                                                     shopifyProduct);
                                if (response.State == ResponseState.OK)
                                {
                                    //Todo add debug logging that this item was updated correctly
                                    returnCount++;
                                    logger.InfoFormat(
                                        "ConnectsterController:: Updated shopify item({0}) successfully.",
                                        shopifyProduct.Id);

                                    _database.UpdateShopifyProductTimeStamp(response.ResponseObject, DateTime.UtcNow);
                                }
                            }
                            else
                            {
                                logger.InfoFormat("ConnectsterController:: Skipped update due to timestamps.");
                            }
                        }
                    }
                }
                else //Cases 1, 5 -- Product exists, no mappings found, maybe on shopify
                {
                    InventoryItemType inventoryItemType = shopsterItem;
                    IList<ShopifyMetafieldMapping> metaFieldMappings = shopifyMap.GetMappedItems()
                        .Where(map => map.DestinationId == Convert.ToInt32(inventoryItemType.ItemId))
                        .Select(map => map).ToList();

                    if (metaFieldMappings.Count > 0)
                        //There are products on shopify that think they belong to this shopsteritem
                    {
                        //Case 5
                        foreach (ShopifyMetafieldMapping metaFieldMapping in metaFieldMappings)
                        {
                            //rebuild the mapping, this call pushes through to the db.
                            ShopifyMetafieldMapping mapping = metaFieldMapping;
                            InventoryItemType item1 = shopsterItem;
                            productMap.AddMapping(new ConnectsterProduct(shopsterItem, shopifyItems
                                                                                           .Where(
                                                                                               item =>
                                                                                               (item.Id ==
                                                                                                mapping.
                                                                                                    SourceId) &&
                                                                                               (mapping.
                                                                                                    DestinationId ==
                                                                                                Convert.ToInt32(
                                                                                                    item1.ItemId)))
                                                                                           .Select(item => item).Take(1)
                                                                                           .ToList()[0]));
                            returnCount++;
                        }
                    }
                    else //There aren't any products on shopify that belong to this shopsterItem
                    {
                        //Case 1
                        //upload the product
                        List<InventoryCategoryType> categories =
                            (shopsterItem.Categories == null || shopsterItem.Categories.Count < 1)
                                ? new List<InventoryCategoryType>(1)
                                : new List<InventoryCategoryType>(shopsterItem.Categories.Count);

                        if (shopsterItem.Categories != null)
                            categories.AddRange(shopsterItem.Categories.Select(categoryId => _shopsterComm.GetCategory(apiContext, categoryId)));

                        ShopifyProduct sP = ShopsterifyConverter.convertItem(shopsterItem, categories);
                        ShopifyResponse<ShopifyProduct> response = _shopifyComm.CreateProduct(storeAuth, sP);
                        if (response.State == ResponseState.OK)
                        {
                            _metaFieldShopsterProductId.Value = Convert.ToInt32(shopsterItem.ItemId).ToString();
                            ShopifyResponse<ShopifyMetafield> responseMetafield = _shopifyComm.CreateMetafield(
                                storeAuth, _metaFieldShopsterProductId, response.ResponseObject.Id);
                            if (responseMetafield.State == ResponseState.OK)
                            {
                                //create the mapping

                                var mapping = new ConnectsterProduct(shopsterItem, response.ResponseObject);
                                productMap.AddMapping(mapping);
                            }

                            returnCount++;
                        }
                    }
                }
            }

            return returnCount;
        }
        /// <summary>
        /// Deletes completely orphaned ShopifyProducts (one's which are tagged) but not related to an existing shopsteritem or a mapping.
        /// </summary>
        /// <param name="shopsterItems"></param>
        /// <param name="productMap"></param>
        /// <param name="shopifyMapping"></param>
        /// <param name="shopifyAuth"></param>
        /// <returns></returns>
        private int DeleteOrphanedShopifyProducts(IEnumerable<InventoryItemType> shopsterItems,
                                                  ConnectsterProductMap productMap, ShopifyMetafieldMap shopifyMapping,
                                                  ShopifyStoreAuth shopifyAuth)
        {
            //DeleteOrphanedShopifyProducts(productMap, shopifyMapping, user, shopifyAuth)
            List<ShopifyMetafieldMapping> notMappedProductsList = shopifyMapping.GetMappedItems()
                .Where(item => (!productMap.GetDestinationIds().Contains(item.SourceId))).Select(item => item).ToList();

            return notMappedProductsList.Where(notMappedProduct => shopsterItems.Where(item => Convert.ToInt32(item.ItemId) == notMappedProduct.DestinationId).Count() == 0).Count(notMappedProduct => _shopifyComm.DeleteProduct(shopifyAuth, notMappedProduct.SourceId));
        }