private void OnEditCategoryItems(string value)
{
if (SelectedCategory != null)
{
IList <IOrderable> values = new List <IOrderable>(_workspace.All <MenuItem>().OrderBy(x => x.GroupCode + x.Name)
.Where(x => !SelectedCategory.ContainsMenuItem(x))
.Select(x => new ScreenMenuItem {
MenuItemId = x.Id, Name = x.Name, MenuItem = x
}));
SelectedCategory.ScreenMenuItems.ToList().ForEach(x => x.MenuItem = Dao.SingleWithCache <MenuItem>(y => y.Id == x.MenuItemId));
IList <IOrderable> selectedValues = new List <IOrderable>(SelectedCategory.ScreenMenuItems);
var choosenValues = InteractionService.UserIntraction.ChooseValuesFrom(values, selectedValues, Resources.ProductList,
string.Format(Resources.AddProductsToCategoryHint_f, SelectedCategory.Name), Resources.Product, Resources.Products);
foreach (var screenMenuItem in SelectedCategory.ScreenMenuItems.ToList())
{
if (!choosenValues.Contains(screenMenuItem) && screenMenuItem.Id > 0)
{
_workspace.Delete(screenMenuItem);
}
}
SelectedCategory.ScreenMenuItems.Clear();
foreach (ScreenMenuItem item in choosenValues)
{
SelectedCategory.ScreenMenuItems.Add(item);
}
SelectedCategory.UpdateDisplay();
}
}
public void RemoveListOfObjects <T>(T[] items) where T : class
{
for (int i = 0; i < items.Length; i++)
{
_workspace.Delete <T>(items[i]);
}
}
private void OnDeleteTransactionItem(string obj)
{
if (SelectedTransactionItem.Model.Id > 0)
{
_workspace.Delete(SelectedTransactionItem.Model);
}
Model.TransactionItems.Remove(SelectedTransactionItem.Model);
TransactionItems.Remove(SelectedTransactionItem);
}
public void RemoveTicketItems(IEnumerable <TicketItem> selectedItems)
{
foreach (var ticketItem in selectedItems)
{
Ticket.TicketItems.Remove(ticketItem);
if (Ticket.Id > 0)
{
ticketItem.Properties.ToList().ForEach(_workspace.Delete);
_workspace.Delete(ticketItem);
}
}
}
private void OnSelectActions(string obj)
{
IList <IOrderable> selectedValues = new List <IOrderable>(Model.Actions);
var selectedIds = selectedValues.Select(x => ((ActionContainer)x).AppActionId);
IList <IOrderable> values = new List <IOrderable>(_workspace.All <AppAction>(x => !selectedIds.Contains(x.Id)).Select(x => new ActionContainer(x)));
var choosenValues = InteractionService.UserIntraction.ChooseValuesFrom(values, selectedValues, Resources.ActionList,
Resources.SelectActions, Resources.Action, Resources.Actions);
foreach (var action in Model.Actions.ToList())
{
var laction = action;
if (choosenValues.FirstOrDefault(x => ((ActionContainer)x).AppActionId == laction.AppActionId) == null)
{
if (action.Id > 0)
{
_workspace.Delete(action);
}
}
}
Model.Actions.Clear();
choosenValues.Cast <ActionContainer>().ToList().ForEach(x => Model.Actions.Add(x));
_actions = new ObservableCollection <ActionContainerViewModel>(Model.Actions.Select(x => new ActionContainerViewModel(x, this)));
RaisePropertyChanged("Actions");
}
/// <summary>
/// Exports the source table using the query filter to the table in the output workspace.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="filter">The filter.</param>
/// <param name="tableName">Name of the output table.</param>
/// <param name="workspace">The output workspace.</param>
/// <param name="requiredFields">The required fields.</param>
/// <param name="handle">The handle.</param>
/// <param name="surrogate">The surrogate for the event handler.</param>
/// <param name="invalid">The errors that occured during the export.</param>
/// <param name="errors">The field errors.</param>
/// <returns>
/// Returns a <see cref="IFeatureClass" /> representing the feature class that was exported.
/// </returns>
public static ITable Export(this ITable source, IQueryFilter filter, string tableName, IWorkspace workspace, IFields requiredFields, int handle, FeatureProgress surrogate, out IEnumInvalidObject invalid, out IEnumFieldError errors)
{
var ds = (IDataset)source;
var input = ds.Workspace.Define(ds.Name, new TableNameClass());
var output = workspace.Define(tableName, new TableNameClass());
workspace.Delete(output);
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = ds.Workspace;
fieldChecker.ValidateWorkspace = workspace;
IFields targetFields;
fieldChecker.Validate(requiredFields, out errors, out targetFields);
var featureDataConverter = new FeatureDataConverterClass();
if (surrogate != null)
{
surrogate.Advise(featureDataConverter);
}
invalid = featureDataConverter.ConvertTable(input, filter, null, output, targetFields, "", 1000, handle);
return(((IName)output).Open() as ITable);
}
void IProductRepository.Delete(int id)
{
var product = _workspace.Get <Product, int>(id);
_workspace.Delete(product);
_workspace.SaveChanges();
}
public Task DeleteAsync(User user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
foreach (var userRole in user.Roles.ToArray())
{
_workspace.Delete(userRole);
}
_workspace.Delete(user);
_workspace.SaveChanges();
return(Task.FromResult(0));
}
/// <summary>
/// Converts the event route source to a stand-alone feature class.
/// </summary>
/// <param name="outputTableName">The name of the output feature class.</param>
/// <param name="filter">The filter used to limit the number of features converted.</param>
/// <param name="workspace">The workspace that will contain the feature class.</param>
/// <returns>
/// Returns a <see cref="IFeatureClass" /> representing the results of the conversion.
/// </returns>
public IFeatureClass Convert(string outputTableName, IQueryFilter filter, IWorkspace workspace)
{
var source = (IFeatureClass)this.FeatureClass;
var geometryDef = ((IClone)source.GetGeometryDef()) as IGeometryDef;
IFieldChecker checker = new FieldCheckerClass();
IEnumFieldError errors;
IFields fields;
checker.InputWorkspace = workspace;
checker.ValidateWorkspace = workspace;
checker.Validate(source.Fields, out errors, out fields);
var outputClassName = workspace.Define(outputTableName, new FeatureClassNameClass());
workspace.Delete(outputClassName);
var dataConverter = new FeatureDataConverterClass();
var invalidObjects = dataConverter.ConvertFeatureClass((IDatasetName)this.Name, filter, null, null, outputClassName, geometryDef, fields, "", 1000, 0);
if (invalidObjects.AsEnumerable().Any())
{
return(null);
}
var route = workspace.GetFeatureClass(outputTableName);
return(route);
}
void ICategoryRepository.Delete(int id)
{
var product = _workspace.Get <Category, int>(id);
_workspace.Delete(product);
_workspace.SaveChanges();
}
private void OnDeleteMap(string obj)
{
if (SelectedMap.Id > 0)
{
_workspace.Delete(SelectedMap.Model);
}
_itemsSource.Remove(SelectedMap.Model);
Maps.Remove(SelectedMap);
}
public void RemoveWidget(Widget widget)
{
if (_resoureceWorkspace == null)
{
return;
}
_resoureceWorkspace.Delete <Widget>(x => x.Id == widget.Id);
_resoureceWorkspace.CommitChanges();
}
/// <summary>
/// Locates the polygon features along the route and writes the result to a new line event table.
/// </summary>
/// <param name="locatePolygonsAlongRouteName">Name of the locate polygons along route.</param>
/// <param name="polygons">The polygons to locate.</param>
/// <param name="keepZeroLengthEvents">
/// if set to <c>true</c> allows you to keep or not keep the zero length line events in
/// the output event table. The zero length line events result from a case where the geometric intersection of the
/// route (line) and the polygon is a point.
/// </param>
/// <param name="properties">
/// Parameter consisting of the route location fields and the type of events that will be written
/// to the output event table.
/// </param>
/// <param name="filter">An optional filter used to use a subset of the polygon data.</param>
/// <param name="keepAllFields">
/// Allows you to include or disinclude the attributes of the point feature class. If this is
/// set to False, the output event table will only contain the route event properties.
/// </param>
/// <param name="workspace">The workspace that will contain the event data table.</param>
/// <returns>
/// Returns a <see cref="ITable" /> representing the event table of the results.
/// </returns>
public ITable Locate(string locatePolygonsAlongRouteName, IFeatureClass polygons, bool keepZeroLengthEvents, IRouteMeasureLineProperties properties, IQueryFilter filter, bool keepAllFields, IWorkspace workspace)
{
var locator = this.GetRouteLocatorOperations(filter, polygons);
var outputClassName = workspace.Define(locatePolygonsAlongRouteName, new TableNameClass());
workspace.Delete(outputClassName);
return(locator.LocatePolygonFeatures((IRouteEventProperties)properties, keepAllFields, keepZeroLengthEvents, outputClassName, "", null));
}
/// <summary>
/// Locate line features along the route and writes the result to a new line event table.
/// </summary>
/// <param name="locateLinesAlongRouteName">The name of the event table of the located features.</param>
/// <param name="lines">The lines to locate.</param>
/// <param name="clusterTolerance">
/// The cluster tolerance which is a numeric value
/// representing the maximum tolerated distance between the input lines and the target routes.
/// </param>
/// <param name="properties">
/// Parameter consisting of the route location fields and the type of events that will be written
/// to the output event table.
/// </param>
/// <param name="filter">An optional filter used to use a subset of the line data.</param>
/// <param name="keepAllFields">
/// Allows you to include or disinclude the attributes of the point feature class. If this is
/// set to False, the output event table will only contain the route event properties.
/// </param>
/// <param name="workspace">The workspace that will contain the event data table.</param>
/// <returns>
/// Returns a <see cref="ITable" /> representing the event table of the results.
/// </returns>
public ITable Locate(string locateLinesAlongRouteName, IFeatureClass lines, double clusterTolerance, IRouteMeasureLineProperties properties, IQueryFilter filter, bool keepAllFields, IWorkspace workspace)
{
var locator = this.GetRouteLocatorOperations(filter, lines);
var outputClassName = workspace.Define(locateLinesAlongRouteName, new TableNameClass());
workspace.Delete(outputClassName);
return(locator.LocateLineFeatures(clusterTolerance, (IRouteEventProperties)properties, keepAllFields, outputClassName, "", null));
}
/// <summary>
/// Locate point features along the route and writes the result to a new point event table.
/// </summary>
/// <param name="locatePointsAlongRouteName">The name of the event table of the located features.</param>
/// <param name="points">The points to locate.</param>
/// <param name="searchRadius">
/// If the input features are points, the search radius is a numeric value defining how far around each point a search
/// will be done to find a target route. If the input features are lines, the search tolerance is really a cluster
/// tolerance, which is a numeric value
/// representing the maximum tolerated distance between the input lines and the target routes. If the input features
/// are polygons, this parameter is ignored since no search radius is used.
/// </param>
/// <param name="searchMultipleLocations">
/// If the point falls on more than one route for the given search radius, you can
/// have the option to create multiple event records that correspond to each route in the search radius vicinity
/// </param>
/// <param name="properties">
/// Parameter consisting of the route location fields and the type of events that will be written
/// to the output event table.
/// </param>
/// <param name="filter">An optional filter used to use a subset of the point data.</param>
/// <param name="keepAllFields">
/// Allows you to include or disinclude the attributes of the point feature class. If this is
/// set to False, the output event table will only contain the route event properties.
/// </param>
/// <param name="workspace">The workspace that will contain the event data table.</param>
/// <returns>
/// Returns a <see cref="ITable" /> representing the event table of the results.
/// </returns>
public ITable Locate(string locatePointsAlongRouteName, IFeatureClass points, double searchRadius, bool searchMultipleLocations, IRouteMeasurePointProperties properties, IQueryFilter filter, bool keepAllFields, IWorkspace workspace)
{
var locator = this.GetRouteLocatorOperations(filter, points);
var outputClassName = workspace.Define(locatePointsAlongRouteName, new TableNameClass());
workspace.Delete(outputClassName);
return(locator.LocatePointFeatures(searchRadius, searchMultipleLocations, (IRouteEventProperties)properties, keepAllFields, outputClassName, "", null));
}
public Task DeleteAsync(Role role)
{
if (role == null)
{
throw new ArgumentNullException("role");
}
_workspace.Delete(role);
_workspace.SaveChanges();
return(Task.FromResult(0));
}
private void OnDeleteInventoryItem(string obj)
{
if (SelectedRecipeItem != null)
{
if (SelectedRecipeItem.Model.Id > 0)
{
_workspace.Delete(SelectedRecipeItem.Model);
}
Model.RecipeItems.Remove(SelectedRecipeItem.Model);
RecipeItems.Remove(SelectedRecipeItem);
}
}
private void OnDeletePropertyExecuted(string obj)
{
if (SelectedProperty == null)
{
return;
}
if (SelectedProperty.Model.Id > 0)
{
_workspace.Delete(SelectedProperty.Model);
}
Model.Properties.Remove(SelectedProperty.Model);
Properties.Remove(SelectedProperty);
}
private void OnDeleteTicketTagExecuted(string obj)
{
if (SelectedTicketTag == null)
{
return;
}
if (SelectedTicketTag.Model.Id > 0)
{
_workspace.Delete(SelectedTicketTag.Model);
}
Model.TicketTags.Remove(SelectedTicketTag.Model);
TicketTags.Remove(SelectedTicketTag);
}
private void DeleteEntity <T>(IWorkspace workspace, params string[] commandName) where T : class, IEntityClass
{
var name = GetName(commandName, 0);
var acs = workspace.All <T>(x => x.Name == name).ToList();
if (acs.Any())
{
foreach (var ac in acs)
{
workspace.Delete(ac);
workspace.CommitChanges();
}
}
var name2 = GetName(commandName, 1);
acs = workspace.All <T>(x => x.Name == name2).ToList();
if (acs.Any())
{
foreach (var ac in acs)
{
workspace.Delete(ac);
workspace.CommitChanges();
}
}
var name3 = GetName(commandName, 2);
acs = workspace.All <T>(x => x.Name == name3).ToList();
if (acs.Any())
{
foreach (var ac in acs)
{
workspace.Delete(ac);
workspace.CommitChanges();
}
}
}
/// <summary>
/// Identifies those features in the source table that are contained by features in the table being joined.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="join">The spatial table to append fields from.</param>
/// <param name="isLeftOuterJoin">
/// if set to <c>true</c> when a match is required before adding a record from the source
/// feature class to the result. If TRUE, all records in the source feature class are added regardless of whether there
/// is a match.
/// </param>
/// <param name="workspace">The workspace.</param>
/// <param name="outputName">Name of the output.</param>
/// <returns>Returns a <see cref="IFeatureClass" /> representing the joined feature class.</returns>
public static IFeatureClass Within(this IFeatureClass source, ITable join, bool isLeftOuterJoin, IWorkspace workspace, string outputName)
{
ISpatialJoin sj = new SpatialJoinClass();
sj.ShowProcess[true] = 0;
sj.LeftOuterJoin = isLeftOuterJoin;
sj.SourceTable = (ITable)source;
sj.JoinTable = join;
var ds = workspace.Define(outputName, new FeatureClassNameClass());
workspace.Delete(ds);
return(sj.JoinWithin(ds));
}
/// <summary>
/// Creates a feature class containing points generated from specified vertices or locations of the input features.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="outputTableName">Name of the output table.</param>
/// <param name="workspace">The workspace.</param>
/// <param name="trackCancel">The track cancel.</param>
/// <param name="eventHandler">The events.</param>
/// <param name="location">The location.</param>
/// <remarks>License ArcGIS Desktop Advanced: Yes</remarks>
/// <returns>
/// Returns a <see cref="IFeatureClass" /> representing the feature class.
/// </returns>
private static IFeatureClass CreateVertexPointsImpl(IFeatureClass source, string outputTableName, IWorkspace workspace, ITrackCancel trackCancel, IGeoProcessorEvents eventHandler, string location)
{
var tableName = workspace.Define(outputTableName, new FeatureClassNameClass());
workspace.Delete(tableName);
FeatureVerticesToPoints gp = new FeatureVerticesToPoints();
gp.in_features = source;
gp.out_feature_class = workspace.GetAbsolutePath(outputTableName);
gp.point_location = location;
var status = gp.Run(trackCancel, eventHandler);
return(status == esriJobStatus.esriJobSucceeded ? workspace.GetFeatureClass(outputTableName) : null);
}
/// <summary>
/// Overlays two event tables to create an output event table that represents the union or intersection of the input.
/// </summary>
/// <param name="gp">The route event geoprocessor.</param>
/// <param name="type">The type of overlay to be performed.</param>
/// <param name="output">
/// Parameter consisting of the route location fields and the type of events in the overlay event
/// table.
/// </param>
/// <param name="outputTableName">The table to be created.</param>
/// <param name="outputWorkspace">The workspace that will contain the table that has been created.</param>
/// <param name="trackCancel">Allows the operation be be cancelled.</param>
/// <returns>Returns a <see cref="ITable" /> representing the table that has been created.</returns>
private static ITable OverlayImpl(IRouteMeasureEventGeoprocessor2 gp, OverlayType type, IRouteEventProperties2 output, string outputTableName, IWorkspace outputWorkspace, ITrackCancel trackCancel)
{
var outputName = new TableNameClass();
outputName.WorkspaceName = (IWorkspaceName)((IDataset)outputWorkspace).FullName;
outputName.Name = outputTableName;
outputWorkspace.Delete(outputName);
if (type == OverlayType.Union)
{
return(gp.Union2(output, true, outputName, trackCancel, ""));
}
return(gp.Intersect2(output, true, outputName, trackCancel, ""));
}
private void OnDeletePortion(string value)
{
if (SelectedPortion != null)
{
var c = Dao.Count <Recipe>(x => x.Portion.Id == SelectedPortion.Model.Id);
if (c == 0)
{
if (SelectedPortion.Model.Id > 0 && Model.Id > 0)
{
_workspace.Delete(SelectedPortion.Model);
}
Model.Portions.Remove(SelectedPortion.Model);
Portions.Remove(SelectedPortion);
}
}
}
/// <summary>
/// Events will be aggregated where the to-measure of one event matches the from-measure of the next event. This option
/// is applicable only for line events.
/// </summary>
/// <param name="table">The table whose rows will be aggregated.</param>
/// <param name="source">Parameter consisting of the route location fields and the type of events in the input event table.</param>
/// <param name="outputWorkspace"></param>
/// <param name="outputTableName">The table to be created.</param>
/// <param name="output">
/// Parameter consisting of the route location fields and the type of events in the concatenate event
/// table.
/// </param>
/// <param name="trackCancel">The object that allows for monitoring the progress.</param>
/// <param name="concatenateFields">The field(s)used to aggregate rows.</param>
/// <returns>Returns a <see cref="ITable" /> representing the table that has been created.</returns>
public static ITable Concatenate(this ITable table, IRouteEventProperties2 source, IWorkspace outputWorkspace, string outputTableName, IRouteEventProperties2 output, ITrackCancel trackCancel, params string[] concatenateFields)
{
var outputName = new TableNameClass();
outputName.WorkspaceName = (IWorkspaceName)((IDataset)outputWorkspace).FullName;
outputName.Name = outputTableName;
outputWorkspace.Delete(outputName);
IRouteMeasureEventGeoprocessor2 gp = new RouteMeasureGeoprocessorClass();
gp.InputEventProperties = source;
gp.InputTable = table;
gp.KeepZeroLengthLineEvents = false;
return(gp.Concatenate2(output, concatenateFields, outputName, trackCancel, ""));
}
private void OnDelete(string obj)
{
if (InteractionService.UserIntraction.AskQuestion(Resources.DeleteSelectedMappingQuestion))
{
var map = SelectedPrinterMap.Model;
PrinterMaps.Remove(SelectedPrinterMap);
Model.PrinterMaps.Remove(map);
if (_newPrinterMaps.Contains(map))
{
_newPrinterMaps.Remove(map);
}
else
{
_workspace.Delete(map);
_workspace.CommitChanges();
}
}
}
/// <summary>
/// Exports the source table using the query filter to the table in the output workspace.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="filter">The filter.</param>
/// <param name="tableName">Name of the output table.</param>
/// <param name="workspace">The output workspace.</param>
/// <param name="requiredFields">The required fields.</param>
/// <param name="handle">The handle.</param>
/// <param name="keepFeatureDatset">if set to <c>true</c> when the feature class should be created within feature datset.</param>
/// <param name="surrogate">The surrogate for the event handler.</param>
/// <param name="invalid">The errors that occured during the export.</param>
/// <param name="errors">The field errors.</param>
/// <returns>
/// Returns a <see cref="IFeatureClass" /> representing the feature class that was exported.
/// </returns>
public static IFeatureClass Export(this IFeatureClass source, IQueryFilter filter, string tableName, IWorkspace workspace, IFields requiredFields, int handle, bool keepFeatureDatset, FeatureProgress surrogate, out IEnumInvalidObject invalid, out IEnumFieldError errors)
{
var ds = (IDataset)source;
var input = ds.Workspace.Define(ds.Name, new FeatureClassNameClass());
var output = workspace.Define(tableName, new FeatureClassNameClass());
if (source.FeatureDataset != null && keepFeatureDatset)
{
output.FeatureDatasetName = source.FeatureDataset.FullName as IDatasetName;
}
var i = source.Fields.FindField(source.ShapeFieldName);
var field = source.Fields.Field[i];
var clone = (IClone)field.GeometryDef;
var geometryDef = (IGeometryDef)clone.Clone();
workspace.Delete(output);
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = ds.Workspace;
fieldChecker.ValidateWorkspace = workspace;
IFields targetFields;
fieldChecker.Validate(requiredFields, out errors, out targetFields);
var featureDataConverter = new FeatureDataConverterClass();
if (surrogate != null)
{
surrogate.Advise(featureDataConverter);
}
invalid = featureDataConverter.ConvertFeatureClass(input, filter, null, output, geometryDef, targetFields, "", 1000, handle);
return(((IName)output).Open() as IFeatureClass);
}
public SettingGetter GetSetting(string valueName)
{
ProgramSetting setting;
try
{
setting = _workspace.Single <ProgramSetting>(x => x.Name == valueName);
}
catch (Exception)
{
_workspace.Delete <ProgramSetting>(x => x.Name == valueName);
_workspace.CommitChanges();
setting = null;
}
if (_settingCache.ContainsKey(valueName))
{
if (setting == null)
{
setting = _settingCache[valueName];
}
else
{
_settingCache.Remove(valueName);
}
}
if (setting == null)
{
setting = new ProgramSetting {
Name = valueName
};
_settingCache.Add(valueName, setting);
_workspace.Add(setting);
_workspace.CommitChanges();
}
return(new SettingGetter(setting));
}
private static void CreateWarehouseTestContext(WarehouseTestContext testContext, IWorkspace workspace)
{
workspace.Delete<InventoryTransactionType>(x => x.Id > 0);
workspace.Delete<Entity>(x => x.Id > 0);
testContext.Iskender = workspace.Single<MenuItem>(x => x.Name == "İskender");
testContext.Iskender.Portions[0].MenuItemId = testContext.Iskender.Id;
testContext.DonerEti = new InventoryItem { Name = "Döner Eti", BaseUnit = "GR", GroupCode = "", TransactionUnit = "KG", TransactionUnitMultiplier = 1000 };
testContext.Yogurt = new InventoryItem { Name = "Yoğurt", BaseUnit = "GR", GroupCode = "", TransactionUnit = "KG", TransactionUnitMultiplier = 1000 };
testContext.Pide = new InventoryItem { Name = "Pide", BaseUnit = "Yarım", GroupCode = "", TransactionUnit = "Adet", TransactionUnitMultiplier = 2 };
testContext.ZeytinYagi = new InventoryItem { Name = "Zeytin Yağı", BaseUnit = "Ölçü", GroupCode = "", TransactionUnit = "Litre", TransactionUnitMultiplier = 100 };
workspace.Add(testContext.DonerEti);
workspace.Add(testContext.Yogurt);
workspace.Add(testContext.Pide);
workspace.Add(testContext.ZeytinYagi);
testContext.IskenderRecipe = new Recipe { Name = "İskender Reçetesi", Portion = testContext.Iskender.Portions[0] };
workspace.Add(testContext.IskenderRecipe);
testContext.IskenderRecipe.RecipeItems.Add(new RecipeItem { InventoryItem = testContext.DonerEti, Quantity = 120 });
testContext.IskenderRecipe.RecipeItems.Add(new RecipeItem { InventoryItem = testContext.Yogurt, Quantity = 50 });
testContext.IskenderRecipe.RecipeItems.Add(new RecipeItem { InventoryItem = testContext.Pide, Quantity = 2 });
testContext.IskenderRecipe.RecipeItems.Add(new RecipeItem { InventoryItem = testContext.ZeytinYagi, Quantity = 1 });
testContext.LocalWarehouseAccountType = new AccountType { Name = "Local Warehouse Account Type" };
testContext.SellerWarehouseAccountType = new AccountType { Name = "Seller Warehouse Account Type" };
workspace.Add(testContext.LocalWarehouseAccountType);
workspace.Add(testContext.SellerWarehouseAccountType);
testContext.WarehouseType = workspace.Single<WarehouseType>(x => x.Name == Resources.Warehouses);
testContext.WarehouseEntityType = new EntityType { Name = "Warehouse Resource Type" };
workspace.Add(testContext.WarehouseEntityType);
testContext.LocalWarehouseAccount = new Account { AccountTypeId = testContext.LocalWarehouseAccountType.Id };
testContext.Seller1Account = new Account { AccountTypeId = testContext.SellerWarehouseAccountType.Id };
testContext.Seller2Account = new Account { AccountTypeId = testContext.SellerWarehouseAccountType.Id };
workspace.Add(testContext.LocalWarehouseAccount);
workspace.Add(testContext.Seller1Account);
workspace.Add(testContext.Seller2Account);
testContext.LocalWarehouse = new Warehouse
{
WarehouseTypeId = testContext.WarehouseType.Id
};
testContext.BarWarehouse = new Warehouse
{
WarehouseTypeId = testContext.WarehouseType.Id
};
testContext.Seller1Warehouse = new Warehouse
{
WarehouseTypeId = testContext.WarehouseType.Id
};
testContext.Seller2Warehouse = new Warehouse
{
WarehouseTypeId = testContext.WarehouseType.Id
};
workspace.Add(testContext.LocalWarehouse);
workspace.Add(testContext.BarWarehouse);
workspace.Add(testContext.Seller1Warehouse);
workspace.Add(testContext.Seller2Warehouse);
testContext.LocalWarehouseEntity = new Entity
{
WarehouseId = testContext.LocalWarehouse.Id,
EntityTypeId = testContext.WarehouseEntityType.Id,
AccountId = testContext.LocalWarehouseAccount.Id
};
testContext.BarWarehouseEntity = new Entity
{
WarehouseId = testContext.BarWarehouse.Id,
EntityTypeId = testContext.WarehouseEntityType.Id
};
testContext.Seller1WarehouseEntity = new Entity
{
WarehouseId = testContext.Seller1Warehouse.Id,
EntityTypeId = testContext.WarehouseEntityType.Id,
AccountId = testContext.Seller1Account.Id
};
testContext.Seller2WarehouseEntity = new Entity
{
WarehouseId = testContext.Seller2Warehouse.Id,
EntityTypeId = testContext.WarehouseEntityType.Id,
AccountId = testContext.Seller2Account.Id
};
workspace.Add(testContext.LocalWarehouseEntity);
workspace.Add(testContext.BarWarehouseEntity);
workspace.Add(testContext.Seller1WarehouseEntity);
workspace.Add(testContext.Seller2WarehouseEntity);
testContext.PurchaseAccountTransactionType = new AccountTransactionType
{
SourceAccountTypeId =
testContext.SellerWarehouseAccountType.Id,
TargetAccountTypeId =
testContext.LocalWarehouseAccountType.Id,
DefaultTargetAccountId =
testContext.LocalWarehouseAccount.Id
};
workspace.Add(testContext.PurchaseAccountTransactionType);
testContext.PurchaseTransactionType = new InventoryTransactionType
{
Name = "PurchaseTransaction",
SourceWarehouseTypeId = testContext.WarehouseType.Id,
TargetWarehouseTypeId = testContext.WarehouseType.Id,
DefaultSourceWarehouseId = testContext.Seller1Warehouse.Id,
DefaultTargetWarehouseId = testContext.LocalWarehouse.Id,
};
testContext.PurchaseTransactionDocumentType = new InventoryTransactionDocumentType
{
AccountTransactionType = testContext.PurchaseAccountTransactionType,
InventoryTransactionType = testContext.PurchaseTransactionType,
SourceEntityTypeId = testContext.WarehouseEntityType.Id,
TargetEntityTypeId = testContext.WarehouseEntityType.Id,
DefaultSourceEntityId = testContext.Seller1WarehouseEntity.Id,
DefaultTargetEntityId = testContext.LocalWarehouseEntity.Id
};
testContext.BarTransferTransactionType = new InventoryTransactionType
{
Name = "Bar Transfer",
SourceWarehouseTypeId = testContext.WarehouseType.Id,
TargetWarehouseTypeId = testContext.WarehouseType.Id,
DefaultSourceWarehouseId = testContext.LocalWarehouse.Id,
DefaultTargetWarehouseId = testContext.BarWarehouse.Id
};
testContext.BarTransferTransactionDocumentType = new InventoryTransactionDocumentType
{
InventoryTransactionType = testContext.BarTransferTransactionType,
SourceEntityTypeId = testContext.WarehouseEntityType.Id,
TargetEntityTypeId = testContext.WarehouseEntityType.Id,
DefaultSourceEntityId = testContext.LocalWarehouseEntity.Id,
DefaultTargetEntityId = testContext.BarWarehouseEntity.Id
};
workspace.Add(testContext.PurchaseTransactionType);
workspace.Add(testContext.BarTransferTransactionType);
testContext.Department = workspace.Single<Department>(x => x.Name == "Restoran");
testContext.Department.WarehouseId = testContext.LocalWarehouse.Id;
ApplicationStateSetter.SetCurrentDepartment(testContext.Department.Id);
WorkPeriodService.StartWorkPeriod("");
Thread.Sleep(1);
}
public void DeleteEntity <T>(T item) where T : class
{
_workspace.Delete <T>(item);
_workspace.CommitChanges();
}
private void DoDeleteItem(TModel item)
{
BeforeDeleteItem(item);
_workspace.Delete(item);
_workspace.CommitChanges();
}
