private OrderGraphicObject(Order order)
: base(order)
{
_order = order;
_order.PropertyChanged += new PropertyChangedEventHandler(_order_PropertyChanged);
Geometry = _CreatePoint(order);
}
protected override List<Guid> GetOrderSpecIds(Order order)
{
List<Guid> specs = base.GetOrderSpecIds(order);
if (_setAssignmentSpec && _unlockedOrdersToAssign.Contains(order))
specs.Add(ASSIGNMENT_SPEC_ID);
return specs;
}
public void Execute(params object[] args)
{
m_application.Messenger.AddInfo("Executing import from QuickBooks.");
int countOrdersAdded = 0;
QBSessionManager session = null;
try
{
// Start session with QuickBooks
session = new QBSessionManager();
session.OpenConnection("123", "ArcLogistics PlugIn: QuickBooksPlugIns.ImportOrdersFromInvoicesCmd");
session.BeginSession("", ENOpenMode.omDontCare);
IInvoiceRetList invoiceList = QueryInvoices(session);
int invoiceCount = invoiceList.Count;
for (int i = 0; i < invoiceCount; i++)
{
IInvoiceRet invoiceRet = invoiceList.GetAt(i);
ESRI.ArcLogistics.DomainObjects.Order newOrder = MakeOrderFromInvoice(invoiceRet, session);
m_application.Project.Orders.Add(newOrder);
countOrdersAdded++;
}
}
catch (Exception e)
{
m_application.Messenger.AddError("Error executing QuickBooksPlugIns.ImportOrdersFromInvoicesCmd: " + e.Message);
}
finally
{
// Close connection because we don't need it anymore
if (session != null)
{
session.EndSession();
session.CloseConnection();
}
m_application.Project.Save();
m_application.Messenger.AddInfo(countOrdersAdded.ToString() + " orders added.");
}
}
/// <summary>
/// Create graphic object for order
/// </summary>
/// <param name="order">Source order</param>
/// <returns>Graphic object for order</returns>
public static OrderGraphicObject Create(Order order)
{
OrderGraphicObject graphic = null;
graphic = new OrderGraphicObject(order);
Color color = Color.FromRgb(0, 0, 0);
graphic.Attributes.Add(SymbologyContext.FILL_ATTRIBUTE_NAME, new SolidColorBrush(color));
graphic.Attributes.Add(SymbologyContext.OFFSETX_ATTRIBUTE_NAME,
-(SymbologyManager.DEFAULT_SIZE - SymbologyManager.DEFAULT_INDENT / 2));
graphic.Attributes.Add(SymbologyContext.OFFSETY_ATTRIBUTE_NAME,
-(SymbologyManager.DEFAULT_SIZE - SymbologyManager.DEFAULT_INDENT / 2));
graphic.Attributes.Add(SymbologyContext.SIZE_ATTRIBUTE_NAME, SymbologyManager.DEFAULT_SIZE);
graphic.Attributes.Add(SymbologyContext.FULLSIZE_ATTRIBUTE_NAME,
SymbologyManager.DEFAULT_SIZE + SymbologyManager.DEFAULT_INDENT);
SymbologyManager.InitGraphic(graphic);
return graphic;
}
/// <summary>
/// Create map point for order
/// </summary>
/// <param name="order">Order to get geometry</param>
/// <returns>Map point of order position</returns>
private ESRI.ArcGIS.Client.Geometry.MapPoint _CreatePoint(Order order)
{
ESRI.ArcGIS.Client.Geometry.MapPoint point = null;
// if order geocoded - create point
if (order.GeoLocation.HasValue)
{
ESRI.ArcLogistics.Geometry.Point geoLocation = order.GeoLocation.Value;
// Project point from WGS84 to Web Mercator if spatial reference of map is Web Mercator
if (ParentLayer != null && ParentLayer.SpatialReferenceID != null)
{
geoLocation = WebMercatorUtil.ProjectPointToWebMercator(geoLocation, ParentLayer.SpatialReferenceID.Value);
}
point = new ESRI.ArcGIS.Client.Geometry.MapPoint(geoLocation.X, geoLocation.Y);
}
else
{
point = null;
}
return point;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Checks is order locked.
/// </summary>
/// <param name="order">Order to check.</param>
/// <param name="schedule">Schedule to check.</param>
/// <returns>TRUE if order has stops belong schedule and this route or stop is locked.</returns>
public static bool IsOrderLocked(Order order, Schedule schedule)
{
Debug.Assert(order != null);
Debug.Assert(schedule != null);
bool isLocked = order.Stops.Any(stop =>
(null != stop.Route) &&
stop.Route.Schedule.Equals(schedule) &&
(stop.Route.IsLocked || stop.IsLocked));
return isLocked;
}
private void processOrders(string path)
{
DataTable table = new DataTable();
table = ReadCSV(path);
foreach (DataRow row in table.Rows)
{
// Create New empty Order
CapacitiesInfo capInfo = m_application.Project.CapacitiesInfo;
OrderCustomPropertiesInfo propInfo = m_application.Project.OrderCustomPropertiesInfo;
ESRI.ArcLogistics.DomainObjects.Order resultOrder = new ESRI.ArcLogistics.DomainObjects.Order(capInfo, propInfo);
OrderCustomPropertiesInfo orderPropertiesInfo = resultOrder.CustomPropertiesInfo;
OrderCustomProperties orderProperties = resultOrder.CustomProperties;
CapacitiesInfo orderCapacitiesInfo = resultOrder.CapacitiesInfo;
Capacities orderCapacities = resultOrder.Capacities;
bool geocodeProvided = false;
bool geocodeCorrect = false;
double tempD;
DateTime TWdateTime;
Double tempX = 0.0;
Double tempY = 0.0;
// Insert Order Information
resultOrder.PlannedDate = m_application.CurrentDate;
for (int i = 0; i < table.Columns.Count; i++)
{
try
{
switch (table.Columns[i].ColumnName)
{
#region Case Statements
case "Name": resultOrder.Name = row["Name"].ToString(); break;
case "Address": resultOrder.Address.AddressLine = row["Address"].ToString(); break;
case "City": resultOrder.Address.Locality3 = row["City"].ToString(); break;
case "State": resultOrder.Address.StateProvince = row["State"].ToString(); break;
case "Zip": resultOrder.Address.PostalCode1 = row["Zip"].ToString(); break;
case "Zip4": resultOrder.Address.PostalCode2 = row["Zip4"].ToString(); break;
case "Country": resultOrder.Address.Country = row["Country"].ToString(); break;
case "PlannedDate":
DateTime tempDT = new DateTime();
if (System.DateTime.TryParse(row["PlannedDate"].ToString(), out tempDT))
resultOrder.PlannedDate = tempDT;
break;
case "Priority":
if (row["Priority"].ToString() == "High") resultOrder.Priority = OrderPriority.High;
else if (row["Priority"].ToString() == "Normal") resultOrder.Priority = OrderPriority.Normal;
break;
case "OrderType":
if (row["OrderType"].ToString() == "Pickup") resultOrder.Type = OrderType.Pickup;
else if (row["OrderType"].ToString() == "Delivery") resultOrder.Type = OrderType.Delivery;
break;
case "ServiceTime":
if (Double.TryParse(row["ServiceTime"].ToString(), out tempD))
resultOrder.ServiceTime = tempD;
break;
case "TimeWindowStart":
string tempS = row["TimeWindowStart"].ToString();
if (DateTime.TryParse(tempS, out TWdateTime))
{
if (TWdateTime.TimeOfDay != TimeSpan.Zero)
{
resultOrder.TimeWindow.From = TWdateTime.TimeOfDay;
resultOrder.TimeWindow.IsWideOpen = false;
}
}
break;
case "TimeWindowFinish":
if (DateTime.TryParse(row["TimeWindowFinish"].ToString(), out TWdateTime))
{
if (TWdateTime.TimeOfDay != TimeSpan.Zero)
{
resultOrder.TimeWindow.To = TWdateTime.TimeOfDay;
resultOrder.TimeWindow.IsWideOpen = false;
}
}
break;
case "TimeWindow2Start":
if (DateTime.TryParse(row["TimeWindow2Start"].ToString(), out TWdateTime))
{
if (TWdateTime.TimeOfDay != TimeSpan.Zero)
{
resultOrder.TimeWindow2.From = TWdateTime.TimeOfDay;
resultOrder.TimeWindow2.IsWideOpen = false;
}
}
break;
case "TimeWindow2Finish":
if (DateTime.TryParse(row["TimeWindow2Finish"].ToString(), out TWdateTime))
{
if (TWdateTime.TimeOfDay != TimeSpan.Zero)
{
resultOrder.TimeWindow2.To = TWdateTime.TimeOfDay;
resultOrder.TimeWindow2.IsWideOpen = false;
}
}
break;
case "MaxViolationTime":
if (Double.TryParse(row["MaxViolationTime"].ToString(), out tempD))
resultOrder.MaxViolationTime = tempD;
break;
case "VehicleSpecialties":
if (row["VehicleSpecialties"].ToString() != "")
{
string[] stringSeparators = new string[] { ";", "," };
string[] specialties = row["VehicleSpecialties"].ToString().Split(stringSeparators, StringSplitOptions.None);
foreach (string s in specialties)
{
VehicleSpecialty vs = new VehicleSpecialty();
vs.Name = s;
foreach (VehicleSpecialty V in m_application.Project.VehicleSpecialties)
{
if (String.Compare(V.Name, vs.Name, true) == 0)
{
V.CopyTo(vs);
m_application.Project.VehicleSpecialties.Remove(V);
break;
}
}
m_application.Project.VehicleSpecialties.Add(vs);
resultOrder.VehicleSpecialties.Add(vs);
}
}
break;
case "DriverSpecialties":
if (row["DriverSpecialties"].ToString() != "")
{
string[] stringSeparators2 = new string[] { ";", "," };
string[] specialties2 = row["DriverSpecialties"].ToString().Split(stringSeparators2, StringSplitOptions.None);
foreach (string s in specialties2)
{
DriverSpecialty ds = new DriverSpecialty();
ds.Name = s;
foreach (DriverSpecialty D in m_application.Project.DriverSpecialties)
{
if (String.Compare(D.Name, ds.Name, true) == 0)
{
D.CopyTo(ds);
m_application.Project.DriverSpecialties.Remove(D);
break;
}
}
m_application.Project.DriverSpecialties.Add(ds);
resultOrder.DriverSpecialties.Add(ds);
}
}
break;
case "X":
string x = row["X"].ToString();
if (x != "" && x != null)
if (Double.TryParse(row["X"].ToString(), out tempX))
{
if (tempX >= -180.0 && tempX <= 180.0 && tempX != 0.0)
{
geocodeProvided = true;
geocodeCorrect = true;
}
else if (tempX == 0.0)
geocodeCorrect = true;
}
break;
case "Y":
string y = row["Y"].ToString();
if (y != "" && y != null)
if (Double.TryParse(row["Y"].ToString(), out tempY))
{
if (tempY >= -90.0 && tempY <= 90.0 && tempY != 0)
{
geocodeProvided = true;
geocodeCorrect = true;
}
else if (tempY == 0.0)
geocodeCorrect = true;
}
break;
#endregion
}// End Switch
if (orderProperties.Count > 0 )
{
OrderCustomProperty orderPropertyInfoItem = null;
for (int j = 0; j < orderPropertiesInfo.Count; j++)
{
orderPropertyInfoItem = orderPropertiesInfo.ElementAt(j) as OrderCustomProperty;
string tempName = orderPropertyInfoItem.Name.Replace(" ", "");
if (tempName == table.Columns[i].ColumnName)
{
orderProperties[j] = (row[table.Columns[i].ToString()].ToString());
break;
}
}
}
if( orderCapacities.Count > 0)
{
CapacityInfo orderCapacityInfoItem = null;
for (int k = 0; k < orderCapacitiesInfo.Count; k++)
{
orderCapacityInfoItem = orderCapacitiesInfo.ElementAt(k);
string tempName = orderCapacityInfoItem.Name.Replace(" ", "");
if (tempName == table.Columns[i].ColumnName)
{
if(Double.TryParse(row[table.Columns[i].ToString()].ToString(), out tempD))
orderCapacities[k] = tempD;
break;
}
}
}
}
catch (Exception e)
{
string statusMessage = " Import from " + Params.Instance.importName + " encountered a problem: " + e.Message;
m_application.Messenger.AddError(statusMessage);
}
}
resultOrder.CustomProperties = orderProperties;
resultOrder.Capacities = orderCapacities;
if (geocodeProvided && geocodeCorrect)
{
AddressCandidate candidate1 = new AddressCandidate();
ESRI.ArcLogistics.Geometry.Point p = new ESRI.ArcLogistics.Geometry.Point(tempX, tempY);
candidate1.GeoLocation = p;
candidate1.Score = 100;
candidate1.Address = resultOrder.Address;
resultOrder.GeoLocation = candidate1.GeoLocation;
}
else
{
AddressCandidate candidate = m_application.Geocoder.Geocode(resultOrder.Address);
if (candidate != null)
resultOrder.GeoLocation = candidate.GeoLocation;
else
{
//TODO: Handle orders which were not geocoded!!
}
}
// Add Order
m_application.Project.Orders.Add(resultOrder);
}
}
/// <summary>
/// Returns text that has to be shown in time windows section.
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
private string _GetTimeWindowsText(Order order)
{
string twText;
if (order.TimeWindow.IsWideOpen && order.TimeWindow2.IsWideOpen)
twText = order.TimeWindow.ToString();
else if (!order.TimeWindow.IsWideOpen && order.TimeWindow2.IsWideOpen)
twText = order.TimeWindow.ToString();
else if (order.TimeWindow.IsWideOpen && !order.TimeWindow2.IsWideOpen)
twText = order.TimeWindow2.ToString();
else
{
StringBuilder strBuilder = new StringBuilder();
strBuilder.Append(order.TimeWindow.ToString());
strBuilder.Append(TIME_WINDOWS_SEPARATOR);
strBuilder.Append(order.TimeWindow2.ToString());
twText = strBuilder.ToString();
}
return twText;
}
private ESRI.ArcLogistics.DomainObjects.Order MakeOrderFromInvoice(IInvoiceRet invoiceRet, QBSessionManager session)
{
ESRI.ArcLogistics.DomainObjects.Order resultOrder = null;
ICustomerRet customerRet = QueryCustomer(session, invoiceRet.CustomerRef.FullName.GetValue());
CapacitiesInfo capInfo = m_application.Project.CapacitiesInfo;
OrderCustomPropertiesInfo propInfo = m_application.Project.OrderCustomPropertiesInfo;
resultOrder = new ESRI.ArcLogistics.DomainObjects.Order(capInfo, propInfo);
resultOrder.PlannedDate = m_application.CurrentDate;
if (customerRet.ParentRef != null)
{
resultOrder.Name = customerRet.ParentRef.FullName.GetValue();
}
else
{
resultOrder.Name = customerRet.FullName.GetValue();
}
IAddress useAddress = null;
if (customerRet.ShipAddress != null)
{
useAddress = customerRet.ShipAddress;
}
else if (customerRet.BillAddress != null)
{
useAddress = customerRet.BillAddress;
}
else
{
m_application.Messenger.AddWarning("No address for: " + resultOrder.Name);
}
if (useAddress != null)
{
if (useAddress.Addr2 != null)
{
resultOrder.Address.AddressLine = useAddress.Addr2.GetValue();
}
else
{
resultOrder.Address.AddressLine = useAddress.Addr1.GetValue();
}
resultOrder.Address.Locality3 = useAddress.City.GetValue();
resultOrder.Address.StateProvince = useAddress.State.GetValue();
resultOrder.Address.PostalCode1 = useAddress.PostalCode.GetValue();
AddressCandidate candidate = m_application.Geocoder.Geocode(resultOrder.Address);
resultOrder.GeoLocation = candidate.GeoLocation;
}
// Look in the order custom properties for matching invoice detail items (by item description).
// Look in the order capacities for matching item type custom fields.
OrderCustomPropertiesInfo orderPropertiesInfo = resultOrder.CustomPropertiesInfo;
OrderCustomProperties orderProperties = resultOrder.CustomProperties;
CapacitiesInfo orderCapacitiesInfo = resultOrder.CapacitiesInfo;
Capacities orderCapacities = resultOrder.Capacities;
// Retrieve invoice line list
// Each line can be either InvoiceLineRet OR InvoiceLineGroupRet
IORInvoiceLineRetList orInvoiceLineRetList = invoiceRet.ORInvoiceLineRetList;
if (orInvoiceLineRetList != null && (orderProperties.Count > 0 || orderCapacities.Count > 0))
{
int lineCount = orInvoiceLineRetList.Count;
for (int i = 0; i < lineCount; i++)
{
IORInvoiceLineRet orInvoiceLineRet = orInvoiceLineRetList.GetAt(i);
// Check what to retrieve from the orInvoiceLineRet object
// based on the "ortype" property. Skip summary lines.
if (orInvoiceLineRet.ortype != ENORInvoiceLineRet.orilrInvoiceLineRet)
{
continue;
}
if (orInvoiceLineRet.InvoiceLineRet.ItemRef.FullName != null)
{
string itemName = orInvoiceLineRet.InvoiceLineRet.ItemRef.FullName.GetValue();
double itemQuantity = 0;
if (orInvoiceLineRet.InvoiceLineRet.ItemRef != null)
{
itemQuantity = System.Convert.ToDouble(orInvoiceLineRet.InvoiceLineRet.Quantity.GetValue());
}
// look for matching custom order property
OrderCustomProperty orderPropertyInfoItem = null;
for (int j = 0; j < orderPropertiesInfo.Count; j++)
{
orderPropertyInfoItem = orderPropertiesInfo.ElementAt(j) as OrderCustomProperty;
if (orderPropertyInfoItem.Name == itemName)
{
if (orderPropertyInfoItem.Type == OrderCustomPropertyType.Numeric)
{
orderProperties[j] = itemQuantity;
}
else
{
orderProperties[j] = itemQuantity.ToString();
}
break;
}
}
// look for matching capacity
// need to lookup item record so we get the extra field(s)
// TODO: It might be a good idea to cache these locally to avoid
// excess QB queries.
IORItemRet orItemRet = QueryItem(session, itemName);
IDataExtRetList custItemFieldsRetList = null;
switch (orItemRet.ortype)
{
case ENORItemRet.orirItemServiceRet:
{
// orir prefix comes from OR + Item + Ret
IItemServiceRet ItemServiceRet = orItemRet.ItemServiceRet;
custItemFieldsRetList = ItemServiceRet.DataExtRetList;
}
break;
case ENORItemRet.orirItemInventoryRet:
{
IItemInventoryRet ItemInventoryRet = orItemRet.ItemInventoryRet;
custItemFieldsRetList = ItemInventoryRet.DataExtRetList;
}
break;
case ENORItemRet.orirItemNonInventoryRet:
{
IItemNonInventoryRet ItemNonInventoryRet = orItemRet.ItemNonInventoryRet;
custItemFieldsRetList = ItemNonInventoryRet.DataExtRetList;
}
break;
}
int custItemFieldCount = 0;
if (custItemFieldsRetList != null)
{
custItemFieldCount = custItemFieldsRetList.Count;
}
for (int j = 0; j < custItemFieldCount; j++)
{
IDataExtRet custItemField = custItemFieldsRetList.GetAt(j);
string custItemFieldName = custItemField.DataExtName.GetValue();
CapacityInfo orderCapacityInfoItem = null;
for (int k = 0; k < orderCapacitiesInfo.Count; k++)
{
orderCapacityInfoItem = orderCapacitiesInfo.ElementAt(k);
if (orderCapacityInfoItem.Name == custItemFieldName)
{
orderCapacities[k] += System.Convert.ToDouble(custItemField.DataExtValue.GetValue()) * itemQuantity;
break;
}
}
}
}
}
}
resultOrder.CustomProperties = orderProperties;
resultOrder.Capacities = orderCapacities;
return(resultOrder);
}
/// <summary>
/// Add priority if it High
/// </summary>
/// <param name="order">Source order</param>
/// <param name="inlines">Inlines to fill</param>
private static void _AddPriorityIfNeeded(Order order, InlineCollection inlines)
{
if (order.Priority == OrderPriority.High)
{
string priority = order.Priority.ToString();
_AddLine(_priorityCaption, priority, inlines, false);
}
}
/// <summary>
/// Method converts pickup and delivery orders into GPFeature.
/// </summary>
/// <param name="pickupOrder">Order.</param>
/// <param name="deliveryOrder">Order.</param>
/// <returns>OrderPair GPFeature.</returns>
private GPFeature _ConvertOrderPair(Order pickupOrder, Order deliveryOrder)
{
Debug.Assert(pickupOrder != null && deliveryOrder != null);
GPFeature feature = new GPFeature();
// Attributes.
AttrDictionary attrs = new AttrDictionary();
// Pickup Name.
attrs.Add(NAAttribute.FIRST_ORDER_NAME, pickupOrder.Id.ToString());
// Delivery Name.
attrs.Add(NAAttribute.SECOND_ORDER_NAME, deliveryOrder.Id.ToString());
// not using MaxTransitTime
feature.Attributes = attrs;
return feature;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
/// <returns></returns>
public override object Clone()
{
Order obj = new Order(this._capacitiesInfo, this._customPropertiesInfo);
this.CopyTo(obj);
return obj;
}
private List <ESRI.ArcLogistics.DomainObjects.Order> processOrders(DataTable table)
{
List <ESRI.ArcLogistics.DomainObjects.Order> OrderList = new List <Order>();
foreach (DataRow row in table.Rows)
{
// Create New empty Order
CapacitiesInfo capInfo = m_application.Project.CapacitiesInfo;
OrderCustomPropertiesInfo propInfo = m_application.Project.OrderCustomPropertiesInfo;
ESRI.ArcLogistics.DomainObjects.Order resultOrder = new ESRI.ArcLogistics.DomainObjects.Order(capInfo, propInfo);
OrderCustomPropertiesInfo orderPropertiesInfo = resultOrder.CustomPropertiesInfo;
OrderCustomProperties orderProperties = resultOrder.CustomProperties;
CapacitiesInfo orderCapacitiesInfo = resultOrder.CapacitiesInfo;
Capacities orderCapacities = resultOrder.Capacities;
bool geocodeProvided = false;
bool geocodeCorrect = false;
bool geocodedCorrectly = false;
double tempD;
DateTime TWdateTime;
Double tempX = 0.0;
Double tempY = 0.0;
// Insert Order Information
resultOrder.PlannedDate = m_application.CurrentDate;
for (int i = 0; i < table.Columns.Count; i++)
{
try
{
switch (table.Columns[i].ColumnName)
{
#region Case Statements
case "Name": resultOrder.Name = row["Name"].ToString(); break;
case "Address": resultOrder.Address.AddressLine = row["Address"].ToString(); break;
case "City": resultOrder.Address.Locality3 = row["City"].ToString(); break;
case "State": resultOrder.Address.StateProvince = row["State"].ToString(); break;
case "Zip": resultOrder.Address.PostalCode1 = row["Zip"].ToString(); break;
case "Zip4": resultOrder.Address.PostalCode2 = row["Zip4"].ToString(); break;
case "Country": resultOrder.Address.Country = row["Country"].ToString(); break;
case "PlannedDate":
DateTime tempDT = new DateTime();
if (System.DateTime.TryParse(row["PlannedDate"].ToString(), out tempDT))
{
resultOrder.PlannedDate = tempDT;
}
break;
case "Priority":
if (row["Priority"].ToString() == "High")
{
resultOrder.Priority = OrderPriority.High;
}
else if (row["Priority"].ToString() == "Normal")
{
resultOrder.Priority = OrderPriority.Normal;
}
break;
case "OrderType":
if (row["OrderType"].ToString() == "Pickup")
{
resultOrder.Type = OrderType.Pickup;
}
else if (row["OrderType"].ToString() == "Delivery")
{
resultOrder.Type = OrderType.Delivery;
}
break;
case "ServiceTime":
if (Double.TryParse(row["ServiceTime"].ToString(), out tempD))
{
resultOrder.ServiceTime = tempD;
}
break;
case "TimeWindowStart":
string tempS = row["TimeWindowStart"].ToString();
if (DateTime.TryParse(tempS, out TWdateTime))
{
if (TWdateTime.TimeOfDay != TimeSpan.Zero)
{
resultOrder.TimeWindow.From = TWdateTime.TimeOfDay;
resultOrder.TimeWindow.IsWideOpen = false;
}
}
break;
case "TimeWindowFinish":
if (DateTime.TryParse(row["TimeWindowFinish"].ToString(), out TWdateTime))
{
if (TWdateTime.TimeOfDay != TimeSpan.Zero)
{
resultOrder.TimeWindow.To = TWdateTime.TimeOfDay;
resultOrder.TimeWindow.IsWideOpen = false;
}
}
break;
case "TimeWindow2Start":
if (DateTime.TryParse(row["TimeWindow2Start"].ToString(), out TWdateTime))
{
if (TWdateTime.TimeOfDay != TimeSpan.Zero)
{
resultOrder.TimeWindow2.From = TWdateTime.TimeOfDay;
resultOrder.TimeWindow2.IsWideOpen = false;
}
}
break;
case "TimeWindow2Finish":
if (DateTime.TryParse(row["TimeWindow2Finish"].ToString(), out TWdateTime))
{
if (TWdateTime.TimeOfDay != TimeSpan.Zero)
{
resultOrder.TimeWindow2.To = TWdateTime.TimeOfDay;
resultOrder.TimeWindow2.IsWideOpen = false;
}
}
break;
case "MaxViolationTime":
if (Double.TryParse(row["MaxViolationTime"].ToString(), out tempD))
{
resultOrder.MaxViolationTime = tempD;
}
break;
case "VehicleSpecialties":
if (row["VehicleSpecialties"].ToString() != "")
{
string[] stringSeparators = new string[] { ";", "," };
string[] specialties = row["VehicleSpecialties"].ToString().Split(stringSeparators, StringSplitOptions.None);
foreach (string s in specialties)
{
VehicleSpecialty vs = new VehicleSpecialty();
vs.Name = s;
foreach (VehicleSpecialty V in m_application.Project.VehicleSpecialties)
{
if (String.Compare(V.Name, vs.Name, true) == 0)
{
V.CopyTo(vs);
m_application.Project.VehicleSpecialties.Remove(V);
break;
}
}
m_application.Project.VehicleSpecialties.Add(vs);
resultOrder.VehicleSpecialties.Add(vs);
}
}
break;
case "DriverSpecialties":
if (row["DriverSpecialties"].ToString() != "")
{
string[] stringSeparators2 = new string[] { ";", "," };
string[] specialties2 = row["DriverSpecialties"].ToString().Split(stringSeparators2, StringSplitOptions.None);
foreach (string s in specialties2)
{
DriverSpecialty ds = new DriverSpecialty();
ds.Name = s;
foreach (DriverSpecialty D in m_application.Project.DriverSpecialties)
{
if (String.Compare(D.Name, ds.Name, true) == 0)
{
D.CopyTo(ds);
m_application.Project.DriverSpecialties.Remove(D);
break;
}
}
m_application.Project.DriverSpecialties.Add(ds);
resultOrder.DriverSpecialties.Add(ds);
}
}
break;
case "X":
string x = row["X"].ToString();
if (x != "" && x != null)
{
if (Double.TryParse(row["X"].ToString(), out tempX))
{
if (tempX >= -180.0 && tempX <= 180.0 && tempX != 0.0)
{
geocodeProvided = true;
geocodeCorrect = true;
}
else if (tempX == 0.0)
{
geocodeCorrect = true;
}
}
}
break;
case "Y":
string y = row["Y"].ToString();
if (y != "" && y != null)
{
if (Double.TryParse(row["Y"].ToString(), out tempY))
{
if (tempY >= -90.0 && tempY <= 90.0 && tempY != 0)
{
geocodeProvided = true;
geocodeCorrect = true;
}
else if (tempY == 0.0)
{
geocodeCorrect = true;
}
}
}
break;
#endregion
}
if (orderProperties.Count > 0)
{
OrderCustomProperty orderPropertyInfoItem = null;
for (int j = 0; j < orderPropertiesInfo.Count; j++)
{
orderPropertyInfoItem = orderPropertiesInfo.ElementAt(j) as OrderCustomProperty;
string tempName = orderPropertyInfoItem.Name.Replace(" ", "");
if (tempName == table.Columns[i].ColumnName)
{
orderProperties[j] = (row[table.Columns[i].ToString()].ToString());
break;
}
}
}
if (orderCapacities.Count > 0)
{
CapacityInfo orderCapacityInfoItem = null;
for (int k = 0; k < orderCapacitiesInfo.Count; k++)
{
orderCapacityInfoItem = orderCapacitiesInfo.ElementAt(k);
string tempName = orderCapacityInfoItem.Name.Replace(" ", "");
if (tempName == table.Columns[i].ColumnName)
{
if (Double.TryParse(row[table.Columns[i].ToString()].ToString(), out tempD))
{
orderCapacities[k] = tempD;
}
break;
}
}
}
}
catch (Exception e)
{
string statusMessage = " Distribute Orders encountered a problem: " + e.Message;
m_application.Messenger.AddError(statusMessage);
}
}
resultOrder.CustomProperties = orderProperties;
resultOrder.Capacities = orderCapacities;
if (geocodeProvided && geocodeCorrect)
{
AddressCandidate candidate1 = new AddressCandidate();
ESRI.ArcLogistics.Geometry.Point p = new ESRI.ArcLogistics.Geometry.Point(tempX, tempY);
candidate1.GeoLocation = p;
candidate1.Score = 100;
candidate1.Address = resultOrder.Address;
resultOrder.GeoLocation = candidate1.GeoLocation;
geocodedCorrectly = true;
}
else
{
try
{
AddressCandidate candidate = new AddressCandidate();
candidate = m_application.Geocoder.Geocode(resultOrder.Address);
if (candidate != null)
{
resultOrder.GeoLocation = candidate.GeoLocation;
geocodedCorrectly = true;
}
else
{
string statusMessage = "Could not geocode address for: " + resultOrder.Name;
m_application.Messenger.AddError(statusMessage);
//TODO: Handle orders which were not geocoded!!
}
}
catch (Exception e)
{
string statusMessage = "Distribute Orders encountered a problem while geocoding addresses: " + e.Message;
m_application.Messenger.AddError(statusMessage);
}
}
// Add Order
if (geocodedCorrectly)
{
OrderList.Add(resultOrder);
}
else
{
string statusMessage = "Distribute Orders encountered a problem while adding order: " + resultOrder.Name;
m_application.Messenger.AddError(statusMessage);
}
}
return(OrderList);
}
/// <summary>
/// Fill order tip
/// </summary>
/// <param name="inlines">Inlines to fill</param>
/// <param name="location">Source order</param>
private static void _FillOrder(InlineCollection inlines, Order order)
{
string name = order.Name;
_AddLine(_nameCaption, name, inlines, false);
_AddPriorityIfNeeded(order, inlines);
_AddTimeWindow(order.TimeWindow, false, inlines, false);
if (!order.TimeWindow.IsWideOpen)
_AddTimeWindow(order.TimeWindow2, true, inlines, false);
foreach (TipProperty tipProperty in App.Current.MapDisplay.OrderTitlesSelected)
{
_AddBindableProperty(inlines, tipProperty, order);
}
}
public void Execute(params object[] args)
{
string statusMessage = "Adding periodic orders between " + m_application.CurrentDate.ToShortDateString() + " and " + m_application.CurrentDate.AddDays(PeriodicOrdersPage.numDays -1).ToShortDateString();
m_application.Messenger.AddInfo(statusMessage);
m_application.MainWindow.StatusBar.WorkingStatus = statusMessage;
Mouse.OverrideCursor = Cursors.Wait;
List<ESRI.ArcLogistics.DomainObjects.Order> oList = processOrders2(PeriodicOrdersPage.dt);
int checkBoxCount = 0;
int comboBoxCount = 0;
int periodicity = 0;
foreach (Order o in oList)
{
periodicity = PeriodicOrdersPage.comboBoxList[comboBoxCount].SelectedIndex +1;
for (int i = 0; i < PeriodicOrdersPage.numDays; i++)
{
if ((i / 7) % (periodicity) == 0)
{
DayOfWeek d = m_application.CurrentDate.AddDays(i).DayOfWeek;
if (PeriodicOrdersPage.checkBoxList[checkBoxCount + (int)d].IsChecked == true)
{
Order tempO = new Order(o.CapacitiesInfo, o.CustomPropertiesInfo);
o.CopyTo(tempO);
tempO.PlannedDate = m_application.CurrentDate.AddDays(i);
m_application.Project.Orders.Add(tempO);
}
}
}
checkBoxCount = checkBoxCount + 7;
comboBoxCount++;
}
m_application.Project.Save();
m_application.MainWindow.StatusBar.WorkingStatus = null;
Mouse.OverrideCursor = null;
statusMessage = "Completed adding Periodic Orders.";
m_application.Messenger.AddInfo(statusMessage);
}
/// <summary>
/// Method converts order into GPFeature.
/// </summary>
/// <param name="unassignedOrder">Unassigned order to convert.</param>
/// <param name="assignedOrder">Assigned order to convert.</param>
/// <returns>Orders GPFeature.</returns>
/// <exception cref="RouteException">If unassigned order is not geocoded.</exception>
private GPFeature _ConvertOrder(Order unassignedOrder, AssignedOrder assignedOrder)
{
Debug.Assert(unassignedOrder != null);
GPFeature feature = new GPFeature();
// Geometry.
IGeocodable gc = unassignedOrder as IGeocodable;
Debug.Assert(gc != null);
if (!gc.IsGeocoded)
{
throw new RouteException(String.Format(
Properties.Messages.Error_OrderIsUngeocoded, unassignedOrder.Id));
}
Debug.Assert(gc.GeoLocation != null);
feature.Geometry = new GeometryHolder();
feature.Geometry.Value = GPObjectHelper.PointToGPPoint((Point)gc.GeoLocation);
// Attributes.
AttrDictionary attrs = new AttrDictionary();
// Name.
attrs.Add(NAAttribute.NAME, unassignedOrder.Id.ToString());
// Curb approach.
attrs.Add(NAAttribute.CURB_APPROACH,
(int)CurbApproachConverter.ToNACurbApproach(
_context.SolverSettings.GetOrderCurbApproach()));
// Service time.
attrs.Add(NAAttribute.SERVICE_TIME, unassignedOrder.ServiceTime);
// Time windows.
TimeWindow timeWindow1 = unassignedOrder.TimeWindow;
TimeWindow timeWindow2 = unassignedOrder.TimeWindow2;
_SetTimeWindowsAttributes(attrs, ref timeWindow1, ref timeWindow2);
// Max Violation Time 1.
attrs.Add(NAAttribute.MAX_VIOLATION_TIME1,
timeWindow1.IsWideOpen ? (double?)null : unassignedOrder.MaxViolationTime);
// Max Violation Time 2.
attrs.Add(NAAttribute.MAX_VIOLATION_TIME2,
timeWindow2.IsWideOpen ? (double?)null : unassignedOrder.MaxViolationTime);
// PickUp or DropOff quantities.
string capacities = _FormatCapacities(unassignedOrder.Capacities);
if (unassignedOrder.Type == OrderType.Delivery)
{
attrs.Add(NAAttribute.DELIVERY, capacities);
attrs.Add(NAAttribute.PICKUP, null);
}
else
{
attrs.Add(NAAttribute.PICKUP, capacities);
attrs.Add(NAAttribute.DELIVERY, null);
}
// Revenue.
attrs.Add(NAAttribute.REVENUE,
unassignedOrder.Priority == OrderPriority.Normal ? 0 : (long)_orderRevenue);
// Specialties.
List<Guid> specIds = GetOrderSpecIds(unassignedOrder);
if (specIds.Count > 0)
attrs.Add(NAAttribute.SPECIALTY_NAMES, _FormatSpecList(specIds));
if (assignedOrder != null)
SetOrderAssignment(attrs, assignedOrder);
else
SetOrderAssignment(attrs, unassignedOrder);
// Status.
attrs.Add(NAAttribute.STATUS, (int)NAObjectStatus.esriNAObjectStatusOK);
feature.Attributes = attrs;
return feature;
}
/// <summary>
/// Method set unassigned order attributes.
/// </summary>
/// <param name="attrs">Attributes to set.</param>
/// <param name="unassignedOrder">Unassigned order to get attribute values.</param>
protected virtual void SetOrderAssignment(AttrDictionary attrs, Order unassignedOrder)
{
Debug.Assert(attrs != null);
// Route name.
attrs.Set(NAAttribute.ROUTE_NAME, "");
// Sequence.
attrs.Set(NAAttribute.SEQUENCE, null);
// Assignment rule.
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderOverride);
}
/// <summary>
/// Method gets specialties Ids from order.
/// </summary>
/// <param name="order">Order to get specialties.</param>
/// <returns>Collection of specialties Ids from order.</returns>
protected virtual List<Guid> GetOrderSpecIds(Order order)
{
Debug.Assert(order != null);
List<Guid> specs = new List<Guid>();
foreach (DriverSpecialty spec in order.DriverSpecialties)
specs.Add(spec.Id);
foreach (VehicleSpecialty spec in order.VehicleSpecialties)
specs.Add(spec.Id);
return specs;
}
/// <summary>
/// Method determine if assigned order exists and returns it in output parameter.
/// </summary>
/// <param name="order">Order to find.</param>
/// <param name="assignedOrders">Collection of assigned orders to search in.</param>
/// <param name="assignedOrder">Output assigned order.</param>
/// <returns>True - if assigned order found, otherwise - false.</returns>
private bool _FindAssignedOrder(Order order, ICollection<AssignedOrder> assignedOrders,
out AssignedOrder assignedOrder)
{
assignedOrder = null;
bool found = false;
foreach (AssignedOrder ao in assignedOrders)
{
if (ao.Order.Equals(order))
{
assignedOrder = ao;
found = true;
break;
}
}
return found;
}
/// <summary>
/// Fill order-specific properties.
/// </summary>
/// <param name="order">Order.</param>
/// <param name="settings">Current solver settings.</param>
/// <param name="result">Stop information to fill in.</param>
private static void _FillOrderProperties(Order order,
SolverSettings settings, StopInfo result)
{
Debug.Assert(order != null);
Debug.Assert(result != null);
result.OrderType = order.Type;
result.Priority = order.Priority;
result.MaxViolationTime = (int)order.MaxViolationTime;
// Fill curb approach policies.
if (settings != null)
{
result.CurbApproach = settings.GetOrderCurbApproach();
}
}
/// <summary>
/// Gets order property value by property name.
/// </summary>
/// <param name="order">Order instance.</param>
/// <param name="name">Property name.</param>
/// <returns>Returns property value.</returns>
public static object GetPropertyValue(Order order, string name)
{
object value = null;
int orderPropertyIndex = OrderCustomProperties.GetCustomPropertyIndex(name);
int capacityIndex = Capacities.GetCapacityPropertyIndex(name);
AddressPart? addressPart = null;
try
{
addressPart = (AddressPart)Enum.Parse(typeof(AddressPart), name);
}
catch { }
if (orderPropertyIndex != -1)
{ // specials type: order custom property
if ((0 <= orderPropertyIndex) && (orderPropertyIndex < order.CustomProperties.Count))
value = order.CustomProperties[orderPropertyIndex];
else
{
string mes = string.Format(Properties.Resources.PropertyNameNotExists, name);
throw new ArgumentException(mes);
}
}
else if (capacityIndex != -1)
{ // specials type: capacities
if ((0 <= capacityIndex) && (capacityIndex < order.Capacities.Count))
value = order.Capacities[capacityIndex];
else
{
string mes = string.Format(Properties.Resources.PropertyNameNotExists, name);
throw new ArgumentException(mes);
}
}
else if (addressPart.HasValue)
{ // specials type: address
value = order.Address[addressPart.Value];
}
else if (name.Equals("X", StringComparison.OrdinalIgnoreCase) || name.Equals("Y", StringComparison.OrdinalIgnoreCase))
{
if (order.GeoLocation.HasValue)
{
if (name.Equals("X", StringComparison.OrdinalIgnoreCase))
value = order.GeoLocation.Value.X;
if (name.Equals("Y", StringComparison.OrdinalIgnoreCase))
value = order.GeoLocation.Value.Y;
}
}
else
{
PropertyInfo propInfo = _GetPropertyByName(name);
value = propInfo.GetValue(order, null);
}
return value;
}
/// <summary>
/// Method determines is order assigned to one of selected routes.
/// </summary>
/// </summary>
/// <param name="order">Order.</param>
/// <param name="routes">Collection of routes.</param>
/// <param name="targetOrderSequence">Target orders sequence.</param>
/// <returns>True - if order assigned to one of selected routes, otherwise - false.</returns>
private static bool _IsOrderAssignedToRoute(Order order,
ICollection<Route> routes, int? targetOrderSequence)
{
Debug.Assert(routes != null);
Debug.Assert(order != null);
var assignedStops =
from route in routes
where route.Stops != null
from stop in route.Stops
where
stop.AssociatedObject == order &&
(targetOrderSequence == null ||
stop.OrderSequenceNumber == targetOrderSequence)
select stop;
return assignedStops.Any();
}
/// <summary>
/// Geocode order, using local geocoder.
/// </summary>
/// <param name="order">Order to geocode.</param>
/// <param name="useLocalAsPrimary">If true and record exists in storage, than dont use server geocoder.</param>
/// <param name="includeDisabledLocators">Is need to add candidates from disabled locators.</param>
/// <returns>Candidates list.</returns>
private static List<AddressCandidate> _DoLocalOrderGeocode(Order order, bool useLocalAsPrimary, bool includeDisabledLocators)
{
LocalGeocoder localGeocoder = new LocalGeocoder(App.Current.Geocoder, App.Current.NameAddressStorage);
NameAddress nameAddress = new NameAddress();
nameAddress.Name = order.Name;
nameAddress.Address = (Address)order.Address.Clone();
List<AddressCandidate> candidates = new List<AddressCandidate>();
AddressCandidate candidateFromLocalGeocoder = localGeocoder.Geocode(nameAddress);
if (useLocalAsPrimary && candidateFromLocalGeocoder != null)
{
candidates.Add(candidateFromLocalGeocoder);
}
else
{
AddressCandidate[] candidatesArray = localGeocoder.GeocodeCandidates(nameAddress, includeDisabledLocators);
candidates.AddRange(candidatesArray);
}
return candidates;
}
/// <summary>
/// Updates properties for all orders with the same name as the specified one.
/// </summary>
/// <param name="sourceOrder">The reference to an
/// <see cref="ESRI.ArcLogistics.DomainObjects.Order"/> object to read property values
/// from.</param>
private void _UpdateOrdersProperties(Order sourceOrder)
{
Debug.Assert(sourceOrder != null);
var orders = _orderGroups[sourceOrder].Where(order => order != sourceOrder);
foreach (var order in orders)
{
sourceOrder.CopyTo(order);
}
}
public void Execute(params object[] args)
{
string importPath = DistributeOrdersPage.importpath;
int numDays = DistributeOrdersPage.numDays;
string statusMessage = "Started distributing orders.";
int numClusters = 0;
m_application.MainWindow.StatusBar.WorkingStatus = statusMessage;
Mouse.OverrideCursor = Cursors.Wait;
try
{
if (File.Exists(importPath))
{
//Read orders info from file
DataTable table = new DataTable();
table = ReadCSV(importPath);
if (numDays > 0)
{
statusMessage = "Distributing " + table.Rows.Count + " orders over " + numDays + " days.";
m_application.Messenger.AddInfo(statusMessage);
/////////////////////////////////
// Count total number of routes
/////////////////////////////////
DateTime dt = new DateTime();
dt = m_application.CurrentDate;
for (int i = 0; i < numDays; i++)
{
if (m_application.Project.DefaultRoutes.Count > 0)
{
List <Schedule> S = m_application.Project.Schedules.Search(dt.AddDays(i)).ToList();
//If the Current Schedule has routes, use those, else use default routes
if (S.Count > 0 && S[0].Routes.Count > 0)
{
numClusters = numClusters + S[0].Routes.Count;
}
else
{
foreach (Route route in m_application.Project.DefaultRoutes)
{
if (route.Days.DoesDaySatisfy(dt.AddDays(i)))
{
numClusters++;
}
}
}
}
}
statusMessage = "Creating " + numClusters + " clusters.";
m_application.Messenger.AddInfo(statusMessage);
/////////////////////////////////
// Create Dataset
/////////////////////////////////
List <ESRI.ArcLogistics.DomainObjects.Order> oList = processOrders(table);
int numOrders = oList.Count;
Point[] data = new Point[numOrders];
Point[] centres = new Point[numClusters];
for (int i = 0; i < numOrders; i++)
{
ESRI.ArcLogistics.DomainObjects.Order o = oList.ElementAt(i);
Point p = new Point(0, o.GeoLocation.Value.X, o.GeoLocation.Value.Y);
data[i] = p;
}
/////////////////////////////////
// Perform Clustering
/////////////////////////////////
int iterations = cluster(ref data, ref centres);
/////////////////////////////////
// Add clustered orders to days
/////////////////////////////////
int numRoutes = 0;
int index = 0;
int tempNumOrders = 0;
for (int k = 0; k < numDays; k++)
{
if (m_application.Project.DefaultRoutes.Count > 0)
{
List <Schedule> S = m_application.Project.Schedules.Search(dt.AddDays(k)).ToList();
if (S.Count > 0 && S[0].Routes.Count > 0)
{
numRoutes = S[0].Routes.Count;
}
else
{
foreach (Route route in m_application.Project.DefaultRoutes)
{
if (route.Days.DoesDaySatisfy(dt.AddDays(k)))
{
numRoutes++;
}
}
}
for (int i = 0; i < numOrders; i++)
{
if (data[i].cluster >= index && data[i].cluster < (index + numRoutes))
{
ESRI.ArcLogistics.DomainObjects.Order o = oList.ElementAt(i);
o.PlannedDate = dt.AddDays(k);
m_application.Project.Orders.Add(o);
tempNumOrders++;
}
}
statusMessage = "Added " + numRoutes + " Clusters (" + tempNumOrders + " orders) to " + dt.AddDays(k);
m_application.Messenger.AddInfo(statusMessage);
index = index + numRoutes;
numRoutes = 0;
tempNumOrders = 0;
}
}
m_application.Project.Save();
statusMessage = "Finished Distributing Orders";
m_application.Messenger.AddInfo(statusMessage);
}
else
{
statusMessage = "Please specify number of days.";
m_application.Messenger.AddError(statusMessage);
}
}
else
{
statusMessage = "Import from " + importPath + " failed! Specified file does not exist.";
m_application.Messenger.AddError(statusMessage);
}
}
catch (Exception e)
{
statusMessage = "Distribute Orders encountered an error: " + e.Message;
m_application.Messenger.AddError(statusMessage);
}
finally
{
m_application.MainWindow.StatusBar.WorkingStatus = null;
Mouse.OverrideCursor = null;
}
if (Mouse.OverrideCursor != null)
{
m_application.MainWindow.StatusBar.WorkingStatus = null;
Mouse.OverrideCursor = null;
}
}
/// <summary>
/// Method gets route name for assigned order.
/// </summary>
/// <param name="info">Operation info.</param>
/// <param name="order">Assigned order.</param>
/// <returns>Route name or empty string, in case order is unassigned.</returns>
private static string _GetRouteNameForAssignedOrder(
AsyncOperationInfo info, Order order)
{
Debug.Assert(info != null);
Debug.Assert(order != null);
var inputParameters = (AssignOrdersParams)info.InputParams;
ICollection<Route> targetRoutes = inputParameters.TargetRoutes;
// Search for stop associated with order, which was assigned to route.
var assignedStops =
from route in targetRoutes
where route.Stops != null
from stop in route.Stops
where (stop.AssociatedObject == order)
select stop;
string routeName = string.Empty;
if (assignedStops.Any())
{
Stop stop = assignedStops.First();
routeName = stop.Route.Name;
}
return routeName;
}