public LocalApiContext(ApiContext context, CommerceInstance instance)
{
InstanceName = context.InstanceName;
Culture = context.Culture;
Customer = context.Customer;
_instance = instance;
}
public System.Collections.IEnumerable Enumerate(CommerceInstance instance, CultureInfo culture)
{
foreach (var data in new BatchedQuery<Product>(Query(instance), 1000))
{
var product = data as Product;
yield return ProductModel.Create(product, culture, CategoryTree.Get(instance.Name));
}
}
public QueryContext(CommerceInstance instance, string keywords, int pageIndex, int pageSize, object config)
{
Instance = instance;
Keywords = keywords;
PageIndex = pageIndex;
PageSize = pageSize;
Config = config;
}
public override ActionResult Execute(IEnumerable<Order> orders, object config, CommerceInstance instance)
{
foreach (var order in orders)
{
Event.Raise(new ApproveOrder(order.Id), instance);
}
return null;
}
public override ActionResult Execute(IEnumerable<Customer> customers, object config, CommerceInstance instance)
{
var service = new CustomerService(instance);
foreach (var customer in customers)
{
service.Delete(customer);
}
return null;
}
public override ActionResult Execute(IEnumerable<Product> products, object config, CommerceInstance instance)
{
var service = new ProductService(instance);
foreach (var product in products)
{
service.Unpublish(product);
}
return null;
}
private void Handle(IEvent @event, CommerceInstance commerceInstance)
{
// TODO: Need to be passed in?
var instance = CommerceInstance.Current;
var rules = RuleManager.GetManager(instance.Name).GetRules(@event.GetType().Name);
var activities = new List<ConfiguredActivity>();
foreach (var rule in rules)
{
activities.AddRange(rule.Execute(@event));
}
ScheduleActivities(activities.Where(it => it.Async), @event, instance);
ExecuteActivities(activities.Where(it => !it.Async), @event);
}
private void InitGlobalSettings(CommerceInstance instance)
{
var settings = new GlobalSettings
{
Image = new ImageSettings
{
Types =
{
new ImageType("List", 240, 240),
new ImageType("Detail", 300, 300, true),
new ImageType("Thumbnail", 240, 240),
new ImageType("Cart", 50, 50)
}
}
};
var service = new SettingService(instance.Database);
service.Set(settings);
}
ActionResult ITopbarCommand.Execute(IEnumerable<object> dataItems, object config, CommerceInstance instance)
{
return Execute(dataItems.OfType<Product>(), config, instance);
}
public abstract ActionResult Execute(IEnumerable<Product> products, object config, CommerceInstance instance);
bool ITopbarCommand.CanExecute(object context, CommerceInstance instance)
{
return CanExecute(context as Product, instance);
}
public override bool CanExecute(Kooboo.Commerce.Customers.Customer customer, CommerceInstance instance)
{
return true;
}
public abstract bool CanExecute(Product product, CommerceInstance instance);
public PromotionService(CommerceInstance instance)
{
_instance = instance;
_repository = instance.Database.Repository<Promotion>();
}
public abstract ActionResult Execute(IEnumerable<Order> orders, object config, CommerceInstance instance);
public abstract bool CanExecute(Customer customer, CommerceInstance instance);
private void ScheduleActivities(IEnumerable<ConfiguredActivity> activities, IEvent @event, CommerceInstance instance)
{
var repository = instance.Database.Repository<ScheduledActivity>();
foreach (var activity in activities)
{
repository.Insert(new ScheduledActivity(@event, activity));
}
}
public static IEnumerable<ITopbarCommand> GetCommands(ControllerContext controllerContext, object context, CommerceInstance instance)
{
return GetCommands(controllerContext).Where(x => x.CanExecute(context, instance));
}
public PaymentService(CommerceInstance instance)
{
_instance = instance;
_repository = _instance.Database.Repository<Payment>();
}
public ProductService(CommerceInstance instance)
{
_instance = instance;
_database = instance.Database;
}
public OrderService(CommerceInstance instance)
{
_instance = instance;
_orderRepository = _instance.Database.Repository<Order>();
}
public ProductTypeService(CommerceInstance instance)
{
_instance = instance;
_productTypes = _instance.Database.Repository<ProductType>();
_customFields = _instance.Database.Repository<CustomFieldDefinition>();
}
public ShippingMethodService(CommerceInstance instance)
{
_instance = instance;
_repository = _instance.Database.Repository<ShippingMethod>();
}
public override bool CanExecute(Kooboo.Commerce.Products.Product product, CommerceInstance instance)
{
return product.IsPublished;
}
public LocalApiContext(CultureInfo culture, CommerceInstance instance)
: base(instance.Name, culture)
{
_instance = instance;
}
bool ITopbarCommand.CanExecute(object dataItem, CommerceInstance instance)
{
return CanExecute(dataItem as Order, instance);
}
public BrandService(CommerceInstance instance)
{
_instance = instance;
}
private void DoWork(CommerceInstance instance)
{
IndexStore store = null;
try
{
var rebuildDirectory = IndexStores.GetDirectory(Context.Instance, Context.Culture, Context.ModelType, true);
var liveDirectory = IndexStores.GetDirectory(Context.Instance, Context.Culture, Context.ModelType, false);
// Ensure temp folder are deleted (last rebuild might encounter errors when deleting the temp folder)
Kooboo.IO.IOUtility.DeleteDirectory(rebuildDirectory, true);
Kooboo.IO.IOUtility.DeleteDirectory(liveDirectory + "-tmp", true);
var total = _source.Count(instance, Context.Culture);
var totalRebuilt = 0;
Progress = 0;
store = new IndexStore(Context.ModelType, FSDirectory.Open(rebuildDirectory), Analyzers.GetAnalyzer(Context.Culture));
foreach (var data in _source.Enumerate(instance, Context.Culture))
{
if (_cancelling)
{
break;
}
store.Index(data);
totalRebuilt++;
Progress = (int)Math.Round(totalRebuilt * 100 / (double)total);
}
if (_cancelling)
{
store.Dispose();
UpdateTaskInfo(info =>
{
info.ClearError();
info.LastRebuildStatus = RebuildStatus.Cancelled;
});
_cancelling = false;
_cancelledEvent.Set();
Status = RebuildStatus.Cancelled;
}
else
{
store.Commit();
store.Dispose();
UpdateTaskInfo(info =>
{
info.ClearError();
info.LastRebuildStatus = RebuildStatus.Success;
info.LastSucceededRebuildTimeUtc = DateTime.UtcNow;
});
// Replace old index files with the new ones
IndexStores.Close(Context.Instance, Context.Culture, Context.ModelType);
var liveDirectoryExists = System.IO.Directory.Exists(liveDirectory);
if (liveDirectoryExists)
{
System.IO.Directory.Move(liveDirectory, liveDirectory + "-tmp");
Kooboo.IO.IOUtility.DeleteDirectory(liveDirectory, true);
}
System.IO.Directory.Move(rebuildDirectory, liveDirectory);
if (liveDirectoryExists)
{
Kooboo.IO.IOUtility.DeleteDirectory(liveDirectory + "-tmp", true);
}
Status = RebuildStatus.Success;
}
Progress = 0;
}
catch (Exception ex)
{
if (store != null)
{
store.Dispose();
}
UpdateTaskInfo(info =>
{
info.LastRebuildStatus = RebuildStatus.Failed;
info.LastRebuildError = ex.Message;
info.LastRebuildErrorDetail = ex.StackTrace;
});
Status = RebuildStatus.Failed;
}
}
public override bool CanExecute(Order order, CommerceInstance instance)
{
return order.Status == OrderStatus.Paid && order.ProcessingStatus != "Approved";
}
public abstract bool CanExecute(Order order, CommerceInstance instance);
