public List<ShopifyProduct> GetAllProducts(ShopifyStoreAuth storeAuth)
{
var returnList = new List<ShopifyProduct>(250);
int pageNumber = 1;
while (true)
{
List<ShopifyProduct> tempList = GetPageOfProducts(storeAuth, 250, pageNumber++);
if (tempList != null)
{
returnList = returnList.Union(tempList).ToList();
if (tempList.Count < 250)
{
break;
}
}
}
return returnList;
}
public List<ShopifyOrder> GetListAllOrders(ShopifyStoreAuth storeAuth)
{
List<ShopifyOrder> returnList = null;
XmlDocument responseDoc = ShopifyGet((_protocol + storeAuth.StoreSubDomain + _domain + "/admin/orders.xml"),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken));
if (responseDoc != null)
{
XmlNodeList errors = responseDoc.SelectNodes("//errors/error");
if (errors != null)
if (errors.Count != 0)
{
var sw = new StringWriter();
var xw = new XmlTextWriter(sw);
responseDoc.WriteTo(xw);
Logger.ErrorFormat("ShopifyCommunicator::GetAllOrders(): Shopify returned errors: {0}",
sw);
//for now we fall through and take whatever orders we can.
}
XmlNodeList orders = responseDoc.SelectNodes("//orders/order");
if (orders != null)
{
returnList = new List<ShopifyOrder>(orders.Count);
foreach (XmlNode order in orders)
{
var orderDoc = new XmlDocument();
orderDoc.AppendChild(orderDoc.ImportNode(order, true));
var serializedResponse = new ShopifyResponse<ShopifyOrder>(orderDoc);
if (serializedResponse.State == ResponseState.OK)
{
returnList.Add(serializedResponse.ResponseObject);
}
else
{
XmlNodeList orderId = responseDoc.SelectNodes("//order/id");
if (orderId != null)
{
string id = orderId.Count > 0 ? orderId[0].InnerText : "unknown";
Logger.ErrorFormat(
"ShopifyCommunicator()::GetListAllOrders(): Error deserializing order id={0}.", id);
}
}
}
}
}
return returnList;
}
public ShopifyResponse<ShopifyProduct> CreateProduct(ShopifyStoreAuth storeAuth, IShopifyProduct sP)
{
//We serialize the ShopifyProduct into and XMLDocument, then POST it to shopify.
var xS = new XmlSerializer(typeof (ShopifyProduct));
var memStream = new MemoryStream();
var xDoc = new XmlDocument();
xS.Serialize(memStream, sP);
memStream.Seek(0, SeekOrigin.Begin);
xDoc.Load(memStream);
memStream.Close();
return
new ShopifyResponse<ShopifyProduct>(
ShopifyPutPost((_protocol + storeAuth.StoreSubDomain + _domain + "/admin/products.xml"),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken), xDoc, "POST"));
}
public bool DeleteProduct(ShopifyStoreAuth storeAuth, int? productId)
{
if (productId == null)
{
Logger.WarnFormat("ShopifyCommunicator::DeleteProduct(): Argument productId is null.");
return true;
}
XmlDocument errorDocument =
ShopifyDelete(
_protocol + storeAuth.StoreSubDomain + _domain + "/admin/products/" + productId + ".xml",
HashString(_appAuth.Secret + storeAuth.StoreAuthToken));
if (errorDocument == null) // null == No Errors
{
return true;
}
ApiLogger.ErrorFormat("ShopifyCommunicator::DeleteProduct(): Shopify returned errors: {0}",
errorDocument.InnerText);
return false;
}
public ShopifyResponse<ShopifyProduct> UpdateProduct(ShopifyStoreAuth storeAuth, ShopifyProduct shopifyProduct)
{
if (shopifyProduct == null || shopifyProduct.Id == null)
{
throw new ArgumentNullException(
"shopifyProduct");
}
var xS = new XmlSerializer(typeof (ShopifyProduct));
var memStream = new MemoryStream();
var xDoc = new XmlDocument();
xS.Serialize(memStream, shopifyProduct);
memStream.Seek(0, SeekOrigin.Begin);
xDoc.Load(memStream);
memStream.Close();
XmlDocument productResponse =
ShopifyPutPost(
(_protocol + storeAuth.StoreSubDomain + _domain + "/admin/products/" + shopifyProduct.Id + ".xml"),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken), xDoc, "PUT");
return new ShopifyResponse<ShopifyProduct>(productResponse);
}
private bool DeleteProductAndDeleteMap(ShopifyStoreAuth shopifyAuth, ConnectsterProductMap productMap,
ConnectsterProduct item)
{
//Attempt to delete the shopsterItem from shopify
if (!_shopifyComm.DeleteProduct(shopifyAuth, item.DestinationId))
{
//maybe a communication error, try next time around
//todo: error, logs
return false;
}
//Delete the Mapping
return (productMap.DeleteMapping(item));
}
public ShopifyResponse<ShopifyCollection> GetCollectionByName(ShopifyStoreAuth storeAuth, string name)
{
if (storeAuth == null || string.IsNullOrEmpty(name))
{
Logger.Error(
"ShopifyCommunicator::GetCollectionByName(): storeAuth and name cannot be null. name cannot be empty");
return null;
}
return
new ShopifyResponse<ShopifyCollection>(
ShopifyGet(
(_protocol + storeAuth.StoreSubDomain + _domain + "/admin/custom_collections.xml?name=" +
HttpUtility.UrlEncode(name)),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken)));
}
public ShopifyResponse<ShopifyProduct> GetProduct(ShopifyStoreAuth storeAuth, int productId)
{
if (productId < 0)
{
Logger.ErrorFormat(
"ShopifyCommunicator::GetProduct() was passed a negative productId ({0}), returning null.",
productId);
return null;
}
XmlDocument xDoc =
ShopifyGet(
(_protocol + storeAuth.StoreSubDomain + _domain + "/admin/products/" + productId + ".xml"),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken));
return new ShopifyResponse<ShopifyProduct>(xDoc);
}
//TODO : Make shopsterify user contain apiContext and shopifyAuth objects, then code that takes both a ApiContext and ShopifyStoreAuth can just take a shopsterifyUser
private bool CreateProductAndMap(ApiContext apiContext, ShopifyStoreAuth shopifyAuth,
InventoryItemType shopsterItem, ShopifyMetafieldMap shopifyMapping)
{
//Steps are: Upload Item to Shopify, Create metafield, Update map according to new productId
//Upload to shopify
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)));
//get the categories for this item
ShopifyResponse<ShopifyProduct> response = _shopifyComm.CreateProduct(shopifyAuth,
ShopsterifyConverter.convertItem(
shopsterItem, categories));
if (response.State == ResponseState.OK)
{
_metaFieldShopsterProductId.Value = shopsterItem.ItemId;
if (response.ResponseObject.Id != null)
{
if (response.ResponseObject.Created != null)
{
ShopifyMetafieldMapping newMap =
ShopifyMetafieldMapping.CreateMetafieldMapping((int) response.ResponseObject.Id,
(DateTime) response.ResponseObject.Created,
_metaFieldShopsterProductId);
//Update map (add mapping will create/update the ShopifyMetafield on shopify)
if (shopifyMapping.AddMapping(newMap))
{
#if DEBUG
logger.DebugFormat(
"ConnectsterController::CreateProductAndMap(): CreatedProduct({0}) and mapping on Shopify.",
response.ResponseObject.Id);
#endif
return true;
}
}
}
}
#if DEBUG
logger.DebugFormat(
"ConnectsterController::CreateProductAndMap(): attempted to create mapping and failed. ShopsterToken({0}), ShopifySubdomain({1}, shopsterItemId({2})",
apiContext.AccessToken, shopifyAuth.StoreSubDomain, shopsterItem.ItemId);
#endif
return false;
}
public ShopifyResponse<ShopifyCollection> CreateCollection(ShopifyStoreAuth storeAuth,
ShopifyCollection collection)
{
if (storeAuth == null || collection == null)
{
Logger.Error("ShopifyCommunicator::CreateCollection(): storeAuth and collection cannot be null.");
return null;
}
var xS = new XmlSerializer(typeof (ShopifyCollection));
var memStream = new MemoryStream();
var xDoc = new XmlDocument();
xS.Serialize(memStream, collection);
memStream.Seek(0, SeekOrigin.Begin);
xDoc.Load(memStream);
memStream.Close();
return
new ShopifyResponse<ShopifyCollection>(
ShopifyPutPost((_protocol + storeAuth.StoreSubDomain + _domain + "/admin/custom_collections.xml"),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken), xDoc, "POST"));
}
public ConnectsterUser GetUser(ApiContext apiContext, ShopifyStoreAuth shopifyAuth)
{
return _database.SelectConnectsterUser(apiContext, shopifyAuth);
}
/// <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;
}
//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;
}
public ShopifyResponse<ShopifyOrder> GetOrder(ShopifyStoreAuth storeAuth, int orderId)
{
//Ensure the orderID makes sense
if (orderId < 0)
{
Logger.Warn("ShopifyCommunicator::GetOrder(): Was passed orderId<0, returning null");
return null;
}
//Retrieve the order from shopify
XmlDocument retrievedOrder =
ShopifyGet(
(_protocol + storeAuth.StoreSubDomain + _domain + "/admin/orders/" + orderId + ".xml"),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken));
//Create e responseObject out of the response.
return new ShopifyResponse<ShopifyOrder>(retrievedOrder);
}
public ShopifyResponse<ShopifyCollection> GetCollection(ShopifyStoreAuth storeAuth, int collectionId)
{
if (storeAuth == null || collectionId <= 0)
{
Logger.Error(
"ShopifyCommunicator::GetCollection(): storeAuth cannot be null and collectionId must be >0");
return null;
}
return
new ShopifyResponse<ShopifyCollection>(
ShopifyGet(
(string.Format("{0}{1}{2}/admin/custom_collections/{3}.xml", _protocol, storeAuth.StoreSubDomain,
_domain, collectionId)),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken)));
}
public List<ShopifyProduct> GetPageOfProducts(ShopifyStoreAuth storeAuth, int numWanted, int pageNumber)
{
if (storeAuth == null)
{
Logger.Warn("ShopifyCommunicator::GetPageOfProducts: storeAuth cannot be null");
return null;
}
if (!(numWanted > 0 && numWanted < 251 && pageNumber > 0))
{
Logger.WarnFormat(
"ShopifyCommunicator::GetPageOfProducts(): numWanted({0}) must be between 0 and 251, pageNumber({1}) must be >0.",
numWanted, pageNumber);
return null;
}
var url = new StringBuilder();
url.Append(_protocol);
url.Append(storeAuth.StoreSubDomain);
url.Append(_domain);
url.Append("/admin/products.xml?");
url.Append("limit=" + numWanted);
url.Append("&page=" + pageNumber);
XmlDocument xDoc = ShopifyGet(url.ToString(), HashString(_appAuth.Secret + storeAuth.StoreAuthToken));
//Now the fun part of parsing this xml.
if (xDoc == null)
{
return null;
}
XmlNodeList productNodeList = xDoc.SelectNodes("//products/product");
var returnList = new List<ShopifyProduct>();
// Foreach product found, serialize and add to return list
if (productNodeList != null)
foreach (XmlNode productNode in productNodeList)
{
var productDoc = new XmlDocument();
productDoc.AppendChild(productDoc.ImportNode(productNode, true));
var serializedResponse = new ShopifyResponse<ShopifyProduct>(productDoc);
if (serializedResponse.State == ResponseState.OK)
{
returnList.Add(serializedResponse.ResponseObject);
}
else
{
XmlNodeList idNode = productNode.SelectNodes("//id");
if (idNode != null)
{
string productId = idNode.Count > 0 ? idNode[0].InnerText : "null";
Logger.ErrorFormat(
"ShopifyCommunicator()::GetPageOfProducts(): Couldn't parse product ({0}) returned in page of product.",
productId);
}
}
}
return returnList;
}
/// <summary>
///
/// </summary>
/// <param name="storeAuth"></param>
/// <param name="limit"></param>
/// <param name="createdMin"></param>
/// <param name="createdMax"></param>
/// <param name="updatedMin"></param>
/// <param name="updatedMax"></param>
/// <param name="fieldNamespace"></param>
/// <param name="key"></param>
/// <param name="valueType"></param>
/// <param name="productId">If productId is >0 get all metafields for that product, if null get metafields tagged to the shop. </param>
/// <exception cref="ArgumentNullException"></exception>
/// <returns></returns>
public List<ShopifyMetafield> GetAllMetafields(ShopifyStoreAuth storeAuth, int? limit,
DateTime? createdMin, DateTime? createdMax, DateTime? updatedMin,
DateTime? updatedMax,
string fieldNamespace, string key, string valueType,
int? productId)
{
//Todo: Should we make this take a "dictionary" and then simply do "foreach key in dictionary"
if (!(valueType == "string" || valueType == "integer"))
{
throw new ArgumentException("valueType can only be 'string' or 'integer'");
}
if (limit > 250 || limit < 0)
{
throw new ArgumentException("limit must be between 1 and 250 inclusive");
}
if (storeAuth == null)
{
throw new ArgumentNullException("storeAuth");
}
if (productId == null && productId < 1)
{
throw new ArgumentException("productId must be >0");
}
List<ShopifyMetafield> returnList = limit != null
? new List<ShopifyMetafield>((int) limit)
: new List<ShopifyMetafield>();
var sbUrl = new StringBuilder();
sbUrl.Append(_protocol + storeAuth.StoreSubDomain + _domain + "/admin/");
if (productId != null)
{
sbUrl.Append("products/" + productId + "/");
}
sbUrl.Append("metafields.xml?");
//Append each of the filter terms.
if (limit != null)
{
sbUrl.Append("limit=" + limit);
}
if (createdMin != null)
{
sbUrl.Append("&created_at_min=" + HttpUtility.UrlEncode(DateTimeToShopifyString((DateTime) createdMin)));
}
if (createdMax != null)
{
sbUrl.Append("&created_at_max=" + HttpUtility.UrlEncode(DateTimeToShopifyString((DateTime) createdMax)));
}
if (updatedMin != null)
{
sbUrl.Append("&updated_at_min=" + HttpUtility.UrlEncode(DateTimeToShopifyString((DateTime) updatedMin)));
}
if (updatedMax != null)
{
sbUrl.Append("&updated_at_max=" + HttpUtility.UrlEncode(DateTimeToShopifyString((DateTime) updatedMax)));
}
if (!string.IsNullOrEmpty(key))
{
sbUrl.Append("&key=" + HttpUtility.UrlEncode(key));
}
if (!string.IsNullOrEmpty(fieldNamespace))
{
sbUrl.Append("&namespace=" + HttpUtility.UrlEncode(fieldNamespace));
}
if (valueType != string.Empty)
{
sbUrl.Append("&value_type=" + HttpUtility.UrlEncode(valueType));
}
XmlDocument xDoc = ShopifyGet(sbUrl.ToString().Replace("?&", "?"),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken));
if (xDoc == null)
{
//ShopifyGet should be logging/reporting the error
return null;
}
XmlNodeList metaFields = xDoc.SelectNodes("//metafields/metafield");
if (metaFields != null)
foreach (XmlNode metaField in metaFields)
{
var metaFieldDoc = new XmlDocument();
metaFieldDoc.AppendChild(metaFieldDoc.ImportNode(metaField, true));
var serializedResponse =
new ShopifyResponse<ShopifyMetafield>(metaFieldDoc);
if (serializedResponse.State == ResponseState.OK)
{
returnList.Add(serializedResponse.ResponseObject);
}
else
{
//Log this error, ignore this metafield and continue with call so we can return the properly formatted metafields
XmlNodeList idNode = metaField.SelectNodes("//id");
if (idNode != null)
{
string metafieldId = idNode.Count > 0 ? idNode[0].InnerText : "null";
Logger.ErrorFormat(
"ShopifyCommunicator()::GetAllMetafields(): Couldn't parse metafield ({0}) returned in page of metafields.",
metafieldId);
}
}
}
return returnList;
}
public ShopifyResponse<ShopifyShop> GetShopInformation(ShopifyStoreAuth storeAuth)
{
XmlDocument retrievedShop = ShopifyGet((_protocol + storeAuth.StoreSubDomain + _domain + "/admin/shop.xml"),
HashString(_appAuth.Secret + storeAuth.StoreAuthToken));
return new ShopifyResponse<ShopifyShop>(retrievedShop);
}
public ShopifyResponse<ShopifyMetafield> CreateMetafield(ShopifyStoreAuth storeAuth, ShopifyMetafield metaField,
int? productId)
{
if (storeAuth == null || metaField == null)
{
Logger.WarnFormat("ShopifyCommunicator::CreateMetafield():storeAuth and metaField cannot be null");
return null;
}
if (productId != null && productId < 1)
//Product ID can be null if the metafield is tagged to the store itself (vs. tagged to a product).
{
Logger.ErrorFormat("ShopifyCommunicator::CreateMetafield(): productId must be >=1 if non-null.");
return null;
}
//Build our url depending on if this metafield will apply to e product or e shop
var url = new StringBuilder();
url.Append(_protocol + storeAuth.StoreSubDomain + _domain + "/admin/");
if (productId != null)
{
url.Append("products/" + productId + "/");
}
url.Append("metafields.xml");
var xS = new XmlSerializer(typeof (ShopifyMetafield));
var memStream = new MemoryStream();
var xDoc = new XmlDocument();
xS.Serialize(memStream, metaField);
memStream.Seek(0, SeekOrigin.Begin);
xDoc.Load(memStream);
memStream.Close();
return new ShopifyResponse<ShopifyMetafield>(ShopifyPutPost(url.ToString(),
HashString(_appAuth.Secret +
storeAuth.StoreAuthToken), xDoc,
"POST"));
}
public ConnectsterUser SelectConnectsterUser(ApiContext apiContext, ShopifyStoreAuth shopifyAuth)
{
if (apiContext == null || shopifyAuth == null)
{
Logger.ErrorFormat("SelectConnectsterUser(): Was given null apiContext or ShopifyAuth");
throw new ArgumentException("Neither arguments can be null");
}
string query = String.Format(
@" SELECT shopsterU.id as ShopsterUserId, shopifyU.subdomain as ShopifyUserId, smap.sleepUntil
FROM shopifyUser shopifyU JOIN connectsterusermap smap ON shopifyU.subdomain = smap.ShopifySubdomain
JOIN shopsteruser shopsterU ON shopsterU.id = smap.ShopsterUserId
WHERE shopsterU.AuthToken = '{0}' AND
shopsterU.AuthSecret = '{1}' AND
shopifyU.subDomain = '{2}' AND
shopifyU.AuthToken = '{3}' LIMIT 1;",
apiContext.AccessToken,
apiContext.AccessTokenSecret,
shopifyAuth.StoreSubDomain,
shopifyAuth.StoreAuthToken);
var sqlCommand = new MySqlCommand(query, _dbConn);
using (var sqlResult = sqlCommand.ExecuteReader())
{
while (sqlResult.Read()) //We return the first read.
{
try //Try to do Convert.ToInt32
{
return new ConnectsterUser(Convert.ToInt32(sqlResult[0]), (string) sqlResult[1]);
}
catch (FormatException e)
{
Logger.DebugFormat(
"SelectConnectsterUser(): FormatException for returned userId({0}). Exception Message is {1}",
sqlResult[0], e.Message);
continue; //Just abandon this user and move on.
}
catch (OverflowException e)
{
Logger.DebugFormat(
"SelectConnectsterUser(): OverflowException for returned userId({0}). Exception Message is {1}",
sqlResult[0], e.Message);
continue;
}
}
}
//User not found.
return null;
}
/// <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));
}
