public GetEntityResult<ExternalActivityViewModel> DownLoadExternalOrders(OrderSearchOptions orderSearchOptions)
{
GetEntityResult<ExternalActivityViewModel> externalActivityResult = new GetEntityResult<ExternalActivityViewModel>() { Success = false };
ExternalOrderResult orderResult = null;
orderSearchOptions.ToDate = DateTime.Now;
orderResult = new ExternalOrderClient().GetUnshippedOrders(orderSearchOptions);
if (orderResult.Success)
{
EntityOperationResultBase saveResult = SaveExternalOrder(orderResult.Orders);
}
else
{
externalActivityResult.ErrorMessage = "Error occurred while retrieving orders for " + orderSearchOptions.StoreProvider.ToString();
return externalActivityResult;
}
ExternalActivityViewModel activity = new ExternalActivityViewModel()
{
ActivityStatus = ExternalActivityStatus.Completed,
ExternalActivityType = ExternalActivityTypeEnum.GetUnshippedOrders,
StoreProviderType = orderSearchOptions.StoreProvider,
LastPerformedOn = orderSearchOptions.ToDate,
};
try
{
UpdateResult<ExternalActivity> externalActivityUpdateResult = UpdateExternalActivityDetails(activity);
GetEntityResult<ExternalActivityViewModel> result = GetLastExternalActivityDetails(ExternalActivityTypeEnum.GetUnshippedOrders, orderSearchOptions.StoreProvider);
externalActivityResult.Success = result.Success;
externalActivityResult.Entity = result.Entity;
}
catch (Exception ex)
{
externalActivityResult.Success = false;
externalActivityResult.ErrorMessage = "Error occurred while update activity details. Please refresh the page";
}
return externalActivityResult;
}
public HttpResponseMessage GetCategorySubCategoryMap(HttpRequestMessage request, Guid categoryId, Guid subCategoryId)
{
GetEntityResult<CategorySubCategoryMapViewModel> entityResult = new GetEntityResult<CategorySubCategoryMapViewModel>();
return GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
entityResult = subCategoryActivity.GetCategorySubCategoryMap(categoryId, subCategoryId);
response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new ObjectContent<GetEntityResult<CategorySubCategoryMapViewModel>>(entityResult, Configuration.Formatters.JsonFormatter);
return response;
});
}
public IHttpActionResult GetExternalActivityDetails(HttpRequestMessage request, int storeProvider, int activityType)
{
GetEntityResult<ExternalActivityViewModel> activityResult = new GetEntityResult<ExternalActivityViewModel>();
try
{
activityResult = externalOrderActivity.GetLastExternalActivityDetails((ExternalActivityTypeEnum)activityType,
(StoreProviderTypeEnum)storeProvider);
}
catch (Exception ex)
{
activityResult.Success = false;
activityResult.ErrorMessage = "Error while trying to retrieve Order Activity details " + ex.Message;
}
return Ok(activityResult);
}
public GetEntityResult<PurchaseOrderViewModel> GetPurchaseOrder(Guid purchaseOrderId)
{
GetEntityResult<PurchaseOrderViewModel> purchaseOrderResult = new GetEntityResult<PurchaseOrderViewModel>
{
Success = false,
};
using (InnoventoryDBContext dbContext = new InnoventoryDBContext())
{
purchaseOrderResult = purchaseOrderRepository.FindById(dbContext, purchaseOrderId);
if (!purchaseOrderResult.Success || purchaseOrderResult.Entity == null)
{
return purchaseOrderResult;
}
PurchaseOrderViewModel purchaseOrder = purchaseOrderResult.Entity;
purchaseOrderResult.Entity.PurchaseOrderItems = new List<PurchaseOrderItemViewModel>();
FindResult<PurchaseOrderItemViewModel> purchaseOrderItemsResult = purchaseOrderItemRepository.FindBy(dbContext, x => x.PurchaseOrderId == purchaseOrder.PurchaseOrderId);
if (!purchaseOrderItemsResult.Success || purchaseOrderItemsResult.Entities.Count == 0)
{
return purchaseOrderResult;
}
purchaseOrderResult.Entity.PurchaseOrderItems = purchaseOrderItemsResult.Entities;
purchaseOrderResult.Success = true;
}
return purchaseOrderResult;
}
public GetEntityResult<ViewModels.SalesOrderViewModel> GetSalesOrder(Guid salesOrderId)
{
GetEntityResult<SalesOrderViewModel> salesOrderResult = new GetEntityResult<SalesOrderViewModel>
{
Success = false,
};
using (InnoventoryDBContext dbContext = new InnoventoryDBContext())
{
salesOrderResult = salesOrderRepository.FindById(dbContext, salesOrderId);
if (!salesOrderResult.Success || salesOrderResult.Entity == null)
{
return salesOrderResult;
}
SalesOrderViewModel salesOrder = salesOrderResult.Entity;
salesOrderResult.Entity.SaleOrderItems = new List<SalesOrderItemViewModel>();
FindResult<SalesOrderItemViewModel> salesOrderItemsResult = salesOrderItemRepository.FindBy(dbContext, x => x.SalesOrderId == salesOrder.SalesOrderId);
if (!salesOrderItemsResult.Success || salesOrderItemsResult.Entities.Count == 0)
{
return salesOrderResult;
}
salesOrderResult.Entity.SaleOrderItems = salesOrderItemsResult.Entities;
salesOrderResult.Success = true;
}
return salesOrderResult;
}
public GetEntityResult<CategorySubCategoryMapViewModel> GetCategorySubCategoryMap(Guid categoryId, Guid subCategoryId)
{
FindResult<CategorySubCategoryMapViewModel> findResult = new FindResult<CategorySubCategoryMapViewModel>();
findResult = categorySubCategoryMapRepo.FindBy(x => x.CategoryId == categoryId && x.SubCategoryId == subCategoryId);
GetEntityResult<CategorySubCategoryMapViewModel> result = new GetEntityResult<CategorySubCategoryMapViewModel>();
if (findResult.Success)
{
result.Entity = findResult.Entities.FirstOrDefault();
result.Success = true;
}
else
{
result.Success = false;
result.Entity = null;
}
return result;
}
public HttpResponseMessage GetSubCategory(HttpRequestMessage request, Guid id)
{
return GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
SubCategoryCategories subCategory = subCategoryActivity.GetSubCategoryCategories(id);
GetEntityResult<SubCategoryCategories> result = new GetEntityResult<SubCategoryCategories>
{
Entity = subCategory,
ErrorMessage = string.Empty,
Success = true,
SuccessMessage = string.Empty
};
response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new ObjectContent<GetEntityResult<SubCategoryCategories>>(result, Configuration.Formatters.JsonFormatter);
return response;
});
}
public GetEntityResult<ExternalActivityViewModel> GetLastExternalActivityDetails(ExternalActivityTypeEnum activityType, StoreProviderTypeEnum storeProvider)
{
GetEntityResult<ExternalActivityViewModel> externalActivityResult = new GetEntityResult<ExternalActivityViewModel>() { Success = false };
using (InnoventoryDBContext dbContext = new InnoventoryDBContext())
{
DbSet<ExternalActivity> externalActivitySet = dbContext.ExternalActivitySet;
List<ExternalActivity> externalActivities = externalActivitySet.Where(x => x.ExternalActivityType == (int)activityType
&& x.StoreProviderType == (int)storeProvider).ToList();
if (externalActivities.Count == 0)
{
externalActivityResult.Entity = null;
externalActivityResult.Success = true;
externalActivityResult.SuccessMessage = "No activity found...";
}
else
{
externalActivities = externalActivities.OrderByDescending(x => x.LastPerformedOn).ToList();
ExternalActivity activity = externalActivities.FirstOrDefault();
ExternalActivityViewModel activityViewModel = new ExternalActivityViewModel()
{
ActivityStatus = (ExternalActivityStatus)activity.ActivityStatus,
ExternalActivityType = (ExternalActivityTypeEnum)activity.ExternalActivityType,
LastPerformedOn = activity.LastPerformedOn,
StoreProviderType = (StoreProviderTypeEnum)activity.StoreProviderType,
};
int unshippedCount = dbContext.ExternalOrderSet.Where(x => x.StoreOrderStatus == StoreOrderStatusEnum.Unshipped.ToString()
&& x.StoreProviderId == (int)storeProvider).Count();
activityViewModel.UnshippedOrdersCount = unshippedCount;
externalActivityResult.Entity = activityViewModel;
externalActivityResult.Success = true;
}
}
return externalActivityResult;
}
public IHttpActionResult SyncUnshippedOrders(HttpRequestMessage request, [FromBody]OrderSearchOptions orderOptions)
{
GetEntityResult<ExternalActivityViewModel> result = new GetEntityResult<ExternalActivityViewModel>();
try
{
IExternalOrderActivity orderActivity = new ExternalOrderActivity();
result = orderActivity.DownLoadExternalOrders(orderOptions);
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.Message;
}
return Ok(result);
}
public GetEntityResult<ProductViewModel> GetProduct(Guid productId)
{
GetEntityResult<ProductViewModel> entityResult = new GetEntityResult<ProductViewModel>();
using (InnoventoryDBContext dbContext = new InnoventoryDBContext())
{
GetEntityResult<ProductViewModel> productResult = productRepository.FindById(dbContext, productId);
if (!productResult.Success)
{
return productResult;
}
var product = productResult.Entity;
var categorySubCategoryMap = from cscmap in dbContext.CategorySubCategoryMapSet
join c in dbContext.CategorySet on cscmap.CategoryId equals c.CategoryId
join sc in dbContext.SubCategorySet
on cscmap.SubCategoryId equals sc.SubCategoryId
where (cscmap.CategorySubCategoryMapId == product.CategorySubCategoryMapId)
select new CategorySubCategoryMapViewModel
{
Category = new CategoryViewModel
{
CategoryId = c.CategoryId,
CategoryName = c.CategoryName,
Description = c.Description,
},
CategoryId = c.CategoryId,
CategorySubCategoryMapId = product.CategorySubCategoryMapId,
SubCategory = new SubCategoryViewModel
{
Description = sc.Description,
SubCategoryId = sc.SubCategoryId,
SubCategoryName = sc.SubCategoryName,
},
SubCategoryId = sc.SubCategoryId
};
product.CategorySubCategoryMap = categorySubCategoryMap.FirstOrDefault();
//if (categorySubCategoryMap != null)
//{
// var category = dbContext.CategorySet.Where(x => x.CategoryId == categorySubCategoryMap.CategoryId).FirstOrDefault();
// if (category != null)
// {
// product.CategoryId = category.CategoryId;
// product.CategoryName = category.CategoryName;
// }
// var subCategory = dbContext.SubCategorySet.Where(x => x.SubCategoryId == categorySubCategoryMap.SubCategoryId).FirstOrDefault();
// if (subCategory != null)
// {
// product.SubCategoryId = subCategory.SubCategoryId;
// product.SubCategoryName = subCategory.SubCategoryName;
// }
//}
FindResult<ProductVariantViewModel> findProductVriantResult = productVariantRepository.FindBy(dbContext, x => x.ProductId == productId);
if (!findProductVriantResult.Success)
{
entityResult.Success = false;
entityResult.ErrorMessage = findProductVriantResult.ErrorMessage;
return entityResult;
}
List<ProductVariantViewModel> productVariants = findProductVriantResult.Entities;
product.ProductVariants = productVariants;
long categoryAttributeCount = 0;
FindResult<SubCategoryAttributeMapViewModel> subCatAttribMapResult = subCategoryAttributeMapRepository
.FindBy(dbContext, x => x.SubCategoryId == product.CategorySubCategoryMap.SubCategoryId);
if (subCatAttribMapResult.Success && subCatAttribMapResult.Count > 0)
{
categoryAttributeCount = subCatAttribMapResult.Count;
}
if (product.ProductVariants != null && product.ProductVariants.Count > 0)
{
foreach (ProductVariantViewModel pvm in product.ProductVariants)
{
pvm.ProductVariantAttributeValues = (from pv in dbContext.ProductVariantAttributeValueSet
join avl in dbContext.AttributeValueListSet on pv.AttributeValueListId equals avl.AttributeValueListId
join subcatAttrMap in dbContext.SubCategoryAttributeMapSet
on avl.SubCategoryAttributeMapID equals subcatAttrMap.SubCategoryAttributeMapId
join productAttributs in dbContext.ProductAttributeSet
on subcatAttrMap.ProductAttributeId equals productAttributs.ProductAttributeId
where pv.ProductVariantId == pvm.ProductVariantId
select new ProductVariantAttributeValueViewModel
{
ProductVariantId = pv.ProductVariantId,
AttributeValueListId = avl.AttributeValueListId,
ProductAttributeName = productAttributs.AttributeName,
ProductAttributeValue = avl.AttributeValue,
ProductAttributeId = productAttributs.ProductAttributeId,
}).ToList();
}
}
FindResult<ProductVariantListItem> pvResult = GetAllProductVariantListItems(product.ProductId);
if (pvResult.Success)
{
product.ProductVariantListItems = pvResult.Entities;
}
entityResult.Entity = product;
entityResult.Success = true;
}
return entityResult;
}
