static NextStepInfo getNextStepForIf(
ISagaAction sagaAction,
ISagaStep step,
SagaExecutionState sagaState)
{
if (step.Is <ISagaStepForIf>())
{
IStepData currentStepData = sagaState.History.
GetLatestByStepName(step.StepName);
if (currentStepData?.ExecutionData?.ConditionResult == true)
{
return(new NextStepInfo {
NextStep = step.ChildSteps.GetFirstStep()
});
}
else
{
return(new NextStepInfo {
NextStep = GetNextStepElsewhere(sagaAction.ChildSteps, step)
});
}
}
return(null);
}
static bool getResultFromPrevIfElse(
SagaSteps childSteps,
ISagaStep step,
SagaExecutionState sagaState)
{
while (true)
{
ISagaStep prevStepIf = GetPrevStepSameLevel(childSteps, step.ParentStep, step);
if (prevStepIf.Is <ISagaStepForIf>())
{
IStepData stepDataIf = sagaState.History.
GetLatestByStepName(prevStepIf.StepName);
if (stepDataIf?.ExecutionData?.ConditionResult == true)
{
return(true);
}
if (!prevStepIf.Is <ISagaStepForElse>())
{
return(false);
}
step = prevStepIf;
}
else
{
return(false);
}
}
}
public async Task Execute(
IServiceProvider serviceProvider,
IExecutionContext context,
ISagaEvent @event,
IStepData stepData)
{
if (typeof(TExecuteEvent) == typeof(EmptyEvent))
{
return;
}
ISagaInternalCoordinator sagaCoordinator = serviceProvider.
GetRequiredService <ISagaCoordinator>() as ISagaInternalCoordinator;
IExecutionContext <TSagaData> contextForAction =
(IExecutionContext <TSagaData>)context;
TExecuteEvent executionEvent = new TExecuteEvent();
if (ActionDelegate != null)
{
await ActionDelegate(contextForAction, executionEvent);
}
ISaga newSaga = await sagaCoordinator.
Publish(executionEvent, contextForAction.ExecutionValues, contextForAction.Data.ID, new SagaRunOptions());
}
public async Task Execute(
IServiceProvider serviceProvider,
IExecutionContext context,
ISagaEvent @event,
IStepData stepData)
{
if (typeof(TExecuteEvent) == typeof(EmptyEvent))
{
return;
}
ISagaCoordinator sagaCoordinator = serviceProvider.
GetRequiredService <ISagaCoordinator>();
IExecutionContext <TSagaData> contextForAction =
(IExecutionContext <TSagaData>)context;
TExecuteEvent executionEvent = new TExecuteEvent();
if (action != null)
{
await action(contextForAction, executionEvent);
}
await sagaCoordinator.
Publish(executionEvent, contextForAction.ExecutionValues);
}
public async Task Compensate(
IServiceProvider serviceProvider,
IExecutionContext context,
ISagaEvent @event,
IStepData stepData)
{
}
public async Task Execute(
IServiceProvider serviceProvider,
IExecutionContext context,
ISagaEvent @event,
IStepData stepData)
{
(context.ExecutionState as SagaExecutionState).IsBreaked = true;
}
/// <inheritdoc />
public override void Unlock(IStepData data, IEnumerable <LockablePropertyData> manualUnlocked)
{
IEnumerable <LockablePropertyData> unlockList = PropertyReflectionHelper.ExtractLockablePropertiesFromStep(data);
unlockList = unlockList.Union(manualUnlocked);
foreach (LockablePropertyData lockable in unlockList)
{
lockable.Property.SetLocked(false);
}
}
public ProductType(IStockProductData _stockProductData,
ICategoryData _categoryData,
IStepData _stepData)
{
Field(_ => _.Id);
Field(_ => _.Desc);
Field(_ => _.CategoryId);
Field(_ => _.Type);
Field <ListGraphType <StockProductType> >(
"stockProduct",
resolve: context => _stockProductData.GetStocksAsync(context.Source.Id));
Field <CategoryType>(
"category",
resolve: context => _categoryData.GetAsync(context.Source.CategoryId));
}
public override Rect Draw(Rect rect, object currentValue, Action <object> changeValueCallback, GUIContent label)
{
if (BuildPipeline.isBuildingPlayer)
{
return(rect);
}
rect = base.Draw(rect, currentValue, changeValueCallback, label);
Step.EntityData step = (Step.EntityData)currentValue;
if (step.Metadata == null)
{
step.Metadata = new Metadata();
}
if (lastStep != step)
{
lockablePropertyTab = new LockablePropertyTab(new GUIContent("Unlocked Objects"), step);
lastStep = step;
}
GUIContent behaviorLabel = new GUIContent("Behaviors");
if (EditorConfigurator.Instance.Validation.LastReport != null && EditorConfigurator.Instance.Validation.LastReport.GetBehaviorEntriesFor(step).Count > 0)
{
behaviorLabel.image = EditorGUIUtility.IconContent("Warning").image;
}
GUIContent transitionLabel = new GUIContent("Transitions");
if (EditorConfigurator.Instance.Validation.LastReport != null && EditorConfigurator.Instance.Validation.LastReport.GetConditionEntriesFor(step).Count > 0)
{
transitionLabel.image = EditorGUIUtility.IconContent("Warning").image;
}
TabsGroup activeTab = new TabsGroup(
step.Metadata,
new DynamicTab(behaviorLabel, () => step.Behaviors, value => step.Behaviors = (IBehaviorCollection)value),
new DynamicTab(transitionLabel, () => step.Transitions, value => step.Transitions = (ITransitionCollection)value),
lockablePropertyTab
);
Rect tabRect = new TabsGroupDrawer().Draw(new Rect(rect.x, rect.y + rect.height + 4f, rect.width, 0), activeTab, changeValueCallback, label);
rect.height += tabRect.height;
return(rect);
}
public static List <LockablePropertyData> ExtractLockablePropertiesFromStep(IStepData data)
{
List <LockablePropertyData> result = new List <LockablePropertyData>();
if (data == null)
{
return(result);
}
foreach (ITransition transition in data.Transitions.Data.Transitions)
{
foreach (ICondition condition in transition.Data.Conditions)
{
result.AddRange(ExtractLockablePropertiesFromConditions(condition.Data));
}
}
return(result);
}
/// <inheritdoc />
public override void Lock(IStepData data, IEnumerable <LockablePropertyData> manualUnlocked)
{
// All properties which should be locked
IEnumerable <LockablePropertyData> lockList = PropertyReflectionHelper.ExtractLockablePropertiesFromStep(data);
lockList = lockList.Union(manualUnlocked);
ITransition completedTransition = data.Transitions.Data.Transitions.FirstOrDefault(transition => transition.IsCompleted);
if (completedTransition != null)
{
IStepData nextStepData = GetNextStep(completedTransition);
IEnumerable <LockablePropertyData> nextStepProperties = PropertyReflectionHelper.ExtractLockablePropertiesFromStep(nextStepData);
if (nextStepData != null && nextStepData is ILockableStepData lockableStepData)
{
IEnumerable <LockablePropertyData> toUnlock = lockableStepData.ToUnlock.Select(reference => new LockablePropertyData(reference.GetProperty()));
nextStepProperties = nextStepProperties.Union(toUnlock);
}
if (completedTransition is ILockablePropertiesProvider completedLockableTransition)
{
IEnumerable <LockablePropertyData> transitionLockList = completedLockableTransition.GetLockableProperties();
foreach (LockablePropertyData lockable in transitionLockList)
{
lockable.Property.SetLocked(lockable.EndStepLocked && nextStepProperties.Contains(lockable) == false);
}
// Remove all lockable from completed transition
lockList = lockList.Except(transitionLockList);
}
// Remove all lockable from
lockList = lockList.Except(nextStepProperties);
}
foreach (LockablePropertyData lockable in lockList)
{
lockable.Property.SetLocked(true);
}
}
public async Task Execute(IServiceProvider serviceProvider, IExecutionContext context, ISagaEvent @event, IStepData stepData)
{
IExecutionContext <TSagaData> contextForAction =
(IExecutionContext <TSagaData>)context;
if (action != null)
{
bool result = await action(contextForAction);
stepData.ExecutionData.ConditionResult = result;
}
else
{
stepData.ExecutionData.ConditionResult = false;
}
}
public async Task Compensate(IServiceProvider serviceProvider, IExecutionContext context, ISagaEvent @event, IStepData stepData)
{
IExecutionContext <TSagaData> contextForAction =
(IExecutionContext <TSagaData>)context;
if (compensation != null)
{
await compensation(contextForAction);
}
}
/// <summary> /// Locks all unlocked LockableProperties for the current step. /// </summary> /// <param name="data">IStepData of the current step</param> /// <param name="manualUnlocked">All LockableProperties which were unlocked in addition</param> public abstract void Lock(IStepData data, IEnumerable <LockablePropertyData> manualUnlocked);
public async Task Execute(IServiceProvider serviceProvider, IExecutionContext context, ISagaEvent @event, IStepData stepData)
{
IExecutionContext <TSagaData> contextForAction =
(IExecutionContext <TSagaData>)context;
TEventHandler activity = (TEventHandler)ActivatorUtilities.CreateInstance(serviceProvider, typeof(TEventHandler));
if (activity != null)
{
await activity.Execute(contextForAction, (TEvent)@event);
}
}
private string CalculateNextStep(ISaga saga, ISagaAction sagaAction, ISagaStep sagaStep, IStepData stepData = null)
{
if (saga.ExecutionState.IsResuming)
{
return(sagaStep.StepName);
}
if (saga.ExecutionState.IsCompensating)
{
return(CalculateNextCompensationStep(saga));
}
return(sagaAction.
GetNextStepToExecute(sagaStep, saga.ExecutionState)?.StepName);
}
/// <inheritdoc />
public override void Lock(IStepData data, IEnumerable <LockablePropertyData> manualUnlocked)
{
}
public async Task Compensate(IServiceProvider serviceProvider, IExecutionContext context, ISagaEvent @event, IStepData stepData)
{
IExecutionContext <TSagaData> contextForAction =
(IExecutionContext <TSagaData>)context;
TSagaActivity activity = (TSagaActivity)ActivatorUtilities.CreateInstance(serviceProvider, typeof(TSagaActivity));
if (activity != null)
{
await activity.Compensate(contextForAction);
}
}
public async Task Execute(IServiceProvider serviceProvider, IExecutionContext context, ISagaEvent @event, IStepData stepData)
{
IExecutionContext <TSagaData> contextForAction =
(IExecutionContext <TSagaData>)context;
TSagaCondition activity = (TSagaCondition)ActivatorUtilities.CreateInstance(serviceProvider, typeof(TSagaCondition));
if (activity != null)
{
bool result = await activity.Execute(contextForAction);
stepData.ExecutionData.ConditionResult = result;
}
else
{
stepData.ExecutionData.ConditionResult = false;
}
}
public RootQuery(IEmployeeData _employeeData,
IRoleData _roleData,
IPermissionData _permissionData,
ITaskData _taskData,
ICategoryData _categoryData,
IStockData _stockData,
IStepData _stepData,
IWineData _wineData,
IProductData _productData)
{
//EMPLOYEES
Field <ListGraphType <EmployeeType> >("employees", resolve: context =>
{
return(_employeeData.GetAllAsync());
});
Field <EmployeeType>("employee",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_employeeData.GetAsync(id));
});
Field <EmployeeType>("employeeEmail",
arguments: new QueryArguments
{
new QueryArgument <StringGraphType> {
Name = "email"
},
new QueryArgument <StringGraphType> {
Name = "password"
}
},
resolve: context =>
{
string email = context.GetArgument <string>("email");
string password = context.GetArgument <string>("password");
return(_employeeData.GetByEmailPasswordAsync(email, password));
});
//ROLES
Field <ListGraphType <RoleType> >("roles", resolve: context =>
{
return(_roleData.GetAllAsync());
});
Field <RoleType>("role",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_roleData.GetAsync(id));
});
//PERMISSIONS
Field <ListGraphType <PermissionType> >("permissions", resolve: context =>
{
return(_permissionData.GetAllAsync());
});
Field <PermissionType>("permission",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_permissionData.GetAsync(id));
});
// TASKS
Field <ListGraphType <TaskType> >("tasks", resolve: context =>
{
return(_taskData.GetAllAsync());
});
Field <TaskType>("task",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_taskData.GetAsync(id));
});
// CATEGORIES
Field <ListGraphType <CategoryType> >("categories", resolve: context =>
{
return(_categoryData.GetAllAsync());
});
Field <CategoryType>("category",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_categoryData.GetAsync(id));
});
// STOCKS
Field <ListGraphType <StockType> >("stocks", resolve: context =>
{
return(_stockData.GetAllAsync());
});
Field <StockType>("stock",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
// try{
int id = context.GetArgument <int>("id");
Console.WriteLine("entrou");
return(_stockData.GetAsync(id));
// } catch (Exception error) {
// Console.WriteLine(error);
// return null;
// }
});
// STEPS
Field <ListGraphType <StepType> >("steps", resolve: context =>
{
return(_stepData.GetAllAsync());
});
Field <StepType>("step",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_stepData.GetAsync(id));
});
// WINES
Field <ListGraphType <WineType> >("wines", resolve: context =>
{
return(_wineData.GetAllAsync());
});
Field <WineType>("wine",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_wineData.GetAsync(id));
});
// PRODUCTS
Field <ListGraphType <ProductType> >("products", resolve: context =>
{
return(_productData.GetAllAsync());
});
Field <ProductType>("product",
arguments: new QueryArguments
{
new QueryArgument <IntGraphType> {
Name = "id"
}
},
resolve: context =>
{
int id = context.GetArgument <int>("id");
return(_productData.GetAsync(id));
});
}
public Task Execute(IServiceProvider serviceProvider, IExecutionContext context, ISagaEvent @event, IStepData stepData)
{
return(Task.CompletedTask);
}
// public RootMutation(IWineData wineData)
// {
// Field<WineType>(
// "addWine",
// arguments: new QueryArguments
// {
// new QueryArgument<InputWineType>(){ Name = "wine"}
// },
// resolve: context =>
// {
// var wine = context.GetArgument<Wine>("wine");
// wineData.AddWine(wine);
// return null;
// }
// );
// }
public RootMutation(IEmployeeData employeeData,
IRoleData roleData,
IPermissionData permissionData,
ITaskData taskData,
ICategoryData categoryData,
IStockData stockData,
IStepData stepData,
IWineData wineData,
IProductData productData,
IStockProductData stockProductData,
IStockWineData stockWineData)
{
// EMPLOYEE
Field <EmployeeType>(
"addEmployee",
arguments: new QueryArguments
{
new QueryArgument <InputEmployeeType>()
{
Name = "employee"
}
},
resolve: context =>
{
var employee = context.GetArgument <Employee>("employee");
return(employeeData.AddEmployee(employee));
}
);
Field <EmployeeType>(
"updateEmployee",
arguments: new QueryArguments {
new QueryArgument <InputEmployeeType>()
{
Name = "employee"
}
},
resolve: context =>
{
var employee = context.GetArgument <Employee>("employee");
return(employeeData.Update(employee));
}
);
Field <EmployeeType>(
"deleteEmployee",
arguments: new QueryArguments {
new QueryArgument <InputEmployeeType>()
{
Name = "employee"
}
},
resolve: context =>
{
var employee = context.GetArgument <Employee>("employee");
employeeData.Delete(employee);
return(employee);
}
);
// ROLE
Field <RoleType>(
"addRole",
arguments: new QueryArguments
{
new QueryArgument <InputRoleType>()
{
Name = "role"
}
},
resolve: context =>
{
var role = context.GetArgument <Role>("role");
return(roleData.AddRole(role));
}
);
Field <RoleType>(
"updateRole",
arguments: new QueryArguments {
new QueryArgument <InputRoleType>()
{
Name = "role"
}
},
resolve: context =>
{
var role = context.GetArgument <Role>("role");
return(roleData.Update(role));
}
);
Field <RoleType>(
"deleteRole",
arguments: new QueryArguments {
new QueryArgument <InputRoleType>()
{
Name = "role"
}
},
resolve: context =>
{
var role = context.GetArgument <Role>("role");
roleData.Delete(role);
return(role);
}
);
// PERMISSION
Field <PermissionType>(
"addPermission",
arguments: new QueryArguments
{
new QueryArgument <InputPermissionType>()
{
Name = "permission"
}
},
resolve: context =>
{
var permission = context.GetArgument <Permission>("permission");
return(permissionData.AddPermission(permission));
}
);
Field <PermissionType>(
"updatePermission",
arguments: new QueryArguments {
new QueryArgument <InputPermissionType>()
{
Name = "permission"
}
},
resolve: context =>
{
var permission = context.GetArgument <Permission>("permission");
return(permissionData.Update(permission));
}
);
Field <PermissionType>(
"deletePermission",
arguments: new QueryArguments {
new QueryArgument <InputPermissionType>()
{
Name = "permission"
}
},
resolve: context =>
{
var permission = context.GetArgument <Permission>("permission");
permissionData.Delete(permission);
return(permission);
}
);
// TASK
Field <TaskType>(
"addTask",
arguments: new QueryArguments
{
new QueryArgument <InputTaskType>()
{
Name = "task"
}
},
resolve: context =>
{
var task = context.GetArgument <Task>("task");
return(taskData.AddTask(task));
}
);
Field <TaskType>(
"updateTask",
arguments: new QueryArguments {
new QueryArgument <InputTaskType>()
{
Name = "task"
}
},
resolve: context =>
{
var task = context.GetArgument <Task>("task");
return(taskData.Update(task));
}
);
Field <TaskType>(
"deleteTask",
arguments: new QueryArguments {
new QueryArgument <InputTaskType>()
{
Name = "task"
}
},
resolve: context =>
{
var task = context.GetArgument <Task>("task");
taskData.Delete(task);
return(task);
}
);
// CATEGORY
Field <CategoryType>(
"addCategory",
arguments: new QueryArguments
{
new QueryArgument <InputCategoryType>()
{
Name = "category"
}
},
resolve: context =>
{
var category = context.GetArgument <Category>("category");
return(categoryData.AddCategory(category));
}
);
Field <CategoryType>(
"updateCategory",
arguments: new QueryArguments {
new QueryArgument <InputCategoryType>()
{
Name = "category"
}
},
resolve: context =>
{
var category = context.GetArgument <Category>("category");
return(categoryData.Update(category));
}
);
Field <CategoryType>(
"deleteCategory",
arguments: new QueryArguments {
new QueryArgument <InputCategoryType>()
{
Name = "category"
}
},
resolve: context =>
{
var category = context.GetArgument <Category>("category");
categoryData.Delete(category);
return(category);
}
);
// STOCK
Field <StockType>(
"addStock",
arguments: new QueryArguments
{
new QueryArgument <InputStockType>()
{
Name = "stock"
}
},
resolve: context =>
{
var stock = context.GetArgument <Stock>("stock");
return(stockData.AddStock(stock));
}
);
Field <StockType>(
"updateStock",
arguments: new QueryArguments {
new QueryArgument <InputStockType>()
{
Name = "stock"
}
},
resolve: context =>
{
var stock = context.GetArgument <Stock>("stock");
return(stockData.Update(stock));
}
);
Field <StockType>(
"deleteStock",
arguments: new QueryArguments {
new QueryArgument <InputStockType>()
{
Name = "stock"
}
},
resolve: context =>
{
var stock = context.GetArgument <Stock>("stock");
stockData.Delete(stock);
return(stock);
}
);
// STEP
Field <StepType>(
"addStep",
arguments: new QueryArguments
{
new QueryArgument <InputStepType>()
{
Name = "step"
}
},
resolve: context =>
{
var step = context.GetArgument <Step>("step");
return(stepData.AddStep(step));
}
);
Field <StepType>(
"updateStep",
arguments: new QueryArguments {
new QueryArgument <InputStepType>()
{
Name = "step"
}
},
resolve: context =>
{
var step = context.GetArgument <Step>("step");
return(stepData.Update(step));
}
);
Field <StepType>(
"deleteStep",
arguments: new QueryArguments {
new QueryArgument <InputStepType>()
{
Name = "step"
}
},
resolve: context =>
{
var step = context.GetArgument <Step>("step");
stepData.Delete(step);
return(step);
}
);
// WINE
Field <WineType>(
"addWine",
arguments: new QueryArguments
{
new QueryArgument <InputWineType>()
{
Name = "wine"
}
},
resolve: context =>
{
var wine = context.GetArgument <Wine>("wine");
return(wineData.AddWine(wine));
}
);
Field <WineType>(
"updateWine",
arguments: new QueryArguments {
new QueryArgument <InputWineType>()
{
Name = "wine"
}
},
resolve: context =>
{
var wine = context.GetArgument <Wine>("wine");
return(wineData.Update(wine));
}
);
Field <WineType>(
"deleteWine",
arguments: new QueryArguments {
new QueryArgument <InputWineType>()
{
Name = "wine"
}
},
resolve: context =>
{
var wine = context.GetArgument <Wine>("wine");
wineData.Delete(wine);
return(wine);
}
);
// PRODUCT
Field <ProductType>(
"addProduct",
arguments: new QueryArguments
{
new QueryArgument <InputProductType>()
{
Name = "product"
}
},
resolve: context =>
{
var product = context.GetArgument <Product>("product");
return(productData.AddProduct(product));
}
);
Field <ProductType>(
"updateProduct",
arguments: new QueryArguments {
new QueryArgument <InputProductType>()
{
Name = "product"
}
},
resolve: context =>
{
var product = context.GetArgument <Product>("product");
return(productData.Update(product));
}
);
Field <ProductType>(
"deleteProduct",
arguments: new QueryArguments {
new QueryArgument <InputProductType>()
{
Name = "product"
}
},
resolve: context =>
{
var product = context.GetArgument <Product>("product");
productData.Delete(product);
return(product);
}
);
// StockProduct
Field <StockProductType>(
"addStockProduct",
arguments: new QueryArguments
{
new QueryArgument <InputStockProductType>()
{
Name = "stockProduct"
}
},
resolve: context =>
{
var stockProduct = context.GetArgument <StockProduct>("stockProduct");
return(stockProductData.AddStockProduct(stockProduct));
}
);
Field <StockProductType>(
"updateStockProduct",
arguments: new QueryArguments {
new QueryArgument <InputStockProductType>()
{
Name = "stockProduct"
}
},
resolve: context =>
{
var stockProduct = context.GetArgument <StockProduct>("stockProduct");
return(stockProductData.Update(stockProduct));
}
);
Field <StockProductType>(
"deleteStockProduct",
arguments: new QueryArguments {
new QueryArgument <InputStockProductType>()
{
Name = "stockProduct"
}
},
resolve: context =>
{
var stockProduct = context.GetArgument <StockProduct>("stockProduct");
stockProductData.Delete(stockProduct);
return(stockProduct);
}
);
// StockWine
Field <StockWineType>(
"addStockWine",
arguments: new QueryArguments
{
new QueryArgument <InputStockWineType>()
{
Name = "stockWine"
}
},
resolve: context =>
{
var stockWine = context.GetArgument <StockWine>("stockWine");
return(stockWineData.AddStockWine(stockWine));
}
);
Field <StockWineType>(
"updateStockWine",
arguments: new QueryArguments {
new QueryArgument <InputStockWineType>()
{
Name = "stockWine"
}
},
resolve: context =>
{
var stockWine = context.GetArgument <StockWine>("stockWine");
return(stockWineData.Update(stockWine));
}
);
Field <StockWineType>(
"deleteStockWine",
arguments: new QueryArguments {
new QueryArgument <InputStockWineType>()
{
Name = "stockWine"
}
},
resolve: context =>
{
var stockWine = context.GetArgument <StockWine>("stockWine");
stockWineData.Delete(stockWine);
return(stockWine);
}
);
}
