//protected static void OnPropertyChanged(DependencyObject target, DependencyPropertyChangedEventArgs e)
//{
// var collectionSource = target as DataObjectCollectionSource;
// if (collectionSource == null) return;
// if (e.Property == ItemsSourceProperty)
// {
// bool hasNewValue = e.NewValue != null;
// collectionSource.AttachToEntitySource(hasNewValue, (IDataObjectCollection)e.NewValue);
// }
// else if (e.Property == RowSelectorProperty)
// {
// collectionSource._rowSelector = e.NewValue as IDataObjectSelector;
// }
// else if (e.Property == SorterProperty)
// {
// collectionSource._sorter = e.NewValue as IDataObjectSorter;
// }
// else if (e.Property == EntityFilterProperty)
// {
// collectionSource._dataObjectFilter = e.NewValue as IDataObjectFilter;
// }
//}
private void AttachToEntitySource(bool hasNewValue, IDataObjectCollection view)
{
if (_currentEntitySource != null)
{
_currentEntitySource.CollectionChanged -= _weakEventHandler.Invoke;
_currentEntitySource.EntityPropertyChanged -= _entityPropertyChangedHandler.Invoke;
}
_weakEventHandler = null;
_entityPropertyChangedHandler = null;
if (hasNewValue)
{
_currentEntitySource = view;
_weakEventHandler = new WeakEventHandler <NotifyCollectionChangedEventArgs>(ListChanged);
_entityPropertyChangedHandler = new WeakEventHandler <PropertyChangedEventArgs>(EntityPropertyChanged);
_currentEntitySource.CollectionChanged += _weakEventHandler.Invoke;
_currentEntitySource.EntityPropertyChanged += _entityPropertyChangedHandler.Invoke;
if (this.Selector != null)
{
SelectRows();
}
else
{
UpdateViewSource();
}
}
else
{
_currentEntitySource = null;
lock (_itemsSourceLock)
{
_viewSource.Clear();
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Method gets sorted collection.
/// </summary>
/// <returns>Sorted collection.</returns>
private SortedDataObjectCollection <Zone> _GetSortedCollection()
{
IDataObjectCollection <Zone> zones = (IDataObjectCollection <Zone>)App.Current.Project.Zones;
SortedDataObjectCollection <Zone> sortedCollection = new SortedDataObjectCollection <Zone>(zones, new CreationTimeComparer <Zone>());
return(sortedCollection);
}
/// <summary>
/// Constructor.
/// </summary>
public DefaultRoutesController(IDataObjectCollection <Route> routes)
{
// Check input parameter.
Debug.Assert(routes != null);
// Save routes as old default collection.
_oldDefaultRoutes = new List <Route>();
_oldDefaultRouteLinks = new List <RouteLinks>();
foreach (Route route in routes)
{
var tempRoute = route.CloneNoResults() as Route;
_oldDefaultRoutes.Add(tempRoute);
// Workaround: when application will call Project.Save method next time
// all reference properties of tempRoute which points on database object
// will be set to null, so we need to remeber this links. Do it by using
// special structure with corresponding fields.
RouteLinks tempRouteLinks = new RouteLinks();
tempRouteLinks.StartLocation = route.StartLocation;
tempRouteLinks.EndLocation = route.EndLocation;
tempRouteLinks.Vehicle = route.Vehicle;
tempRouteLinks.Driver = route.Driver;
tempRouteLinks.Zones = route.Zones;
tempRouteLinks.RenewalLocations = route.RenewalLocations;
tempRouteLinks.savedRouteID = tempRoute.Id;
_oldDefaultRouteLinks.Add(tempRouteLinks);
}
}
/// <summary>
/// Export route to GRF file.
/// </summary>
/// <param name="writer">XMLWriter.</param>
/// <param name="route">Route to export.</param>
/// <param name="stops">Route's stops.</param>
/// <param name="project">Project, which contains this route.</param>
/// <param name="geocoder">Geocoder.</param>
/// <param name="solver">Solver.</param>
/// <param name="orderPropertiesToExport">Collection of order properties, which must be
/// exported.</param>
/// <param name="compress">Flag, shows compress result file or not.</param>
/// <returns>GrfExportResult which contains messages about exporting.</returns>
public static GrfExportResult ExportToGRF(XmlWriter writer, Route route, ICollection <Stop> stops, Project project,
IGeocoder geocoder, IVrpSolver solver, ICollection <string> orderPropertiesToExport, bool compress)
{
GrfExportResult result = new GrfExportResult();
writer.WriteStartElement(GRF_DOC_NODE_NAME);
writer.WriteAttributeString(VERSION_ATTR_NAME, VERSION_VALUE);
writer.WriteStartElement(ROUTEINFO_NODE_NAME);
if (stops.Count > 0)
{
_SaveStops(
writer,
route,
stops,
orderPropertiesToExport,
project,
geocoder.AddressFields);
}
IDataObjectCollection <Barrier> barriers =
(IDataObjectCollection <Barrier>)project.Barriers.Search(route.StartTime.Value.Date, true);
_SaveBarriers(writer, barriers, result);
_SaveRouteResults(writer, route, stops);
writer.WriteEndElement();
_SaveRouteSettings(writer, route, solver, result);
writer.WriteEndElement();
return(result);
}
/// <summary>
/// Method unpacks dragging objects from dragging data
/// </summary>
/// <param name="draggingData"></param>
/// <returns></returns>
public Collection <Order> GetDraggingOrders(IDataObject draggingData)
{
Collection <Order> draggingObjects = new Collection <Order>();
// get collection of dragging elements
if (draggingData.GetDataPresent(DRAGGING_DATA_FORMAT_STRING))
{
// get data from data.GetData("format");
DraggingOrdersObject draggingObject = (DraggingOrdersObject)draggingData.GetData(DRAGGING_DATA_FORMAT_STRING);
IDataObjectCollection <Order> ordersForDate = App.Current.Project.Orders.Search(draggingObject.OrdersPlannedDate);
foreach (Order order in ordersForDate)
{
foreach (Guid id in draggingObject.IDsCollection)
{
if (order.Id.Equals(id))
{
draggingObjects.Add(order);
}
}
}
}
return(draggingObjects);
}
/// <summary>
/// Writes stops content.
/// </summary>
/// <param name="data">Data keeper.</param>
/// <param name="schedules">Schedules to export.</param>
/// <param name="fields">Exported fields.</param>
/// <param name="writeOnlyOrders">Write only orders flag.</param>
/// <param name="tracker">Cancel tracker (can be null).</param>
/// <param name="sw">Export writer.</param>
private void _WriteStopsContent(DataKeeper data,
ICollection <Schedule> schedules,
ICollection <string> fields,
bool writeOnlyOrders,
ICancelTracker tracker,
StreamWriter sw)
{
foreach (Schedule schedule in schedules)
{
Guid scheduleID = schedule.Id;
foreach (Route route in schedule.Routes)
{ // stops
IDataObjectCollection <Stop> stops = route.Stops;
foreach (Stop stop in stops)
{
_CheckCancelState(tracker);
if (!writeOnlyOrders ||
(writeOnlyOrders && (stop.StopType == StopType.Order)))
{
string exportString = _AssemblyStopString(fields,
data,
scheduleID,
stop,
tracker);
Debug.Assert(!string.IsNullOrEmpty(exportString));
sw.WriteLine(exportString);
}
}
}
_WriteUnassignedOrdersContent(data, schedule, fields, tracker, sw);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
protected override void DoValidate(IDataObjectCollection <Zone> objectToValidate, object currentTarget, string key,
ValidationResults validationResults)
{
if (null == objectToValidate)
{
return;
}
string format = this.MessageTemplate;
StringBuilder sb = new StringBuilder();
foreach (Zone zone in objectToValidate)
{
string error = zone.Error;
if (!string.IsNullOrEmpty(error))
{
sb.AppendLine(string.Format(format, zone.Name));
}
}
string message = sb.ToString().Trim();
if (!string.IsNullOrEmpty(message))
{
this.LogValidationResult(validationResults, message, currentTarget, key);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates copy all elements.
/// </summary>
/// <param name="source">Source collection.</param>
/// <returns>Collection with copy elements for source.</returns>
private ICollection <T> _DoCopy <T>(ICollection <T> source)
where T : ICloneable
{
var copy = new List <T>(source.Count);
foreach (T obj in source)
{
T objCopy = (T)obj.Clone();
// WORKAROUND: special routine for schedule - need init Unassigned Orders
Schedule scheduleCopy = objCopy as Schedule;
if (null != scheduleCopy)
{
Schedule schedule = obj as Schedule;
Debug.Assert(null != obj);
IDataObjectCollection <Order> unassignedOrders = schedule.UnassignedOrders;
if (null != unassignedOrders)
{
scheduleCopy.UnassignedOrders = unassignedOrders;
}
}
copy.Add(objCopy);
}
return(copy);
}
/// <summary>
/// Updates the first schedule of specified type with a new value and name.
/// </summary>
private void _UpdateSchedule(ScheduleType scheduleTypeToUpdate, Schedule newValue, string newName)
{
// get all schedules
Project project = App.Current.Project;
IDataObjectCollection <Schedule> schedules = project.Schedules.Search(newValue.PlannedDate.Value, false);
// and try to find schedule of specified type.
Schedule oldSchedule = null;
foreach (Schedule schedule in schedules)
{
if (schedule.Type == scheduleTypeToUpdate)
{
oldSchedule = schedule;
break;
}
}
// delete old schedule if present
if (oldSchedule != null)
{
project.Schedules.Remove(oldSchedule);
}
// create new schedule and add it to the project
Schedule updatedSchedule = (Schedule)newValue.Clone();
updatedSchedule.Type = scheduleTypeToUpdate;
updatedSchedule.Name = newName;
project.Schedules.Add(updatedSchedule);
}
/// <summary>
/// Find order.
/// </summary>
private void _FindOrder()
{
Cursor = Cursors.Wait;
try
{
// Get range.
string keyword = txtOrderText.Text;
DateTime currentDate = DateTime.Now.Date;
TimeRanges rangeType = (TimeRanges)cbSearch.SelectedIndex;
TimeRange range = null;
if (rangeType == TimeRanges.SpecifiedTimeRange)
{
if (dpFrom.SelectedDate.HasValue && dpTo.SelectedDate.HasValue)
{
range = new TimeRange(dpFrom.SelectedDate.Value.Date, dpTo.SelectedDate.Value.Date);
}
}
else
{
range = TimeRangeHelper.GetRange(currentDate, rangeType);
}
// If range valid make search.
if (range != null)
{
if (_previousOrdersCollection != null)
{
_previousOrdersCollection.Dispose();
_previousOrdersCollection = null;
}
OrderManager manager = App.Current.Project.Orders;
IDataObjectCollection <Order> orders = manager.SearchByKeyword(range.Start, range.End.AddDays(1), keyword, true);
// Store orders collection to dispose.
_previousOrdersCollection = orders;
UpdateLayout();
_collectionSource.Source = null;
// Set orders collection.
_collectionSource.Source = orders;
// Save last search criteria.
Properties.Settings.Default.FindOrdersLastKeyword = txtOrderText.Text;
Properties.Settings.Default.FindOrdersSearchCriteria =
TimeRangeHelper.GetRangeSettingsName(rangeType);
Properties.Settings.Default.Save();
_needToClearSelection = true;
}
}
finally
{
Cursor = Cursors.Arrow;
}
}
/// <summary>
/// Inits collecton of grid items
/// </summary>
protected override void _InitDataGridCollection()
{
DataGridCollectionViewSource vehicleCollectionSource = (DataGridCollectionViewSource)base.LayoutRoot.FindResource(COLLECTION_SOURCE_KEY);
IDataObjectCollection <VehicleSpecialty> vehiclesSpecialtiesCollection = (IDataObjectCollection <VehicleSpecialty>)App.Current.Project.VehicleSpecialties;
SortedDataObjectCollection <VehicleSpecialty> sortedVehicleSpecialtiesCollection = new SortedDataObjectCollection <VehicleSpecialty>(vehiclesSpecialtiesCollection, new CreationTimeComparer <VehicleSpecialty>());
vehicleCollectionSource.Source = sortedVehicleSpecialtiesCollection;
}
/// <summary>
/// Initializes a new instance of the <see cref="RoutesCollectionOwner"/> class.
/// </summary>
/// <param name="routes">A collection of routes owned by this instance.</param>
public RoutesCollectionOwner(IDataObjectCollection <Route> routes)
{
CodeContract.RequiresNotNull("routes", routes);
_routes = routes;
_routes.CollectionChanged += _RoutesCollectionChanged;
_TrackAssociations();
}
/// <summary>
/// Initializes a new instance of the <see cref="RoutesCollectionOwner"/> class.
/// </summary>
/// <param name="routes">A collection of routes owned by this instance.</param>
public RoutesCollectionOwner(IDataObjectCollection<Route> routes)
{
CodeContract.RequiresNotNull("routes", routes);
_routes = routes;
_routes.CollectionChanged += _RoutesCollectionChanged;
_TrackAssociations();
}
/// <summary>
/// Creates data object context for the specified data objects collection.
/// </summary>
/// <typeparam name="T">The type of data objects in the source collection.</typeparam>
/// <param name="source">The reference to the data objects collection to create data object
/// context for.</param>
/// <returns>A new key-value pair containing <typeparamref name="T"/> as a key and
/// data object context for the <paramref name="source"/> as a value.</returns>
private static KeyValuePair <Type, IDataObjectContext> _MakeContext <T>(
IDataObjectCollection <T> source)
where T : DataObject
{
return(new KeyValuePair <Type, IDataObjectContext>(
typeof(T),
new RelatedDataObjectCollectionContext <T>(source)));
}
/// <summary>
/// Returns orders.
/// </summary>
/// <param name="initialQuery">Intial query to the database.</param>
/// <param name="queryParams">Parameters for the query.</param>
/// <param name="filterClause">Filter clause used for syncronized data object collections.</param>
/// <returns>Collection of founded orders.
/// It is syncronized in <c>filterClause</c> isn't null.</returns>
protected IDataObjectCollection <Order> _SearchOrders(string initialQuery,
ObjectParameter[] queryParams,
Expression <Func <DataModel.Orders, bool> > filterClause)
{
IDataObjectCollection <Order> result = _Search(initialQuery, queryParams, filterClause);
return(result);
}
/// <summary>
/// Initializes a new instance of the RelatedDataObjectCollectionContext class.
/// </summary>
/// <param name="source">Source collection of data objects to track changes for.</param>
public RelatedDataObjectCollectionContext(IDataObjectCollection <T> source)
{
Debug.Assert(source != null);
Debug.Assert(source.All(item => item != null));
_source = source;
_Reset();
}
private void _FilterDrivers(IDataObjectCollection <Route> routes, IList filterObjects,
ref Collection <ESRI.ArcLogistics.Data.DataObject> filtredObjects)
{
for (int index = 0; index < routes.Count; ++index)
{
_FilterObject(routes[index].Driver, filterObjects, ref filtredObjects);
}
}
/// <summary>
/// Checks is object present in object collection.
/// </summary>
/// <param name="currentObj">Object to check.</param>
/// <param name="collection">Object's collection.</param>
/// <returns>TRUE if cheked object present in collection.</returns>
private bool _IsObjectPresentInCollection <T>(T currentObj,
IDataObjectCollection <T> collection)
where T : DataObject
{
string objName = currentObj.ToString();
return(collection.Any(obj =>
obj.ToString().Equals(objName, StringComparison.OrdinalIgnoreCase)));
}
/// <summary>
/// Filteres objects
/// </summary>
/// <param name="objects">Collection of objects to filtration</param>
/// <param name="filterObjects">Filter collection</param>
/// <param name="usedObjects">Filtred objects</param>
/// <remarks>To filtredObjects adding unique object only from filterObjects</remarks>
protected void _FilterObjects <T>(IDataObjectCollection <T> objects, IList filterObjects,
ref Collection <ESRI.ArcLogistics.Data.DataObject> usedObjects)
where T : ESRI.ArcLogistics.Data.DataObject
{
for (int specIndex = 0; specIndex < objects.Count; ++specIndex)
{
_FilterObject(objects[specIndex], filterObjects, ref usedObjects);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
private void _Init(IDataObjectCollection <T> coll,
IComparer <T> comparer)
{
// fill collection
_sortedList.AddRange(coll);
// sort
_sortedList.Sort(comparer);
}
/// <summary>
/// Returns orders where clause on a expression.
/// </summary>
/// <param name="whereClause">Expression for filtation collections.</param>
/// <param name="asSynchronized">Indicates whether collection remains syncronized
/// when orders are added or deleted to the project database.</param>
/// <returns>Syncronized collection of found orders.</returns>
protected IDataObjectCollection <Order> _SearchOrders(
Expression <Func <DataModel.Orders, bool> > whereClause,
bool asSynchronized)
{
Expression <Func <DataModel.Orders, bool> > expression =
asSynchronized ? whereClause : null;
IDataObjectCollection <Order> result = _Search(whereClause, expression);
return(result);
}
/// <summary>
/// Method check is property value was really changed.
/// </summary>
/// <param name="propertyName"></param>
/// <param name="editedRoute"></param>
/// <returns></returns>
private bool _WasPropetyValueChanged(string propertyName, Route editedRoute)
{
PropertyInfo newInfo = editedRoute.GetType().GetProperty(propertyName);
object newValue = newInfo.GetValue(editedRoute, null);
// check Zones value
if (newValue is IDataObjectCollection <Zone> )
{
IDataObjectCollection <Zone> newCollection = (IDataObjectCollection <Zone>)newValue;
ICollection <Zone> oldCollection = (ICollection <Zone>)_initialRouteProperties[propertyName];
if (newCollection.Count != oldCollection.Count)
{
return(true);
}
foreach (Zone newLocation in newCollection)
{
if (!oldCollection.Contains(newLocation))
{
return(true);
}
}
return(false);
}
// check Locations value
if (newValue is IDataObjectCollection <Location> )
{
IDataObjectCollection <Location> newCollection = (IDataObjectCollection <Location>)newValue;
ICollection <Location> oldCollection = (ICollection <Location>)_initialRouteProperties[propertyName];
if (newCollection.Count != oldCollection.Count)
{
return(true);
}
foreach (Location newLocation in newCollection)
{
if (!oldCollection.Contains(newLocation))
{
return(true);
}
}
return(false);
}
object newObjValue = newInfo.GetValue(editedRoute, null);
if (newObjValue is Boolean)
{
return(!_initialRouteProperties[propertyName].Equals(newObjValue));
}
return(_initialRouteProperties[propertyName] != newObjValue);
}
private void _Reset(IDataObjectCollection <TDataObj> dataObjects)
{
_dataObjects.Clear();
List <TDataObj> coll = new List <TDataObj>(dataObjects);
foreach (TDataObj obj in coll)
{
_dataObjects.Add(obj);
}
}
private void _FilterLocations(IDataObjectCollection <Route> routes, IList filterObjects,
ref Collection <ESRI.ArcLogistics.Data.DataObject> filtredObjects)
{
for (int index = 0; index < routes.Count; ++index)
{
Route route = routes[index];
_FilterObject(route.StartLocation, filterObjects, ref filtredObjects);
_FilterObject(route.EndLocation, filterObjects, ref filtredObjects);
_FilterObjects(route.RenewalLocations, filterObjects, ref filtredObjects);
}
}
/// <summary>
/// Method sets grid data binding.
/// </summary>
private void _InitDataGridCollection()
{
IDataObjectCollection <Schedule> schedules = _ScheduleVersions;
if (schedules != null)
{
schedules.Dispose();
}
schedules = (IDataObjectCollection <Schedule>)App.Current.Project.Schedules.Search(App.Current.CurrentDate, true);
SortedDataObjectCollection <Schedule> sortedScheduleCollection = new SortedDataObjectCollection <Schedule>(schedules, new ScheduleVersionComparer());
_DataGridSource.Source = sortedScheduleCollection;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <c>SortedDataObjectCollection</c> class.
/// </summary>
public SortedDataObjectCollection(IDataObjectCollection <T> coll,
IComparer <T> comparer)
{
Debug.Assert(coll != null);
Debug.Assert(comparer != null);
_Init(coll, comparer);
coll.CollectionChanged += new NotifyCollectionChangedEventHandler(
_coll_CollectionChanged);
_coll = coll;
_comparer = comparer;
}
/// <summary>
/// Get objects, which must be in startup extent.
/// </summary>
/// <returns>Objects, which must be in startup extent.</returns>
private List <object> _GetScheduleExtentCollection()
{
List <object> scheduleList = new List <object>();
IDataObjectCollection <Order> unassignedOrders = (IDataObjectCollection <Order>)_unassignedOrdersColl;
if (_stopOrders.Count + unassignedOrders.Count > 0)
{
if (_routesColl != null)
{
// Add stops to extent.
foreach (Stop stop in _stopOrders)
{
scheduleList.Add(stop);
}
// Add routes to extent.
foreach (Route route in _routesColl)
{
scheduleList.Add(route);
}
}
if (_unassignedOrdersColl != null)
{
// Add orders to extent.
foreach (Order order in _unassignedOrdersColl)
{
scheduleList.Add(order);
}
}
}
else
{
// Add zones to extent.
foreach (Zone zone in App.Current.Project.Zones)
{
scheduleList.Add(zone);
}
// Add locations to extent.
foreach (Location location in App.Current.Project.Locations)
{
scheduleList.Add(location);
}
}
return(scheduleList);
}
/// <summary>
/// Creates violation messages for route's specialities.
/// </summary>
/// <param name="obj">Violation's object (can be any DataObject: Vehicle, Driver and etc).</param>
/// <param name="relatedObjects">Related object's.</param>
/// <returns>Created violation messages for route's specialities.</returns>
private static ICollection <MessageDetail> _GetSpecialitiesRouteViolationMessages(DataObject obj,
ICollection <DataObject> relatedObjects)
{
Debug.Assert(obj is Route);
Route route = obj as Route;
IDataObjectCollection <VehicleSpecialty> routeVehSpecialties = route.Vehicle.Specialties;
IDataObjectCollection <DriverSpecialty> routeDrvSpecialties = route.Driver.Specialties;
Collection <DataObject> ordersVehSpecNotSupported = new Collection <DataObject>();
Collection <DataObject> ordersDrvSpecNotSupported = new Collection <DataObject>();
foreach (DataObject relatedObj in relatedObjects)
{
Order order = relatedObj as Order;
if (null != order)
{
foreach (DriverSpecialty specialty in order.DriverSpecialties)
{
if (!routeDrvSpecialties.Contains(specialty))
{
ordersDrvSpecNotSupported.Add(specialty);
}
}
foreach (VehicleSpecialty specialty in order.VehicleSpecialties)
{
if (!routeVehSpecialties.Contains(specialty))
{
ordersVehSpecNotSupported.Add(specialty);
}
}
}
}
Collection <MessageDetail> details = new Collection <MessageDetail>();
if (0 < ordersDrvSpecNotSupported.Count)
{
details.Add(_GetRouteViolationMessageStr(obj, ordersDrvSpecNotSupported, "DriverSpecialitiesRouteViolationMessage"));
}
if (0 < ordersVehSpecNotSupported.Count)
{
details.Add(_GetRouteViolationMessageStr(obj, ordersVehSpecNotSupported, "VehicleSpecialitiesRouteViolationMessage"));
}
return(details);
}
/// <summary>
/// Method makes new edited version of a schedule.
/// </summary>
/// <param name="baseSchedule">Source schedule version.</param>
/// <param name="otherVersions">Existed schedule versions.</param>
/// <returns>Copied schedule version.</returns>
private Schedule _MakeScheduleVersion(Schedule baseSchedule, IDataObjectCollection <Schedule> otherVersions)
{
Debug.Assert(baseSchedule != null);
Schedule newVersion = (Schedule)baseSchedule.Clone();
int latestVersionIndex = _GetLatestVersionIndex(otherVersions);
newVersion.Name = (latestVersionIndex == 0) ?
(string)App.Current.FindResource("ClonedScheduleNameFormatWithoutNumber") :
string.Format((string)App.Current.FindResource("ClonedScheduleNameFormat"), latestVersionIndex);
newVersion.Type = ScheduleType.Edited;
return(newVersion);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Get schedule by day
/// </summary>
/// <param name="schedule"></param>
/// <returns></returns>
public static Schedule GetCurrentScheduleByDay(DateTime day)
{
IDataObjectCollection <Schedule> schedules = App.Current.Project.Schedules.Search(day);
Schedule selectedSchedule = null;
foreach (Schedule schedule in schedules)
{
if (ScheduleType.Current == schedule.Type)
{
selectedSchedule = schedule;
break;
}
}
return(selectedSchedule);
}
/// <summary>
/// Method inits collection of drivers.
/// </summary>
protected void _InitDataGridCollection()
{
try
{
DataGridCollectionViewSource collectionSource = (DataGridCollectionViewSource)LayoutRoot.FindResource(COLLECTION_SOURCE_KEY);
IDataObjectCollection <Driver> collection = (IDataObjectCollection <Driver>)App.Current.Project.Drivers;
SortedDataObjectCollection <Driver> sortedDriversCollection = new SortedDataObjectCollection <Driver>(collection, new CreationTimeComparer <Driver>());
collectionSource.Source = sortedDriversCollection;
_isDataGridCollectionInited = true;
}
catch (Exception ex)
{
_isDataGridCollectionInited = false;
Logger.Info(ex);
}
}
/// <summary>
/// When route added to or removed from schedule we need to subscribe(unsubscribe) from event.
/// </summary>
/// <param name="sender">Ignored.</param>
/// <param name="e">CollectionChangeEventArgs.</param>
void SchedulesReference_AssociationChanged(object sender, CollectionChangeEventArgs e)
{
// If we added this route to schedule, remember it schedule.routes, subscribe to
// collection changed event and clear _DefaultsRoutes if we haven't done this before.
if (e.Action == CollectionChangeAction.Add)
{
if (_ScheduledRoutesCollection == null ||
_ScheduledRoutesCollection != Schedule.Routes)
{
_AddScheduledRoutesCollectionChangedHandler();
}
}
// If we removed route from collection - then unsubscribe from this
// collection changed event and clear reference to this collection.
if (e.Action == CollectionChangeAction.Remove)
{
_ScheduledRoutesCollection.CollectionChanged -= _ScheduleCollectionChanged;
_ScheduledRoutesCollection = null;
}
}
/// <summary>
/// Constructor.
/// </summary>
public DefaultRoutesController(IDataObjectCollection<Route> routes)
{
// Check input parameter.
Debug.Assert(routes != null);
// Save routes as old default collection.
_oldDefaultRoutes = new List<Route>();
_oldDefaultRouteLinks = new List<RouteLinks>();
foreach (Route route in routes)
{
var tempRoute = route.CloneNoResults() as Route;
_oldDefaultRoutes.Add(tempRoute);
// Workaround: when application will call Project.Save method next time
// all reference properties of tempRoute which points on database object
// will be set to null, so we need to remeber this links. Do it by using
// special structure with corresponding fields.
RouteLinks tempRouteLinks = new RouteLinks();
tempRouteLinks.StartLocation = route.StartLocation;
tempRouteLinks.EndLocation = route.EndLocation;
tempRouteLinks.Vehicle = route.Vehicle;
tempRouteLinks.Driver = route.Driver;
tempRouteLinks.Zones = tempRoute.Zones;
tempRouteLinks.RenewalLocations = tempRoute.RenewalLocations;
tempRouteLinks.savedRouteID = tempRoute.Id;
_oldDefaultRouteLinks.Add(tempRouteLinks);
}
}
/// <summary>
/// Remember ref to current scheduled routes, subscribe to scheduled routes
/// collection changed event and clear default routes collection.
/// </summary>
private void _AddScheduledRoutesCollectionChangedHandler()
{
this.Schedule.RoutesCollectionInitialized -= _ScheduleRoutesCollectionInitialized;
_ScheduledRoutesCollection = this.Schedule.Routes;
_ScheduledRoutesCollection.CollectionChanged += _ScheduleCollectionChanged;
if (_DefaultRoutesCollection != null)
(this as ISupportOwnerCollection).OwnerCollection = null;
}
