public SingleResult <Order> AddShipment(int key, ODataActionParameters parameters)
{
var result = GetSingleResult(key);
var order = GetExpandedEntity(key, result, "OrderItems, OrderItems.Product, Shipments, Shipments.ShipmentItems");
this.ProcessEntity(() =>
{
if (order.CanAddItemsToShipment())
{
var trackingNumber = parameters.GetValueSafe <string>("TrackingNumber");
var trackingUrl = parameters.GetValueSafe <string>("TrackingUrl");
var shipment = _orderProcessingService.Value.AddShipment(order, trackingNumber, trackingUrl, null);
if (shipment != null)
{
if (parameters.GetValueSafe <bool>("SetAsShipped"))
{
_orderProcessingService.Value.Ship(shipment, true);
}
}
}
});
return(result);
}
public IHttpActionResult CopyFile(int key, ODataActionParameters parameters)
{
MediaFileOperationResult opResult = null;
this.ProcessEntity(() =>
{
var file = Service.GetFileById(key);
if (file == null)
{
throw Request.NotFoundException(WebApiGlobal.Error.EntityNotFound.FormatInvariant(key));
}
var destinationFileName = parameters.GetValueSafe <string>("DestinationFileName");
var duplicateFileHandling = parameters.GetValueSafe("DuplicateFileHandling", DuplicateFileHandling.ThrowError);
var result = Service.CopyFile(file, destinationFileName, duplicateFileHandling);
opResult = new MediaFileOperationResult
{
DestinationFileId = result.DestinationFile.Id,
//DestinationFile = Convert(result.DestinationFile),
IsDuplicate = result.IsDuplicate,
UniquePath = result.UniquePath
};
});
return(Ok(opResult));
}
public IHttpActionResult CopyFolder(ODataActionParameters parameters)
{
MediaFolderOperationResult opResult = null;
this.ProcessEntity(() =>
{
var path = parameters.GetValueSafe <string>("Path");
var destinationPath = parameters.GetValueSafe <string>("DestinationPath");
var duplicateEntryHandling = parameters.GetValueSafe("DuplicateEntryHandling", DuplicateEntryHandling.Skip);
var result = _mediaService.CopyFolder(path, destinationPath, duplicateEntryHandling);
opResult = new MediaFolderOperationResult
{
FolderId = result.Folder.Id,
//Folder = Convert(result.Folder)
};
opResult.DuplicateFiles = result.DuplicateFiles
.Select(x => new MediaFolderOperationResult.DuplicateFileInfo
{
SourceFileId = x.SourceFile.Id,
DestinationFileId = x.DestinationFile.Id,
//SourceFile = Convert(x.SourceFile),
//DestinationFile = Convert(x.DestinationFile),
UniquePath = x.UniquePath
})
.ToList();
});
return(Ok(opResult));
}
public IHttpActionResult MoveFolder(ODataActionParameters parameters)
{
FolderNodeInfo movedFolder = null;
this.ProcessEntity(() =>
{
var path = parameters.GetValueSafe <string>("Path");
var destinationPath = parameters.GetValueSafe <string>("DestinationPath");
var result = _mediaService.MoveFolder(path, destinationPath);
movedFolder = Convert(result.Node, false)?.FirstOrDefault();
});
return(Ok(movedFolder));
}
public SingleResult <Order> PaymentRefund(int key, ODataActionParameters parameters)
{
var result = GetSingleResult(key);
var order = GetExpandedEntity(key, result, null);
this.ProcessEntity(() =>
{
var online = parameters.GetValueSafe <bool>("Online");
if (online)
{
var errors = _orderProcessingService.Value.Refund(order);
if (errors.Count > 0)
{
throw new SmartException(errors[0]);
}
}
else
{
_orderProcessingService.Value.RefundOffline(order);
}
});
return(result);
}
public IHttpActionResult CountFilesGrouped(ODataActionParameters parameters)
{
MediaCountResult result = null;
this.ProcessEntity(() =>
{
var query = parameters.GetValueSafe <MediaFilesFilter>("Filter");
var res = Service.CountFilesGrouped(query ?? new MediaFilesFilter());
result = new MediaCountResult
{
Total = res.Total,
Trash = res.Trash,
Unassigned = res.Unassigned,
Transient = res.Transient,
Orphan = res.Orphan
};
result.Folders = res.Folders
.Select(x => new MediaCountResult.FolderCount
{
FolderId = x.Key,
Count = x.Value
})
.ToList();
});
return(Ok(result));
}
public IHttpActionResult DeleteFile(int key, ODataActionParameters parameters)
{
this.ProcessEntity(() =>
{
var file = Service.GetFileById(key);
if (file == null)
{
throw Request.NotFoundException(WebApiGlobal.Error.EntityNotFound.FormatInvariant(key));
}
var permanent = parameters.GetValueSafe <bool>("Permanent");
var force = parameters.GetValueSafe("Force", false);
Service.DeleteFile(file.File, permanent, force);
});
return(StatusCode(HttpStatusCode.NoContent));
}
public IHttpActionResult DeleteFolder(ODataActionParameters parameters)
{
MediaFolderDeleteResult opResult = null;
this.ProcessEntity(() =>
{
var path = parameters.GetValueSafe <string>("Path");
var fileHandling = parameters.GetValueSafe("FileHandling", FileHandling.SoftDelete);
var result = _mediaService.DeleteFolder(path, fileHandling);
opResult = new MediaFolderDeleteResult
{
DeletedFileNames = result.DeletedFileNames,
DeletedFolderIds = result.DeletedFolderIds
};
});
return(Ok(opResult));
}
public async Task <IHttpActionResult> CountFiles(ODataActionParameters parameters)
{
var count = 0;
await this.ProcessEntityAsync(async() =>
{
var query = parameters.GetValueSafe <MediaSearchQuery>("Query");
count = await Service.CountFilesAsync(query ?? new MediaSearchQuery());
});
return(Ok(count));
}
public IHttpActionResult MoveFile(int key, ODataActionParameters parameters)
{
FileItemInfo movedFile = null;
this.ProcessEntity(() =>
{
var file = Service.GetFileById(key);
if (file == null)
{
throw Request.NotFoundException(WebApiGlobal.Error.EntityNotFound.FormatInvariant(key));
}
var destinationFileName = parameters.GetValueSafe <string>("DestinationFileName");
var duplicateFileHandling = parameters.GetValueSafe("DuplicateFileHandling", DuplicateFileHandling.ThrowError);
var result = Service.MoveFile(file.File, destinationFileName, duplicateFileHandling);
movedFile = Convert(result);
});
return(Ok(movedFile));
}
public IHttpActionResult FileExists(ODataActionParameters parameters)
{
var fileExists = false;
this.ProcessEntity(() =>
{
var path = parameters.GetValueSafe <string>("Path");
fileExists = Service.FileExists(path);
});
return(Ok(fileExists));
}
public IHttpActionResult GetFileByPath(ODataActionParameters parameters)
{
FileItemInfo file = null;
this.ProcessEntity(() =>
{
var path = parameters.GetValueSafe <string>("Path");
var result = Service.GetFileByPath(path, _defaultLoadFlags);
file = Convert(result);
});
return(Ok(file));
}
public IHttpActionResult CheckUniqueFileName(ODataActionParameters parameters)
{
var result = new CheckUniquenessResult();
this.ProcessEntity(() =>
{
var path = parameters.GetValueSafe <string>("Path");
result.Result = Service.CheckUniqueFileName(path, out string newPath);
result.NewPath = newPath;
});
return(Ok(result));
}
public IHttpActionResult CreateFolder(ODataActionParameters parameters)
{
FolderNodeInfo newFolder = null;
this.ProcessEntity(() =>
{
var path = parameters.GetValueSafe <string>("Path");
var result = _mediaService.CreateFolder(path);
newFolder = Convert(result.Node, false)?.FirstOrDefault();
});
return(Created(newFolder));
}
public IHttpActionResult GetNodeByPath(ODataActionParameters parameters)
{
List <FolderNodeInfo> result = null;
this.ProcessEntity(() =>
{
var path = parameters.GetValueSafe <string>("Path");
var node = Service.GetNodeByPath(path);
result = Convert(node);
});
return(Ok(result));
}
public IHttpActionResult AddShipment(int key, ODataActionParameters parameters)
{
var order = GetByKeyNotNull(key);
this.ProcessEntity(() =>
{
if (order.CanAddItemsToShipment())
{
var trackingNumber = parameters.GetValueSafe <string>("TrackingNumber");
var trackingUrl = parameters.GetValueSafe <string>("TrackingUrl");
var shipment = _orderProcessingService.Value.AddShipment(order, trackingNumber, trackingUrl, null);
if (shipment != null)
{
if (parameters.GetValueSafe <bool>("SetAsShipped"))
{
_orderProcessingService.Value.Ship(shipment, true);
}
}
}
});
return(Ok(order));
}
public async Task <IHttpActionResult> SearchFiles(ODataActionParameters parameters)
{
MediaSearchResult result = null;
await this.ProcessEntityAsync(async() =>
{
var maxTop = WebApiCachingControllingData.Data().MaxTop;
var query = parameters.GetValueSafe <MediaSearchQuery>("Query") ?? new MediaSearchQuery {
PageSize = maxTop
};
query.PageSize = Math.Min(query.PageSize, maxTop);
result = await Service.SearchFilesAsync(query, _defaultLoadFlags);
});
return(Ok(result.Select(x => Convert(x)).AsQueryable()));
}
public IHttpActionResult PaymentPaid(int key, ODataActionParameters parameters)
{
var order = GetByKeyNotNull(key);
this.ProcessEntity(() =>
{
var paymentMethodName = parameters.GetValueSafe <string>("PaymentMethodName");
if (paymentMethodName != null)
{
order.PaymentMethodSystemName = paymentMethodName;
Service.UpdateOrder(order);
}
_orderProcessingService.Value.MarkOrderAsPaid(order);
});
return(Ok(order));
}
public SingleResult <Order> PaymentPaid(int key, ODataActionParameters parameters)
{
var result = GetSingleResult(key);
var order = GetExpandedEntity(key, result, null);
this.ProcessEntity(() =>
{
var paymentMethodName = parameters.GetValueSafe <string>("PaymentMethodName");
if (paymentMethodName != null)
{
order.PaymentMethodSystemName = paymentMethodName;
Service.UpdateOrder(order);
}
_orderProcessingService.Value.MarkOrderAsPaid(order);
});
return(result);
}
public IHttpActionResult PaymentRefund(int key, ODataActionParameters parameters)
{
var order = GetByKeyNotNull(key);
this.ProcessEntity(() =>
{
var online = parameters.GetValueSafe <bool>("Online");
if (online)
{
var errors = _orderProcessingService.Value.Refund(order);
if (errors.Count > 0)
{
throw new SmartException(errors[0]);
}
}
else
{
_orderProcessingService.Value.RefundOffline(order);
}
});
return(Ok(order));
}
public IQueryable <ProductVariantAttribute> ManageAttributes(int key, ODataActionParameters parameters)
{
var entity = GetExpandedEntity(key, x => x.ProductVariantAttributes);
var result = new List <ProductVariantAttributeValue>();
this.ProcessEntity(() =>
{
var synchronize = parameters.GetValueSafe <bool>("Synchronize");
var data = (parameters["Attributes"] as IEnumerable <ManageAttributeType>)
.Where(x => x.Name.HasValue())
.ToList();
var attributeNames = new HashSet <string>(data.Select(x => x.Name), StringComparer.InvariantCultureIgnoreCase);
var pagedAttributes = _productAttributeService.Value.GetAllProductAttributes(0, 1);
var attributesData = pagedAttributes.SourceQuery
.Where(x => attributeNames.Contains(x.Name))
.Select(x => new { x.Id, x.Name })
.ToList();
var allAttributesDic = attributesData.ToDictionarySafe(x => x.Name, x => x, StringComparer.OrdinalIgnoreCase);
foreach (var srcAttr in data)
{
var attributeId = 0;
if (allAttributesDic.TryGetValue(srcAttr.Name, out var attributeData))
{
attributeId = attributeData.Id;
}
else
{
var attribute = new ProductAttribute {
Name = srcAttr.Name
};
_productAttributeService.Value.InsertProductAttribute(attribute);
attributeId = attribute.Id;
}
var productAttribute = entity.ProductVariantAttributes.FirstOrDefault(x => x.ProductAttribute.Name.IsCaseInsensitiveEqual(srcAttr.Name));
if (productAttribute == null)
{
productAttribute = new ProductVariantAttribute
{
ProductId = entity.Id,
ProductAttributeId = attributeId,
AttributeControlTypeId = srcAttr.ControlTypeId,
DisplayOrder = entity.ProductVariantAttributes.OrderByDescending(x => x.DisplayOrder).Select(x => x.DisplayOrder).FirstOrDefault() + 1,
IsRequired = srcAttr.IsRequired
};
entity.ProductVariantAttributes.Add(productAttribute);
Service.UpdateProduct(entity);
}
else if (synchronize)
{
if (srcAttr.Values.Count <= 0 && productAttribute.ShouldHaveValues())
{
_productAttributeService.Value.DeleteProductVariantAttribute(productAttribute);
}
else
{
productAttribute.AttributeControlTypeId = srcAttr.ControlTypeId;
productAttribute.IsRequired = srcAttr.IsRequired;
Service.UpdateProduct(entity);
}
}
var maxDisplayOrder = productAttribute.ProductVariantAttributeValues
.OrderByDescending(x => x.DisplayOrder)
.Select(x => x.DisplayOrder)
.FirstOrDefault();
foreach (var srcVal in srcAttr.Values.Where(x => x.Name.HasValue()))
{
var value = productAttribute.ProductVariantAttributeValues.FirstOrDefault(x => x.Name.IsCaseInsensitiveEqual(srcVal.Name));
if (value == null)
{
value = new ProductVariantAttributeValue
{
ProductVariantAttributeId = productAttribute.Id,
Name = srcVal.Name,
Alias = srcVal.Alias,
Color = srcVal.Color,
PriceAdjustment = srcVal.PriceAdjustment,
WeightAdjustment = srcVal.WeightAdjustment,
IsPreSelected = srcVal.IsPreSelected,
DisplayOrder = ++maxDisplayOrder
};
productAttribute.ProductVariantAttributeValues.Add(value);
Service.UpdateProduct(entity);
}
else if (synchronize)
{
value.Alias = srcVal.Alias;
value.Color = srcVal.Color;
value.PriceAdjustment = srcVal.PriceAdjustment;
value.WeightAdjustment = srcVal.WeightAdjustment;
value.IsPreSelected = srcVal.IsPreSelected;
Service.UpdateProduct(entity);
}
}
if (synchronize)
{
foreach (var dstVal in productAttribute.ProductVariantAttributeValues.ToList())
{
if (!srcAttr.Values.Any(x => x.Name.IsCaseInsensitiveEqual(dstVal.Name)))
{
_productAttributeService.Value.DeleteProductVariantAttributeValue(dstVal);
}
}
}
}
});
return(entity.ProductVariantAttributes.AsQueryable());
}
public IQueryable <ProductVariantAttribute> ManageAttributes(int key, ODataActionParameters parameters)
{
var entity = GetExpandedEntity <ICollection <ProductVariantAttribute> >(key, x => x.ProductVariantAttributes);
var result = new List <ProductVariantAttributeValue>();
this.ProcessEntity(() =>
{
var synchronize = parameters.GetValueSafe <bool>("Synchronize");
var data = (parameters["Attributes"] as IEnumerable <ManageAttributeType>).Where(x => x.Name.HasValue()).ToList();
var allAttributes = _productAttributeService.Value.GetAllProductAttributes();
foreach (var srcAttr in data)
{
var productAttribute = allAttributes.FirstOrDefault(x => x.Name.IsCaseInsensitiveEqual(srcAttr.Name));
if (productAttribute == null)
{
productAttribute = new ProductAttribute()
{
Name = srcAttr.Name
};
_productAttributeService.Value.InsertProductAttribute(productAttribute);
}
var attribute = entity.ProductVariantAttributes.FirstOrDefault(x => x.ProductAttribute.Name.IsCaseInsensitiveEqual(srcAttr.Name));
if (attribute == null)
{
attribute = new ProductVariantAttribute()
{
ProductId = entity.Id,
ProductAttributeId = productAttribute.Id,
AttributeControlTypeId = srcAttr.ControlTypeId,
DisplayOrder = entity.ProductVariantAttributes.OrderByDescending(x => x.DisplayOrder).Select(x => x.DisplayOrder).FirstOrDefault() + 1,
IsRequired = srcAttr.IsRequired
};
entity.ProductVariantAttributes.Add(attribute);
Service.UpdateProduct(entity);
}
else if (synchronize)
{
if (srcAttr.Values.Count <= 0 && attribute.ShouldHaveValues())
{
_productAttributeService.Value.DeleteProductVariantAttribute(attribute);
}
else
{
attribute.AttributeControlTypeId = srcAttr.ControlTypeId;
attribute.IsRequired = srcAttr.IsRequired;
Service.UpdateProduct(entity);
}
}
int maxDisplayOrder = attribute.ProductVariantAttributeValues.OrderByDescending(x => x.DisplayOrder).Select(x => x.DisplayOrder).FirstOrDefault();
foreach (var srcVal in srcAttr.Values.Where(x => x.Name.HasValue()))
{
var value = attribute.ProductVariantAttributeValues.FirstOrDefault(x => x.Name.IsCaseInsensitiveEqual(srcVal.Name));
if (value == null)
{
value = new ProductVariantAttributeValue()
{
ProductVariantAttributeId = attribute.Id,
Name = srcVal.Name,
Alias = srcVal.Alias,
Color = srcVal.Color,
PriceAdjustment = srcVal.PriceAdjustment,
WeightAdjustment = srcVal.WeightAdjustment,
IsPreSelected = srcVal.IsPreSelected,
DisplayOrder = ++maxDisplayOrder
};
attribute.ProductVariantAttributeValues.Add(value);
Service.UpdateProduct(entity);
}
else if (synchronize)
{
value.Alias = srcVal.Alias;
value.Color = srcVal.Color;
value.PriceAdjustment = srcVal.PriceAdjustment;
value.WeightAdjustment = srcVal.WeightAdjustment;
value.IsPreSelected = srcVal.IsPreSelected;
Service.UpdateProduct(entity);
}
}
if (synchronize)
{
foreach (var dstVal in attribute.ProductVariantAttributeValues.ToList())
{
if (!srcAttr.Values.Any(x => x.Name.IsCaseInsensitiveEqual(dstVal.Name)))
{
_productAttributeService.Value.DeleteProductVariantAttributeValue(dstVal);
}
}
}
}
});
return(entity.ProductVariantAttributes.AsQueryable());
}
