diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..a7b50b96
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+Route4MeSDK.sln
+Route4MeSDKTest/Route4MeSDKTest.csproj
+*.userprefs
+/**/obj/
+/packages/
diff --git a/.nuget/packages.config b/.nuget/packages.config
new file mode 100644
index 00000000..18f45ea6
--- /dev/null
+++ b/.nuget/packages.config
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..b04e7dd9
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,26 @@
+# =============================================================================
+# Access Route4Me's logistics-as-a-service API using our C# SDK
+#
+# Copyright (C) 2016-2017 Route4Me
+#
+# =============================================================================
+
+sudo: false
+language: csharp
+solution: Route4MeSDK.sln
+
+mono:
+ - latest
+ - 3.8.0
+# - 2.10.8 # fails: https://travis-ci.org/maxkoryukov/route4me-csharp-sdk/jobs/194265821
+
+# dotnet:
+# - 1.0.0-preview2-003121
+
+cache:
+ directories:
+ - packages
+
+script:
+ - xbuild /p:Configuration=Release Route4MeSDK.sln
+ - mono ./packages/NUnit.ConsoleRunner.3.6.0/tools/nunit3-console.exe ./Route4MeSDKTest/bin/Debug/Route4MeSDKTest.exe
diff --git a/README.md b/README.md
new file mode 100755
index 00000000..71fe84f7
--- /dev/null
+++ b/README.md
@@ -0,0 +1,223 @@
+# Route4Me Route Optimization SaaS C# SDK
+
+[![Build Status](https://travis-ci.org/route4me/route4me-csharp-sdk.svg?branch=master)](https://travis-ci.org/route4me/route4me-csharp-sdk)
+[![Build status](https://ci.appveyor.com/api/projects/status/8iq2b0ctti0lw79k?svg=true)](https://ci.appveyor.com/project/novapulsar/route4me-csharp-sdk)
+
+
+### What does the Route4Me SDK permit me to do?
+This SDK makes it easier for you use the Route4Me API, which creates optimally sequenced driving routes for many drivers.
+
+### Who can use the Route4Me SDK (and API)?
+The service is typically used by organizations who must route many drivers to many destinations. In addition to route optimization for new (future) routes, the API can also be used to analyze historical routes, and to distribute routes to field personnel.
+
+### Who is prohibited from using the Route4Me SDK (and API)?
+The Route4Me SDK and API cannot be resold or used in a product or system that competes directly with Route4Me. This means that developers cannot resell route optimization services to other businesses or developers. However, developers can integrate our route optimization SDK/API into their software applications. Developers and startups are also permitted to use our software for internal purposes (i.e. a same day delivery startup).
+
+
+### How does the API/SDK Integration Work?
+A Route4Me customer, integrator, or partner incorporates the Route4Me SDK or API into their code base.
+Route4Me permits any paying subscriber to interact with every part of its system using it’s API.
+The API is RESTful, which means that it’s web based and can be accessed by other programs and machines
+The API/SDK should be used to automate the route planning process, or to generate many routes with minimal manual intervention
+
+
+
+### Do optimized routes automatically appear inside my Route4Me account?
+Every Route4Me SDK instance needs a unique API key. The API key can be retrieved inside your Route4Me.com account, inside the Settings tab called API. When a route is planned, it appears inside the corresponding Route4Me account. Because Route4Me web and mobile accounts are synchronized, the routes will appear in both environments at the same time.
+
+### Can I test the SDK with other addresses without a valid API Key?
+No. The sample API key only permits you to optimize routes with the sample address coordinates that are part of this SDK.
+
+### Does the SDK have rate limits?
+The number of requests you can make per second is limited by your current subscription plan. Typically, there are different rate limits for these core features:
+Address Geocoding & Address Reverse Geocoding
+Route Optimization & Management
+Viewing a Route
+
+### What is the recommended architecture for the Route4Me SDK?
+There are two typical integration strategies that we recommend. Using this SDK, you can make optimization requests and then the SDK polls the Route4Me API to detect state changes as the optimization progresses. Alternatively, you can provide a webhook/callback url, and the API will notify that callback URL every time there is a state change.
+
+### I don't need route management or mobile capabilities. Is there a lower level Route4Me API just for the optimization engine?
+Yes. Please contact support@route4me.com to learn about the low-level RESTful API.
+
+### How fast is the route Route4Me Optimization Web Service?
+Most routes having less than 200 destinations are optimized in 1 second or less.
+
+### Can I disable optimization when planning routes?
+Yes. You can send routes with optimization disabled if you want to conveniently see them on a map, or distribute them to your drivers in the order you prefer.
+
+### Can the API be used for aerial vehicles such as drones or self-driving cars?
+Yes. The API can accept lat/lng and an unlimited amount of per-address metadata. The metadata will be preserved as passthrough data by our API, so that the receiving device will have access to critical data when our API invokes a webhook callback to the device.
+
+### Are all my optimized routes stored permanently stored in the Route4Me database?
+Yes. All routes are permanently stored in the database and are no longer accessible to you after your subscription is terminated.
+
+
+### Can I incorporate your API into my mobile application?
+Route4Me’s route planning and optimization technology can only be added into applications that do not directly compete with Route4Me.
+This means the application’s primary capabilities must be unrelated to route optimization, route planning, or navigation.
+
+### Can I pay you to develop a custom algorithm?
+Yes
+
+### Can I use your API and resell it to my customers?
+White-labeling and private-labeling Route4Me is possible but the deal’s licensing terms vary considerably based on customer count, route count, and the level of support that Route4Me should provide to your customers.
+
+### Does the API/SDK have TMS or EDI, or EDI translator capabilities?
+Route4Me is currently working on these features but they are not currently available for sale.
+
+### Can the API/SDK send notifications back to our system using callbacks, notifications, pushes, or webhooks?
+
+Because Route4Me processes all routes asynchronously, Route4Me will conveniently notify the endpoint you specify as the route optimization job progresses through each state of the optimization. Every stage of the route optimization process has a unique stage id.
+
+### Does the Route4Me API and SDK work in my country?
+Route4Me.com, as well as all of Route4Me’s mobile applications use the Route4Me SDK’s and API.
+Since Route4Me works globally, this means that all of Route4Me’s capabilities are available using the SDK’s in every country
+
+
+### Will the Route4Me API/SDK work in my program on the Mac, PC, or Linux?
+Customers are encouraged to select their preferred operating system environment. The Route4Me API/SDK will function on any operating system that supports the preferred programming language of the customer. At this point in time, almost every supported SDK can run on any operating system.
+
+
+### Does the Route4Me API/SDK require me to buy my own servers?
+Route4Me has its own computing infrastructure that you can access using the API and SDKs. Customers typically have to run the SDK code on their own computers and/or servers to access this infrastructure.
+
+### Does Route4Me have an on-premise solution?
+Route4Me does not currently lease or sell servers, and does not have on-premise appliance solution. This would only be possible in exceptionally unique scenarios.
+
+
+### Does the Route4Me API/SDK require me to have my own programmers?
+The time required to integrate the SDK can be as little as 1 hour or may take several weeks, depending on the number of features being incorporated into the customer’s application and how much integration testing will be done by the client. A programmer’s involvement is almost always required to use Route4Me’s technology when accessing it through the API.
+
+
+
+### Installation and Usage
+
+1. Add reference to Route4MeSDKLibrary.dll
+2. Use the class Route4MeSDK.Route4MeManager for accessing the Route4ME API
+3. Use methods Route4MeManager.GetRoute(), Route4MeManager.UpdateOptimization() etc. to access the main functionality of Route4Me API.
+4. Use generic methods Route4MeManager.GetStringResponseFromAPI() and Route4MeManager.GetJsonObjectFromAPI() for accessing any Route4Me API functionally via custom defined classes (see example in Route4MeSDKTest.SingleDriverRoundTripGeneric.cs)
+
+### Examples and Tests
+
+1. See project Route4MeSDKTest (class Route4MeSDKTest.Examples) for some examples of using Route4MeSDKLibrary
+2. See an example of creating a simple route below
+
+### Creating a Simple Route
+
+``` C#
+using Route4MeSDK.DataTypes;
+using Route4MeSDK.QueryTypes;
+
+namespace Route4MeSDK.Examples
+{
+ public sealed partial class Route4MeExamples
+ {
+ public void SingleDriverRoundTrip()
+ {
+ // Create the manager with the api key
+ Route4MeManager route4Me = new Route4MeManager(c_ApiKey);
+
+ // Prepare the addresses
+ Address[] addresses = new Address[]
+ {
+ #region Addresses
+
+ new Address() { AddressString = "754 5th Ave New York, NY 10019",
+ Alias = "Bergdorf Goodman",
+ //designate the point of origination in the route
+ //single driver routes should have one point of origin (single depot)
+ //multiple depot routes can have multiple addresses marked as depots
+ //and the optimization algorithm will determine the optimal departure depot
+ //for each generated route
+ IsDepot = true,
+ Latitude = 40.7636197, //all addresses must be properly geocoded
+ Longitude = -73.9744388, //all addresses must be properly geocoded
+ Time = 0 },
+
+ new Address() { AddressString = "717 5th Ave New York, NY 10022",
+ Alias = "Giorgio Armani",
+ Latitude = 40.7669692, //all addresses must be properly geocoded
+ Longitude = -73.9693864, //all addresses must be properly geocoded
+ Time = 0 },
+
+ new Address() { AddressString = "888 Madison Ave New York, NY 10014",
+ Alias = "Ralph Lauren Women's and Home",
+ Latitude = 40.7715154, //all addresses must be properly geocoded
+ Longitude = -73.9669241, //all addresses must be properly geocoded
+ Time = 0 },
+
+ new Address() { AddressString = "1011 Madison Ave New York, NY 10075",
+ Alias = "Yigal Azrou'l",
+ Latitude = 40.7772129, //all addresses must be properly geocoded
+ Longitude = -73.9669, //all addresses must be properly geocoded
+ Time = 0 },
+
+ new Address() { AddressString = "440 Columbus Ave New York, NY 10024",
+ Alias = "Frank Stella Clothier",
+ Latitude = 40.7808364, //all addresses must be properly geocoded
+ Longitude = -73.9732729,//all addresses must be properly geocoded
+ Time = 0 },
+
+ new Address() { AddressString = "324 Columbus Ave #1 New York, NY 10023",
+ Alias = "Liana",
+ Latitude = 40.7803123,//all addresses must be properly geocoded
+ Longitude = -73.9793079,//all addresses must be properly geocoded
+ Time = 0 },
+
+ new Address() { AddressString = "110 W End Ave New York, NY 10023",
+ Alias = "Toga Bike Shop",
+ Latitude = 40.7753077,//all addresses must be properly geocoded
+ Longitude = -73.9861529,//all addresses must be properly geocoded
+ Time = 0 },
+
+ new Address() { AddressString = "555 W 57th St New York, NY 10019",
+ Alias = "BMW of Manhattan",
+ Latitude = 40.7718005,//all addresses must be properly geocoded
+ Longitude = -73.9897716,//all addresses must be properly geocoded
+ Time = 0 },
+
+ new Address() { AddressString = "57 W 57th St New York, NY 10019",
+ Alias = "Verizon Wireless",
+ Latitude = 40.7558695,//all addresses must be properly geocoded
+ Longitude = -73.9862019,//all addresses must be properly geocoded
+ Time = 0 },
+
+ #endregion
+ };
+
+ // Set parameters
+ RouteParameters parameters = new RouteParameters()
+ {
+ AlgorithmType = AlgorithmType.TSP,
+ StoreRoute = false,
+ RouteName = "Single Driver Round Trip",
+
+ RouteTime = 0,
+ RouteMaxDuration = 86400,
+ VehicleCapacity = "1",
+ VehicleMaxDistanceMI = "10000",
+
+ Optimize = Optimize.Distance.Description(),
+ DistanceUnit = DistanceUnit.MI.Description(),
+ DeviceType = DeviceType.Web.Description(),
+ TravelMode = TravelMode.Driving.Description(),
+ };
+
+ OptimizatonParameters optimizatonParameters = new OptimizatonParameters()
+ {
+ Addresses = addresses,
+ Parameters = parameters
+ };
+
+ // Run the query
+ string errorString;
+ DataObject dataObject = route4Me.RunOptimization(optimizatonParameters, out errorString);
+
+ // Output the result
+ PrintExampleOptimizationResult("SingleDriverRoundTrip", dataObject, errorString);
+ }
+ }
+}
+
+```
diff --git a/Route4MeSDK.sln b/Route4MeSDK.sln
new file mode 100644
index 00000000..de49168d
--- /dev/null
+++ b/Route4MeSDK.sln
@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Route4MeSDKLibrary", "Route4MeSDKLibrary\Route4MeSDKLibrary.csproj", "{37E5D3FC-BBF7-4BD8-98E6-A58DC9138D98}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Route4MeSDKTest", "Route4MeSDKTest\Route4MeSDKTest.csproj", "{DBA0AA41-4223-4404-B3E6-4948FE147A40}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{8BA18B34-5258-42D7-BCAE-6EEB86520598}"
+ ProjectSection(SolutionItems) = preProject
+ .nuget\packages.config = .nuget\packages.config
+ EndProjectSection
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {37E5D3FC-BBF7-4BD8-98E6-A58DC9138D98}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {37E5D3FC-BBF7-4BD8-98E6-A58DC9138D98}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {37E5D3FC-BBF7-4BD8-98E6-A58DC9138D98}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {37E5D3FC-BBF7-4BD8-98E6-A58DC9138D98}.Release|Any CPU.Build.0 = Release|Any CPU
+ {DBA0AA41-4223-4404-B3E6-4948FE147A40}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {DBA0AA41-4223-4404-B3E6-4948FE147A40}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {DBA0AA41-4223-4404-B3E6-4948FE147A40}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {DBA0AA41-4223-4404-B3E6-4948FE147A40}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/Route4MeSDK.v11.suo b/Route4MeSDK.v11.suo
new file mode 100755
index 00000000..f7fad525
Binary files /dev/null and b/Route4MeSDK.v11.suo differ
diff --git a/Route4MeSDKLibrary/Consts.cs b/Route4MeSDKLibrary/Consts.cs
new file mode 100755
index 00000000..222fb730
--- /dev/null
+++ b/Route4MeSDKLibrary/Consts.cs
@@ -0,0 +1,53 @@
+
+namespace Route4MeSDK
+{
+ ///
+ /// Route4Me infrastructure settings
+ /// Api version 4 hosts constants
+ ///
+ public static class R4MEInfrastructureSettings
+ {
+ #region Api V4
+
+ public const string ApiVersion = "4";
+
+ public const string MainHost = "https://www.route4me.com";
+ public const string ApiHost = MainHost + "/api.v4/optimization_problem.php";
+ public const string ShowRouteHost = MainHost + "/route4me.php";
+ public const string RouteHost = MainHost + "/api.v4/route.php";
+ public const string SetGpsHost = MainHost + "/track/set.php";
+ public const string GetUsersHost = MainHost + "/api.v4/user.php";
+ public const string UserAuthentication = MainHost + "/actions/authenticate.php";
+ public const string ValidateSession = MainHost + "/datafeed/session/validate_session.php";
+ public const string UserRegistration = MainHost + "/actions/register_action.php";
+ public const string UserConfiguration = MainHost + "/api.v4/configuration-settings.php";
+ public const string AddRouteNotesHost = MainHost + "/actions/addRouteNotes.php";
+ public const string ActivityFeedHost = MainHost + "/api.v4/activity_feed.php";
+ public const string GetAddress = MainHost + "/api.v4/address.php";
+ public const string DuplicateRoute = MainHost + "/actions/duplicate_route.php";
+ public const string MoveRouteDestination = MainHost + "/actions/route/move_route_destination.php";
+ public const string AddressBook = MainHost + "/api.v4/address_book.php";
+ public const string Avoidance = MainHost + "/api.v4/avoidance.php";
+ public const string Territory = MainHost + "/api.v4/territory.php";
+ public const string Order = MainHost + "/api.v4/order.php";
+ public const string MergeRoutes = MainHost + "/actions/merge_routes.php";
+ public const string RouteReoptimize = MainHost + "/api.v3/route/reoptimize_2.php";
+ public const string RouteSharing = MainHost + "/actions/route/share_route.php";
+
+ public const string MarkAddressDeparted = MainHost + "/api/route/mark_address_departed.php";
+ public const string MarkAddressVisited = MainHost + "/actions/address/update_address_visited.php";
+
+ public const string Geocoder = MainHost + "/api/geocoder.php";
+ public const string RapidStreetData = "https://rapid.route4me.com/street_data";
+ public const string RapidStreetZipcode = "https://rapid.route4me.com/street_data/zipcode";
+ public const string RapidStreetService = "https://rapid.route4me.com/street_data/service";
+
+ //public const string AssetTracking = MainHost + "/api/asset/find_route.php";
+ public const string AssetTracking = MainHost + "/api.v4/status.php";
+ public const string ViewVehicles = MainHost + "/api/vehicles/view_vehicles.php";
+
+ public const string HybridOptimization = MainHost + "/api.v4/hybrid_date_optimization.php";
+
+ #endregion
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/Activity.cs b/Route4MeSDKLibrary/DataTypes/Activity.cs
new file mode 100644
index 00000000..3309af05
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/Activity.cs
@@ -0,0 +1,54 @@
+using Route4MeSDK.QueryTypes;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ ///
+ ///
+ ///
+ [DataContract]
+ public sealed class Activity : GenericParameters
+ {
+ ///
+ /// Activity Id
+ ///
+ [DataMember(Name = "activity_id", EmitDefaultValue = false)]
+ public string ActivityId { get; set; }
+
+ ///
+ /// Activity type
+ ///
+ [DataMember(Name = "activity_type", EmitDefaultValue = false)]
+ public string ActivityType { get; set; }
+
+ ///
+ /// Activity timestamp
+ ///
+ [DataMember(Name = "activity_timestamp", EmitDefaultValue = false)]
+ public uint? ActivityTimestamp { get; set; }
+
+ ///
+ /// Activity message
+ ///
+ [DataMember(Name = "activity_message", EmitDefaultValue = false)]
+ public string ActivityMessage { get; set; }
+
+ ///
+ /// Member Id
+ ///
+ [DataMember(Name = "member_id", EmitDefaultValue = false)]
+ public string MemberId { get; set; }
+
+ ///
+ /// Route Id
+ ///
+ [DataMember(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId { get; set; }
+
+ ///
+ /// Destination Id
+ ///
+ [DataMember(Name = "route_destination_id", EmitDefaultValue = false)]
+ public string RouteDestinationId { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/Address.cs b/Route4MeSDKLibrary/DataTypes/Address.cs
new file mode 100755
index 00000000..898afcdc
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/Address.cs
@@ -0,0 +1,218 @@
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+
+ [DataContract]
+ public sealed class Address
+ {
+ [DataMember(Name = "route_destination_id", EmitDefaultValue = false)]
+ public int? RouteDestinationId { get; set; }
+
+ [DataMember(Name = "alias", EmitDefaultValue = false)]
+ public string Alias { get; set; }
+
+ //the id of the member inside the route4me system
+ [DataMember(Name = "member_id", EmitDefaultValue = false)]
+ public string MemberId { get; set; }
+
+ [DataMember(Name = "first_name", EmitDefaultValue = false)]
+ public string FirstName
+ {
+ get { return m_FirstName; }
+ set { m_FirstName = value; }
+ }
+ private string m_FirstName;
+
+ [DataMember(Name = "last_name", EmitDefaultValue = false)]
+ public string LastName
+ {
+ get { return m_LastName; }
+ set { m_LastName = value; }
+ }
+ private string m_LastName;
+
+ [DataMember(Name = "address")]
+ public string AddressString { get; set; }
+
+ //designate this stop as a depot
+ //a route may have multiple depots/points of origin
+ [DataMember(Name = "is_depot", EmitDefaultValue = false)]
+ public bool? IsDepot { get; set; }
+
+ //the latitude of this address
+ [DataMember(Name = "lat")]
+ public double Latitude { get; set; }
+
+ //the longitude of this address
+ [DataMember(Name = "lng")]
+ public double Longitude { get; set; }
+
+ //the id of the route being viewed, modified, erased
+ [DataMember(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId { get; set; }
+
+ //if this route was duplicated from an existing route, this value would have the original route's id
+ [DataMember(Name = "original_route_id", EmitDefaultValue = false)]
+ public string OriginalRouteId { get; set; }
+
+ //the id of the optimization request that was used to initially instantiate this route
+ [DataMember(Name = "optimization_problem_id", EmitDefaultValue = false)]
+ public string OptimizationProblemId { get; set; }
+
+ [DataMember(Name = "sequence_no", EmitDefaultValue = false)]
+ public int? SequenceNo { get; set; }
+
+ [DataMember(Name = "geocoded", EmitDefaultValue = false)]
+ public bool? Geocoded { get; set; }
+
+ [DataMember(Name = "preferred_geocoding", EmitDefaultValue = false)]
+ public int? PreferredGeocoding { get; set; }
+
+ [DataMember(Name = "failed_geocoding", EmitDefaultValue = false)]
+ public bool? FailedGeocoding { get; set; }
+
+ //when planning a route from the address book or using existing address book ids
+ //pass the address book id (contact_id) for an address so that route4me can run
+ //analytics on the address book addresses that were used to plan routes, and to find previous visits to
+ //favorite addresses
+ [DataMember(Name = "contact_id", EmitDefaultValue = false)]
+ public int? ContactId { get; set; }
+
+ //status flag to mark an address as visited (aka check in)
+ [DataMember(Name = "is_visited", EmitDefaultValue = false)]
+ public bool? IsVisited { get; set; }
+
+ //status flag to mark an address as departed (aka check out)
+ [DataMember(Name = "is_departed", EmitDefaultValue = false)]
+ public bool? IsDeparted { get; set; }
+
+ //the last known visited timestamp of this address
+ [DataMember(Name = "timestamp_last_visited", EmitDefaultValue = false)]
+ public uint? TimestampLastVisited { get; set; }
+
+ //the last known departed timestamp of this address
+ [DataMember(Name = "timestamp_last_departed", EmitDefaultValue = false)]
+ public uint? TimestampLastDeparted { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ [DataMember(Name = "customer_po", EmitDefaultValue = false)]
+ public object CustomerPo { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ [DataMember(Name = "invoice_no", EmitDefaultValue = false)]
+ public object InvoiceNo { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ [DataMember(Name = "reference_no", EmitDefaultValue = false)]
+ public object ReferenceNo { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ [DataMember(Name = "order_no", EmitDefaultValue = false)]
+ public object OrderNo { get; set; }
+
+ [DataMember(Name = "order_id", EmitDefaultValue = false)]
+ public System.Nullable OrderId
+ {
+ get { return m_OrderId; }
+ set { m_OrderId = value; }
+ }
+ private System.Nullable m_OrderId;
+
+ [DataMember(Name = "weight", EmitDefaultValue = false)]
+ public object Weight { get; set; }
+
+ [DataMember(Name = "cost", EmitDefaultValue = false)]
+ public object Cost { get; set; }
+
+ [DataMember(Name = "revenue", EmitDefaultValue = false)]
+ public object Revenue { get; set; }
+
+ //the cubic volume that this destination/order/line-item consumes/contains
+ //this is how much space it will take up on a vehicle
+ [DataMember(Name = "cube", EmitDefaultValue = false)]
+ public object Cube { get; set; }
+
+ //the number of pieces/palllets that this destination/order/line-item consumes/contains on a vehicle
+ [DataMember(Name = "pieces", EmitDefaultValue = false)]
+ public object Pieces { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ //also used to email clients when vehicles are approaching (future capability)
+ [DataMember(Name = "email", EmitDefaultValue = false)]
+ public object Email { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ //also used to sms message clients when vehicles are approaching (future capability)
+ [DataMember(Name = "phone", EmitDefaultValue = false)]
+ public object Phone { get; set; }
+
+ //the number of notes that are already associated with this address on the route
+ [DataMember(Name = "destination_note_count", EmitDefaultValue = false)]
+ public int? DestinationNoteCount { get; set; }
+
+ //server-side generated amount of km/miles that it will take to get to the next location on the route
+ [DataMember(Name = "drive_time_to_next_destination", EmitDefaultValue = false)]
+ public int? DriveTimeToNextDestination { get; set; }
+
+ //server-side generated amount of seconds that it will take to get to the next location
+ [DataMember(Name = "distance_to_next_destination", EmitDefaultValue = false)]
+ public double? DistanceToNextDestination { get; set; }
+
+
+ //estimated time window start based on the optimization engine, after all the sequencing has been completed
+ [DataMember(Name = "generated_time_window_start", EmitDefaultValue = false)]
+ public int? GeneratedTimeWindowStart { get; set; }
+
+ //estimated time window end based on the optimization engine, after all the sequencing has been completed
+ [DataMember(Name = "generated_time_window_end", EmitDefaultValue = false)]
+ public int? GeneratedTimeWindowEnd { get; set; }
+
+ //the unique socket channel name which should be used to get real time alerts
+ [DataMember(Name = "channel_name", EmitDefaultValue = false)]
+ public string ChannelName { get; set; }
+
+ [DataMember(Name = "time_window_start", EmitDefaultValue = false)]
+ public int? TimeWindowStart { get; set; }
+
+ [DataMember(Name = "time_window_end", EmitDefaultValue = false)]
+ public int? TimeWindowEnd { get; set; }
+
+ //the expected amount of time that will be spent at this address by the driver/user
+ [DataMember(Name = "time", EmitDefaultValue = false)]
+ public int? Time { get; set; }
+
+ [DataMember(Name = "notes", EmitDefaultValue = false)]
+ public AddressNote[] Notes { get; set; }
+
+ //if present, the priority will sequence addresses in all the optimal routes so that
+ //higher priority addresses are general at the beginning of the route sequence
+ //1 is the highest priority, 100000 is the lowest
+ [DataMember(Name = "priority", EmitDefaultValue = false)]
+ public int? Priority { get; set; }
+
+ //generate optimal routes and driving directions to this curbside lat
+ [DataMember(Name = "curbside_lat")]
+ public double? CurbsideLatitude { get; set; }
+
+ //generate optimal routes and driving directions to the curbside lang
+ [DataMember(Name = "curbside_lng")]
+ public double? CurbsideLongitude { get; set; }
+
+ [DataMember(Name = "time_window_start_2", EmitDefaultValue = false)]
+ public int? TimeWindowStart2 { get; set; }
+
+ [DataMember(Name = "time_window_end_2", EmitDefaultValue = false)]
+ public int? TimeWindowEnd2 { get; set; }
+
+ [DataMember(Name = "custom_fields", EmitDefaultValue = false)]
+ public Dictionary CustomFields { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/AddressBookContact.cs b/Route4MeSDKLibrary/DataTypes/AddressBookContact.cs
new file mode 100644
index 00000000..dde71e7d
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/AddressBookContact.cs
@@ -0,0 +1,95 @@
+using Route4MeSDK.QueryTypes;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class AddressBookContact : GenericParameters
+ {
+ [DataMember(Name = "territory_name", EmitDefaultValue = false)]
+ public string territory_name { get; set; }
+
+ [DataMember(Name = "created_timestamp", EmitDefaultValue = false)]
+ public int created_timestamp { get; set; }
+
+ [DataMember(Name = "address_id", EmitDefaultValue = false)]
+ public int? address_id { get; set; }
+
+ [DataMember(Name = "address_1")]
+ public string address_1 { get; set; }
+
+ [DataMember(Name = "address_2", EmitDefaultValue = false)]
+ public string address_2 { get; set; }
+
+ [DataMember(Name = "address_alias", EmitDefaultValue = false)]
+ public string address_alias { get; set; }
+
+ [DataMember(Name = "address_group", EmitDefaultValue = false)]
+ public string address_group { get; set; }
+
+ [DataMember(Name = "first_name", EmitDefaultValue = false)]
+ public string first_name { get; set; }
+
+ [DataMember(Name = "last_name", EmitDefaultValue = false)]
+ public string last_name { get; set; }
+
+ [DataMember(Name = "address_email", EmitDefaultValue = false)]
+ public string address_email { get; set; }
+
+ [DataMember(Name = "address_phone_number", EmitDefaultValue = false)]
+ public string address_phone_number { get; set; }
+
+ [DataMember(Name = "cached_lat")]
+ public double cached_lat { get; set; }
+
+ [DataMember(Name = "cached_lng")]
+ public double cached_lng { get; set; }
+
+ [DataMember(Name = "curbside_lat")]
+ public double? curbside_lat { get; set; }
+
+ [DataMember(Name = "curbside_lng")]
+ public double? curbside_lng { get; set; }
+
+ [DataMember(Name = "address_city", EmitDefaultValue = false)]
+ public string address_city { get; set; }
+
+ [DataMember(Name = "address_state_id", EmitDefaultValue = false)]
+ public string address_state_id { get; set; }
+
+ [DataMember(Name = "address_country_id", EmitDefaultValue = false)]
+ public string address_country_id { get; set; }
+
+ [DataMember(Name = "address_zip", EmitDefaultValue = false)]
+ public string address_zip { get; set; }
+
+ [DataMember(Name = "address_custom_data", EmitDefaultValue = false)]
+ public object address_custom_data
+ {
+ get {
+ if (m_address_custom_data == null) return null;
+ string sTypeName = m_address_custom_data.GetType().Name;
+ if (sTypeName == "Object[]") return new Dictionary();
+ return (Dictionary)m_address_custom_data;
+ }
+ set { m_address_custom_data = value; }
+ }
+ private object m_address_custom_data;
+
+ [DataMember(Name = "schedule", EmitDefaultValue = false)]
+ public IList schedule { get; set; }
+
+ [DataMember(Name = "schedule_blacklist", EmitDefaultValue = false)]
+ public string[] schedule_blacklist { get; set; }
+
+ [DataMember(Name = "service_time", EmitDefaultValue = false)]
+ public int? service_time { get; set; }
+
+ [DataMember(Name = "color", EmitDefaultValue = false)]
+ public string color { get; set; }
+
+ [DataMember(Name = "address_icon", EmitDefaultValue = false)]
+ public string address_icon { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/AddressBookContactsResponse.cs b/Route4MeSDKLibrary/DataTypes/AddressBookContactsResponse.cs
new file mode 100644
index 00000000..6abf1a49
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/AddressBookContactsResponse.cs
@@ -0,0 +1,16 @@
+using Route4MeSDK.QueryTypes;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class AddressBookContactsResponse : GenericParameters
+ {
+ [DataMember(Name = "results", EmitDefaultValue = false)]
+ public AddressBookContact[] results { get; set; }
+
+ [DataMember(Name = "total", EmitDefaultValue = false)]
+ public int? total { get; set; }
+ }
+}
\ No newline at end of file
diff --git a/Route4MeSDKLibrary/DataTypes/AddressNote.cs b/Route4MeSDKLibrary/DataTypes/AddressNote.cs
new file mode 100644
index 00000000..14289588
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/AddressNote.cs
@@ -0,0 +1,47 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class AddressNote
+ {
+ [DataMember(Name = "note_id", EmitDefaultValue = false)]
+ public int NoteId { get; set; }
+
+ [DataMember(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId { get; set; }
+
+ [DataMember(Name = "route_destination_id", EmitDefaultValue = false)]
+ public int RouteDestinationId { get; set; }
+
+ [DataMember(Name = "upload_id")]
+ public string UploadId { get; set; }
+
+ [DataMember(Name = "ts_added", EmitDefaultValue = false)]
+ public uint? TimestampAdded { get; set; }
+
+ [DataMember(Name = "lat")]
+ public double Latitude { get; set; }
+
+ [DataMember(Name = "lng")]
+ public double Longitude { get; set; }
+
+ [DataMember(Name = "activity_type")]
+ public string ActivityType { get; set; }
+
+ [DataMember(Name = "contents")]
+ public string Contents { get; set; }
+
+ [DataMember(Name = "upload_type")]
+ public string UploadType { get; set; }
+
+ [DataMember(Name = "upload_url")]
+ public string UploadUrl { get; set; }
+
+ [DataMember(Name = "upload_extension")]
+ public string UploadExtension { get; set; }
+
+ [DataMember(Name = "device_type")]
+ public string DeviceType { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/AvoidanceZone.cs b/Route4MeSDKLibrary/DataTypes/AvoidanceZone.cs
new file mode 100644
index 00000000..f8d253f0
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/AvoidanceZone.cs
@@ -0,0 +1,41 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ ///
+ /// Avoidance Zone
+ ///
+ [DataContract]
+ public sealed class AvoidanceZone
+ {
+ ///
+ /// Avoidance zone id
+ ///
+ [DataMember(Name = "territory_id")]
+ public string TerritoryId { get; set; }
+
+ ///
+ /// Territory name
+ ///
+ [DataMember(Name = "territory_name")]
+ public string TerritoryName { get; set; }
+
+ ///
+ /// Territory color
+ ///
+ [DataMember(Name = "territory_color")]
+ public string TerritoryColor { get; set; }
+
+ ///
+ /// Member Id
+ ///
+ [DataMember(Name = "member_id")]
+ public string MemberId { get; set; }
+
+ ///
+ /// Territory parameters
+ ///
+ [DataMember(Name = "territory")]
+ public Territory Territory { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/DataObject.cs b/Route4MeSDKLibrary/DataTypes/DataObject.cs
new file mode 100755
index 00000000..e8e2787c
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/DataObject.cs
@@ -0,0 +1,46 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ ///
+ /// Main data object data-structure
+ /// See https://www.assembla.com/spaces/route4me_api/wiki/Optimization_Problem_V4
+ ///
+ [DataContract]
+ [KnownType(typeof(DataObjectRoute))]
+ public class DataObject
+ {
+ [DataMember(Name = "optimization_problem_id")]
+ public string OptimizationProblemId { get; set; }
+
+ [DataMember(Name = "state")]
+ public OptimizationState State { get; set; }
+
+ [DataMember(Name = "user_errors")]
+ public string[] UserErrors { get; set; }
+
+ [DataMember(Name = "sent_to_background")]
+ public bool IsSentToBackground { get; set; }
+
+ [DataMember(Name = "parameters")]
+ public RouteParameters Parameters { get; set; }
+
+ [DataMember(Name = "addresses")]
+ public Address[] Addresses { get; set; }
+
+ [DataMember(Name = "routes")]
+ public DataObjectRoute[] Routes { get; set; }
+
+ [DataMember(Name = "links")]
+ public Links Links { get; set; }
+
+ [DataMember(Name = "tracking_history")]
+ public TrackingHistory[] TrackingHistory { get; set; }
+
+ [DataMember(Name = "directions")]
+ public Direction[] Directions { get; set; }
+
+ [DataMember(Name = "path")]
+ public DirectionPathPoint[] Path { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/Direction.cs b/Route4MeSDKLibrary/DataTypes/Direction.cs
new file mode 100644
index 00000000..c0ce2e32
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/Direction.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class Direction
+ {
+ ///
+ /// Location
+ ///
+ [DataMember(Name = "location")]
+ public DirectionLocation Location { get; set; }
+
+ ///
+ /// Steps
+ ///
+ [DataMember(Name = "steps")]
+ public DirectionStep[] Steps { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/DirectionLocation.cs b/Route4MeSDKLibrary/DataTypes/DirectionLocation.cs
new file mode 100644
index 00000000..45d532b0
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/DirectionLocation.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Route4MeSDK.DataTypes
+{
+ ///
+ /// Edge by edge turn-by-turn direction.
+ ///
+ [DataContract]
+ public sealed class DirectionLocation
+ {
+ ///
+ /// Name
+ ///
+ [DataMember(Name = "name")]
+ public string Name { get; set; }
+
+ ///
+ /// Segment time (seconds)
+ ///
+ [DataMember(Name = "time")]
+ public int Time { get; set; }
+
+ ///
+ /// Segment distance
+ ///
+ [DataMember(Name = "segment_distance")]
+ public double SegmentDistance { get; set; }
+
+ ///
+ /// Start Location
+ ///
+ [DataMember(Name = "start_location")]
+ public string StartLocation { get; set; }
+
+ ///
+ /// End Location
+ ///
+ [DataMember(Name = "end_location")]
+ public string EndLocation { get; set; }
+
+ ///
+ /// Directions Error
+ ///
+ [DataMember(Name = "directions_error")]
+ public string DirectionsError { get; set; }
+
+ ///
+ /// Error Code
+ ///
+ [DataMember(Name = "error_code")]
+ public int ErrorCode { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/DirectionPathPoint.cs b/Route4MeSDKLibrary/DataTypes/DirectionPathPoint.cs
new file mode 100644
index 00000000..8412dd8a
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/DirectionPathPoint.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Route4MeSDK.DataTypes
+{
+ ///
+ /// Direction Path Point
+ ///
+ [DataContract]
+ public sealed class DirectionPathPoint
+ {
+ ///
+ /// Latitude
+ ///
+ [DataMember(Name = "lat")]
+ public double Lat { get; set; }
+
+ ///
+ /// Longitude
+ ///
+ [DataMember(Name = "lng")]
+ public double Lng { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/DirectionStep.cs b/Route4MeSDKLibrary/DataTypes/DirectionStep.cs
new file mode 100644
index 00000000..bd784887
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/DirectionStep.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Route4MeSDK.DataTypes
+{
+ ///
+ /// Direction Step
+ ///
+ [DataContract]
+ public sealed class DirectionStep
+ {
+ ///
+ /// Name (detailed)
+ ///
+ [DataMember(Name = "direction")]
+ public string Direction { get; set; }
+
+ ///
+ /// Name (brief)
+ ///
+ [DataMember(Name = "directions")]
+ public string Directions { get; set; }
+
+ ///
+ /// Distance
+ ///
+ [DataMember(Name = "distance")]
+ public double Distance { get; set; }
+
+ ///
+ /// Distance units
+ ///
+ [DataMember(Name = "distance_unit")]
+ public string DistanceUnit { get; set; }
+
+ ///
+ /// Maneuver Type
+ ///
+ [DataMember(Name = "maneuverType")]
+ public string ManeuverType { get; set; }
+
+ ///
+ /// Compass Direction
+ ///
+ [DataMember(Name = "compass_direction")]
+ public string CompassDirection { get; set; }
+
+ ///
+ /// Duration (seconds)
+ ///
+ [DataMember(Name = "duration_sec")]
+ public int DurationSec { get; set; }
+
+ ///
+ /// Maneuver Point
+ ///
+ [DataMember(Name = "maneuverPoint")]
+ public DirectionPathPoint ManeuverPoint { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/Enums.cs b/Route4MeSDKLibrary/DataTypes/Enums.cs
new file mode 100755
index 00000000..69c79fe7
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/Enums.cs
@@ -0,0 +1,217 @@
+using System.ComponentModel;
+
+namespace Route4MeSDK.DataTypes
+{
+
+ public enum AlgorithmType
+ {
+ TSP = 1, //single depot, single driver route
+ VRP = 2, //single depot, multiple driver, no constraints, no time windows, no capacities
+ CVRP_TW_SD = 3, //single depot, multiple driver, capacitated, time windows
+ CVRP_TW_MD = 4, //multiple depot, multiple driver, capacitated, time windows
+ TSP_TW = 5, //single depot, single driver, time windows
+ TSP_TW_CR = 6, //single depot, single driver, time windows, continuous optimization (minimal location shifting)
+ BBCVRP = 7, //shifts addresses from one route to another over time on a recurring schedule
+ ALG_NONE = 100,
+ ALG_LEGACY_DISTRIBUTED = 101
+ }
+
+
+ public enum TravelMode : uint
+ {
+ [Description("Driving")]
+ Driving,
+
+ [Description("Walking")]
+ Walking,
+
+ [Description("Trucking")]
+ Trucking
+ }
+
+
+ public enum DistanceUnit : uint
+ {
+ [Description("mi")]
+ MI,
+
+ [Description("km")]
+ KM
+ }
+ public enum Avoid
+ {
+ [Description("Highways")]
+ Highways,
+
+ [Description("Tolls")]
+ Tolls,
+
+ [Description("minimizeHighways")]
+ MinimizeHighways,
+
+ [Description("minimizeTolls")]
+ MinimizeTolls,
+
+ [Description("")]
+ None
+ }
+
+
+ public enum Optimize : uint
+ {
+ [Description("Distance")]
+ Distance,
+
+ [Description("Time")]
+ Time,
+
+ [Description("timeWithTraffic")]
+ TimeWithTraffic
+ }
+
+
+ public enum Metric : uint
+ {
+ Euclidean = 1, //measures point to point distance as a straight line
+ Manhattan = 2, //measures point to point distance as taxicab geometry line
+ Geodesic = 3, //measures point to point distance approximating curvature of the earth
+ Matrix = 4, //measures point to point distance by traversing the actual road network
+ Exact_2D = 5 //measures point to point distance using 2d rectilinear distance
+ }
+
+ public enum DeviceType
+ {
+ [Description("web")]
+ Web,
+
+ [Description("iphone")]
+ IPhone,
+
+ [Description("ipad")]
+ IPad,
+
+ [Description("android_phone")]
+ AndroidPhone,
+
+ [Description("android_tablet")]
+ AndroidTablet
+ }
+
+
+ public enum Format
+ {
+ [Description("csv")]
+ Csv,
+
+ [Description("serialized")]
+ Serialized,
+
+ [Description("xml")]
+ Xml
+ }
+
+
+ //an optimization problem can be at one state at any given time
+ //every state change invokes a socket notification to the associated member id
+ //every state change invokes a callback webhook event invocation if it was provided during the initial optimization
+ public enum OptimizationState : uint
+ {
+ Initial = 1,
+ MatrixProcessing = 2,
+ Optimizing = 3,
+ Optimized = 4,
+ Error = 5,
+ ComputingDirections = 6
+ }
+
+ //if the actual polylines of the driving path between all the stops on the route should be returned
+ public enum RoutePathOutput : uint
+ {
+ [Description("None")]
+ None,
+
+ [Description("Points")]
+ Points
+ }
+
+ public enum StatusUpdateType
+ {
+ [Description("pickup")]
+ Pickup,
+
+ [Description("dropoff")]
+ DropOff,
+
+ [Description("noanswer")]
+ NoAnswer,
+
+ [Description("notfound")]
+ NotFound,
+
+ [Description("notpaid")]
+ NotPaid,
+
+ [Description("paid")]
+ Paid,
+
+ [Description("wrongdelivery")]
+ WrongDelivery,
+
+ [Description("wrongaddressrecipient")]
+ WrongAddressRecipient,
+
+ [Description("notpresent")]
+ NotPresent,
+
+ [Description("parts_missing")]
+ PartsMissing,
+
+ [Description("service_rendered")]
+ ServiceRendered,
+
+ [Description("follow_up")]
+ FollowUp,
+
+ [Description("left_information")]
+ LeftInformation,
+
+ [Description("spoke_with_decision_maker")]
+ SpokeWithDecisionMaker,
+
+ [Description("spoke_with_decision_influencer")]
+ SpokeWithDecisionInfluencer,
+
+ [Description("competitive_account")]
+ CompetitiveAccount,
+
+ [Description("scheduled_follow_up_meeting")]
+ ScheduledFollowUpMeeting,
+
+ [Description("scheduled_lunch")]
+ ScheduledLunch,
+
+ [Description("scheduled_product_demo")]
+ ScheduledProductDemo,
+
+ [Description("scheduled_clinical_demo")]
+ ScheduledClinicalDemo,
+
+ [Description("no_opportunity")]
+ NoOpportunity
+ }
+
+ ///
+ /// Territory type (circle, rectangle, polygon)
+ ///
+ public enum TerritoryType : uint
+ {
+ [Description("circle")]
+ Circle,
+
+ [Description("poly")]
+ Poly,
+
+ [Description("rect")]
+ Rect
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/ErrorResponse.cs b/Route4MeSDKLibrary/DataTypes/ErrorResponse.cs
new file mode 100644
index 00000000..de00a448
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/ErrorResponse.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Route4MeSDKLibrary.DataTypes
+{
+ ///
+ /// Errors data-structure
+ ///
+ [DataContract]
+ public class ErrorResponse
+ {
+ [DataMember(Name = "errors")]
+ public List Errors { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/FindAssetResponse.cs b/Route4MeSDKLibrary/DataTypes/FindAssetResponse.cs
new file mode 100644
index 00000000..78b01c75
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/FindAssetResponse.cs
@@ -0,0 +1,107 @@
+using System.Runtime.Serialization;
+using System.Collections.Generic;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class FindAssetResponse
+ {
+ [DataMember(Name = "tracking_number")]
+ public string TrackingNumber
+ {
+ get { return m_TrackingNumber; }
+ set { m_TrackingNumber = value; }
+ }
+ private string m_TrackingNumber;
+
+ [DataMember(Name = "status_history")]
+ public string[] StatusHistory
+ {
+ get { return m_StatusHistory; }
+ set { m_StatusHistory = value; }
+ }
+ private string[] m_StatusHistory;
+
+ [DataMember(Name = "locations")]
+ public FindAssetResponseLocations[] Locations
+ {
+ get { return m_Locations; }
+ set { m_Locations = value; }
+ }
+ private FindAssetResponseLocations[] m_Locations;
+
+ [DataMember(Name = "custom_data", EmitDefaultValue = false)]
+ public Dictionary CustomData
+ {
+ get { return m_CustomData; }
+ set { m_CustomData = value; }
+ }
+ private Dictionary m_CustomData;
+
+ [DataMember(Name = "arrival")]
+ public FindAssetResponseArrival[] Arrival
+ {
+ get { return m_Arrival; }
+ set { m_Arrival = value; }
+ }
+ private FindAssetResponseArrival[] m_Arrival;
+
+ [DataMember(Name = "delivered", EmitDefaultValue = false)]
+ public System.Nullable Delivered
+ {
+ get { return m_Delivered; }
+ set { m_Delivered = value; }
+ }
+ private System.Nullable m_Delivered;
+ }
+
+ [DataContract()]
+ public sealed class FindAssetResponseLocations
+ {
+ [DataMember(Name = "lat")]
+ public double Latitude
+ {
+ get { return m_Latitude; }
+ set { m_Latitude = value; }
+ }
+ private double m_Latitude;
+
+ [DataMember(Name = "lng")]
+ public double Longitude
+ {
+ get { return m_Longitude; }
+ set { m_Longitude = value; }
+ }
+ private double m_Longitude;
+
+ [DataMember(Name = "icon")]
+ public string Icon
+ {
+ get { return m_Icon; }
+ set { m_Icon = value; }
+ }
+ private string m_Icon;
+ }
+
+ [DataContract()]
+ public sealed class FindAssetResponseArrival
+ {
+ [DataMember(Name = "from_unix_timestamp")]
+ public System.Nullable FromUnixTimestamp
+ {
+ get { return m_FromUnixTimestamp; }
+ set { m_FromUnixTimestamp = value; }
+ }
+ private System.Nullable m_FromUnixTimestamp;
+
+
+ [DataMember(Name = "to_unix_timestamp")]
+ public System.Nullable ToUnixTimestamp
+ {
+ get { return m_ToUnixTimestamp; }
+ set { m_ToUnixTimestamp = value; }
+ }
+ private System.Nullable m_ToUnixTimestamp;
+ }
+
+ }
diff --git a/Route4MeSDKLibrary/DataTypes/GeoPoint.cs b/Route4MeSDKLibrary/DataTypes/GeoPoint.cs
new file mode 100644
index 00000000..15684ff8
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/GeoPoint.cs
@@ -0,0 +1,24 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class GeoPoint
+ {
+ [DataMember(Name = "lat")]
+ public double Latitude
+ {
+ get { return m_Latitude; }
+ set { m_Latitude = value; }
+ }
+ private double m_Latitude;
+
+ [DataMember(Name = "lng")]
+ public double Longitude
+ {
+ get { return m_Longitude; }
+ set { m_Longitude = value; }
+ }
+ private double m_Longitude;
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/Links.cs b/Route4MeSDKLibrary/DataTypes/Links.cs
new file mode 100755
index 00000000..5d02ebca
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/Links.cs
@@ -0,0 +1,18 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+
+ [DataContract]
+ public sealed class Links
+ {
+ [DataMember(Name = "route")]
+ public string Route { get; set; }
+
+ [DataMember(Name = "view")]
+ public string View { get; set; }
+
+ [DataMember(Name = "optimization_problem_id")]
+ public string OptimizationProblemId { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/MemberConfigurationData.cs b/Route4MeSDKLibrary/DataTypes/MemberConfigurationData.cs
new file mode 100644
index 00000000..d5003359
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/MemberConfigurationData.cs
@@ -0,0 +1,32 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class MemberConfigurationData
+ {
+ [DataMember(Name = "member_id", EmitDefaultValue = false)]
+ public int member_id
+ {
+ get { return m_member_id; }
+ set { m_member_id = value; }
+ }
+ private int m_member_id;
+
+ [DataMember(Name = "config_key", EmitDefaultValue = false)]
+ public string config_key
+ {
+ get { return m_config_key; }
+ set { m_config_key = value; }
+ }
+ private string m_config_key;
+
+ [DataMember(Name = "config_value", EmitDefaultValue = false)]
+ public string config_value
+ {
+ get { return m_config_value; }
+ set { m_config_value = value; }
+ }
+ private string m_config_value;
+ }
+}
\ No newline at end of file
diff --git a/Route4MeSDKLibrary/DataTypes/MemberConfigurationDataRersponse.cs b/Route4MeSDKLibrary/DataTypes/MemberConfigurationDataRersponse.cs
new file mode 100644
index 00000000..90f9bf8b
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/MemberConfigurationDataRersponse.cs
@@ -0,0 +1,24 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class MemberConfigurationDataRersponse
+ {
+ [DataMember(Name = "config_key", EmitDefaultValue = false)]
+ public string result
+ {
+ get { return m_result; }
+ set { m_result = value; }
+ }
+ private string m_result;
+
+ [DataMember(Name = "data", EmitDefaultValue = false)]
+ public MemberConfigurationData[] data
+ {
+ get { return m_data; }
+ set { m_data = value; }
+ }
+ private MemberConfigurationData[] m_data;
+ }
+}
\ No newline at end of file
diff --git a/Route4MeSDKLibrary/DataTypes/MemberConfigurationResponse.cs b/Route4MeSDKLibrary/DataTypes/MemberConfigurationResponse.cs
new file mode 100644
index 00000000..f6e08a78
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/MemberConfigurationResponse.cs
@@ -0,0 +1,25 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class MemberConfigurationResponse
+ {
+ [DataMember(Name = "result")]
+ public string result
+ {
+ get { return m_result; }
+ set { m_result = value; }
+ }
+ private string m_result;
+
+ [DataMember(Name = "affected")]
+ public int affected
+ {
+ get { return m_affected; }
+ set { m_affected = value; }
+ }
+ private int m_affected;
+
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/MemberResponse.cs b/Route4MeSDKLibrary/DataTypes/MemberResponse.cs
new file mode 100644
index 00000000..71782c57
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/MemberResponse.cs
@@ -0,0 +1,216 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class MemberResponse
+ {
+ [DataMember(Name = "status")]
+ public System.Nullable Status
+ {
+ get { return m_Status; }
+ set { m_Status = value; }
+ }
+ private System.Nullable m_Status;
+
+ [DataMember(Name = "geocoding_service")]
+ public string GeocodingService
+ {
+ get { return m_GeocodingService; }
+ set { m_GeocodingService = value; }
+ }
+ private string m_GeocodingService;
+
+ [DataMember(Name = "session_id")]
+ public System.Nullable SessionId
+ {
+ get { return m_SessionId; }
+ set { m_SessionId = value; }
+ }
+ private System.Nullable m_SessionId;
+
+ [DataMember(Name = "session_guid")]
+ public string SessionGuid
+ {
+ get { return m_SessionGuid; }
+ set { m_SessionGuid = value; }
+ }
+ private string m_SessionGuid;
+
+ [DataMember(Name = "member_id")]
+ public System.Nullable MemberId
+ {
+ get { return m_MemberId; }
+ set { m_MemberId = value; }
+ }
+ private System.Nullable m_MemberId;
+
+ [DataMember(Name = "api_key")]
+ public string ApiKey
+ {
+ get { return m_ApiKey; }
+ set { m_ApiKey = value; }
+ }
+ private string m_ApiKey;
+
+ [DataMember(Name = "tracking_ttl")]
+ public System.Nullable TrackingTtl
+ {
+ get { return m_TrackingTtl; }
+ set { m_TrackingTtl = value; }
+ }
+ private System.Nullable m_TrackingTtl;
+
+ [DataMember(Name = "geofence_polygon_shape")]
+ public string GeofencePolygonShape
+ {
+ get { return m_GeofencePolygonShape; }
+ set { m_GeofencePolygonShape = value; }
+ }
+ private string m_GeofencePolygonShape;
+
+ [DataMember(Name = "geofence_polygon_size")]
+ public System.Nullable GeofencePolygonSize
+ {
+ get { return m_GeofencePolygonSize; }
+ set { m_GeofencePolygonSize = value; }
+ }
+ private System.Nullable m_GeofencePolygonSize;
+
+ [DataMember(Name = "geofence_time_onsite_trigger_secs")]
+ public System.Nullable GeofenceTimeOnsiteTriggerSecs
+ {
+ get { return m_GeofenceTimeOnsiteTriggerSecs; }
+ set { m_GeofenceTimeOnsiteTriggerSecs = value; }
+ }
+ private System.Nullable m_GeofenceTimeOnsiteTriggerSecs;
+
+ [DataMember(Name = "geofence_minimum_trigger_speed")]
+ public System.Nullable GeofenceMinimumTriggerSpeed
+ {
+ get { return m_GeofenceMinimumTriggerSpeed; }
+ set { m_GeofenceMinimumTriggerSpeed = value; }
+ }
+ private System.Nullable m_GeofenceMinimumTriggerSpeed;
+
+ [DataMember(Name = "is_subscription_past_due")]
+ public System.Nullable IsSubscriptionPastDue
+ {
+ get { return m_IsSubscriptionPastDue; }
+ set { m_IsSubscriptionPastDue = value; }
+ }
+ private System.Nullable m_IsSubscriptionPastDue;
+
+ [DataMember(Name = "visited_departed_enabled")]
+ public string VisitedDepartedEnabled
+ {
+ get { return m_VisitedDepartedEnabled; }
+ set { m_VisitedDepartedEnabled = value; }
+ }
+ private string m_VisitedDepartedEnabled;
+
+ [DataMember(Name = "long_press_enabled")]
+ public string LongPressEnabled
+ {
+ get { return m_LongPressEnabled; }
+ set { m_LongPressEnabled = value; }
+ }
+ private string m_LongPressEnabled;
+
+ [DataMember(Name = "account_type_id")]
+ public System.Nullable AccountTypeId
+ {
+ get { return m_AccountTypeId; }
+ set { m_AccountTypeId = value; }
+ }
+ private System.Nullable m_AccountTypeId;
+
+ [DataMember(Name = "account_type_alias")]
+ public string AccountTypeAlias
+ {
+ get { return m_AccountTypeAlias; }
+ set { m_AccountTypeAlias = value; }
+ }
+ private string m_AccountTypeAlias;
+
+ [DataMember(Name = "member_type")]
+ public string MemberType
+ {
+ get { return m_MemberType; }
+ set { m_MemberType = value; }
+ }
+ private string m_MemberType;
+
+ [DataMember(Name = "max_stops_per_route")]
+ public System.Nullable MaxStopsPerRoute
+ {
+ get { return m_MaxStopsPerRoute; }
+ set { m_MaxStopsPerRoute = value; }
+ }
+ private System.Nullable m_MaxStopsPerRoute;
+
+ [DataMember(Name = "max_routes")]
+ public System.Nullable MaxRoutes
+ {
+ get { return m_MaxRoutes; }
+ set { m_MaxRoutes = value; }
+ }
+ private System.Nullable m_MaxRoutes;
+
+ [DataMember(Name = "routes_planned")]
+ public System.Nullable RoutesPlanned
+ {
+ get { return m_RoutesPlanned; }
+ set { m_RoutesPlanned = value; }
+ }
+ private System.Nullable m_RoutesPlanned;
+
+ [DataMember(Name = "preferred_units")]
+ public string PreferredUnits
+ {
+ get { return m_PreferredUnits; }
+ set { m_PreferredUnits = value; }
+ }
+ private string m_PreferredUnits;
+
+ [DataMember(Name = "preferred_language")]
+ public string PreferredLanguage
+ {
+ get { return m_PreferredLanguage; }
+ set { m_PreferredLanguage = value; }
+ }
+ private string m_PreferredLanguage;
+
+ [DataMember(Name = "HIDE_ROUTED_ADDRESSES")]
+ public string HideRoutedAddresses
+ {
+ get { return m_HideRoutedAddresses; }
+ set { m_HideRoutedAddresses = value; }
+ }
+ private string m_HideRoutedAddresses;
+
+ [DataMember(Name = "HIDE_VISITED_ADDRESSES")]
+ public string HideVisitedAddresses
+ {
+ get { return m_HideVisitedAddresses; }
+ set { m_HideVisitedAddresses = value; }
+ }
+ private string m_HideVisitedAddresses;
+
+ [DataMember(Name = "HIDE_NONFUTURE_ROUTES")]
+ public string HideNonfutureAddresses
+ {
+ get { return m_HideNonfutureAddresses; }
+ set { m_HideNonfutureAddresses = value; }
+ }
+ private string m_HideNonfutureAddresses;
+
+ [DataMember(Name = "auto_logout_ts")]
+ public System.Nullable AutoLogoutTs
+ {
+ get { return m_AutoLogoutTs; }
+ set { m_AutoLogoutTs = value; }
+ }
+ private System.Nullable m_AutoLogoutTs;
+ }
+}
\ No newline at end of file
diff --git a/Route4MeSDKLibrary/DataTypes/MemberResponseV4.cs b/Route4MeSDKLibrary/DataTypes/MemberResponseV4.cs
new file mode 100644
index 00000000..25026f57
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/MemberResponseV4.cs
@@ -0,0 +1,175 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class MemberResponseV4
+ {
+ [DataMember(Name = "HIDE_NONFUTURE_ROUTES", EmitDefaultValue = false)]
+ public string HIDE_NONFUTURE_ROUTES
+ {
+ get { return m_HIDE_NONFUTURE_ROUTES; }
+ set { m_HIDE_NONFUTURE_ROUTES = value; }
+ }
+ private string m_HIDE_NONFUTURE_ROUTES;
+
+ [DataMember(Name = "HIDE_ROUTED_ADDRESSES", EmitDefaultValue = false)]
+ public string HIDE_ROUTED_ADDRESSES
+ {
+ get { return m_HIDE_ROUTED_ADDRESSES; }
+ set { m_HIDE_ROUTED_ADDRESSES = value; }
+ }
+ private string m_HIDE_ROUTED_ADDRESSES;
+
+ [DataMember(Name = "HIDE_VISITED_ADDRESSES", EmitDefaultValue = false)]
+ public string HIDE_VISITED_ADDRESSES
+ {
+ get { return m_HIDE_VISITED_ADDRESSES; }
+ set { m_HIDE_VISITED_ADDRESSES = value; }
+ }
+ private string m_HIDE_VISITED_ADDRESSES;
+
+ [DataMember(Name = "member_id")]
+ public string member_id
+ {
+ get { return m_member_id; }
+ set { m_member_id = value; }
+ }
+ private string m_member_id;
+
+ [DataMember(Name = "OWNER_MEMBER_ID")]
+ public string OWNER_MEMBER_ID
+ {
+ get { return m_OWNER_MEMBER_ID; }
+ set { m_OWNER_MEMBER_ID = value; }
+ }
+ private string m_OWNER_MEMBER_ID;
+
+ [DataMember(Name = "READONLY_USER")]
+ public string READONLY_USER
+ {
+ get { return m_READONLY_USER; }
+ set { m_READONLY_USER = value; }
+ }
+ private string m_READONLY_USER;
+
+ [DataMember(Name = "SHOW_ALL_DRIVERS")]
+ public string SHOW_ALL_DRIVERS
+ {
+ get { return m_SHOW_ALL_DRIVERS; }
+ set { m_SHOW_ALL_DRIVERS = value; }
+ }
+ private string m_SHOW_ALL_DRIVERS;
+
+ [DataMember(Name = "SHOW_ALL_VEHICLES")]
+ public string SHOW_ALL_VEHICLES
+ {
+ get { return m_SHOW_ALL_VEHICLES; }
+ set { m_SHOW_ALL_VEHICLES = value; }
+ }
+ private string m_SHOW_ALL_VEHICLES;
+
+ [DataMember(Name = "date_of_birth")]
+ public string date_of_birth
+ {
+ get { return m_date_of_birth; }
+ set { m_date_of_birth = value; }
+ }
+ private string m_date_of_birth;
+
+ [DataMember(Name = "member_email")]
+ public string member_email
+ {
+ get { return m_member_email; }
+ set { m_member_email = value; }
+ }
+ private string m_member_email;
+
+ [DataMember(Name = "member_first_name")]
+ public string member_first_name
+ {
+ get { return m_member_first_name; }
+ set { m_member_first_name = value; }
+ }
+ private string m_member_first_name;
+
+ [DataMember(Name = "member_last_name")]
+ public string member_last_name
+ {
+ get { return m_member_last_name; }
+ set { m_member_last_name = value; }
+ }
+ private string m_member_last_name;
+
+ [DataMember(Name = "member_phone")]
+ public string member_phone
+ {
+ get { return m_member_phone; }
+ set { m_member_phone = value; }
+ }
+ private string m_member_phone;
+
+ [DataMember(Name = "member_picture")]
+ public string member_picture {
+ get { return m_member_picture; }
+ set { m_member_picture = value; }
+ }
+ private string m_member_picture;
+
+ [DataMember(Name = "member_type")]
+ public string member_type
+ {
+ get { return m_member_type; }
+ set { m_member_type = value; }
+ }
+ private string m_member_type;
+
+ [DataMember(Name = "member_zipcode")]
+ public string member_zipcode
+ {
+ get { return m_member_zipcode; }
+ set { m_member_zipcode = value; }
+ }
+ private string m_member_zipcode;
+
+ [DataMember(Name = "preferred_language")]
+ public string preferred_language
+ {
+ get { return m_preferred_language; }
+ set { m_preferred_language = value; }
+ }
+ private string m_preferred_language;
+
+ [DataMember(Name = "preferred_units")]
+ public string preferred_units
+ {
+ get { return m_preferred_units; }
+ set { m_preferred_units = value; }
+ }
+ private string m_preferred_units;
+
+ [DataMember(Name = "timezone")]
+ public string timezone
+ {
+ get { return m_timezone; }
+ set { m_timezone = value; }
+ }
+ private string m_timezone;
+
+ [DataMember(Name = "user_reg_country_id")]
+ public string user_reg_country_id
+ {
+ get { return m_user_reg_country_id; }
+ set { m_user_reg_country_id = value; }
+ }
+ private string m_user_reg_country_id;
+
+ [DataMember(Name = "user_reg_state_id")]
+ public string user_reg_state_id
+ {
+ get { return m_user_reg_state_id; }
+ set { m_user_reg_state_id = value; }
+ }
+ private string m_user_reg_state_id;
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/Order.cs b/Route4MeSDKLibrary/DataTypes/Order.cs
new file mode 100644
index 00000000..ff750294
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/Order.cs
@@ -0,0 +1,185 @@
+using Route4MeSDK.QueryTypes;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class Order : GenericParameters
+ {
+
+ ///
+ /// Order ID.
+ ///
+ [DataMember(Name = "order_id", EmitDefaultValue = false)]
+ public int order_id { get; set; }
+
+ ///
+ /// Address 1 field. Required
+ ///
+ [DataMember(Name = "address_1")]
+ public string address_1 { get; set; }
+
+ ///
+ /// Address 2 field
+ ///
+ [DataMember(Name = "address_2", EmitDefaultValue = false)]
+ public string address_2 { get; set; }
+
+ ///
+ /// Geo latitude. Required
+ ///
+ [DataMember(Name = "cached_lat")]
+ public double cached_lat { get; set; }
+
+ ///
+ /// Geo longitude. Required
+ ///
+ [DataMember(Name = "cached_lng")]
+ public double cached_lng { get; set; }
+
+ ///
+ /// Generate optimal routes and driving directions to this curbside latitude
+ ///
+ [DataMember(Name = "curbside_lat", EmitDefaultValue = false)]
+ public double? curbside_lat { get; set; }
+
+ ///
+ /// Generate optimal routes and driving directions to the curbside langitude
+ ///
+ [DataMember(Name = "curbside_lng", EmitDefaultValue = false)]
+ public double? curbside_lng { get; set; }
+
+ ///
+ /// Scheduled day
+ ///
+ [DataMember(Name = "day_scheduled_for_YYMMDD", EmitDefaultValue = false)]
+ public string day_scheduled_for_YYMMDD { get; set; }
+
+ ///
+ /// Address Alias. Required
+ ///
+ [DataMember(Name = "address_alias")]
+ public string address_alias { get; set; }
+
+ ///
+ /// Local time window start
+ ///
+ [DataMember(Name = "local_time_window_start", EmitDefaultValue = false)]
+ public int? local_time_window_start { get; set; }
+
+ ///
+ /// Local time window end
+ ///
+ [DataMember(Name = "local_time_window_end", EmitDefaultValue = false)]
+ public int? local_time_window_end { get; set; }
+
+ ///
+ /// Second Local time window start
+ ///
+ [DataMember(Name = "local_time_window_start_2", EmitDefaultValue = false)]
+ public int? local_time_window_start_2 { get; set; }
+
+ ///
+ /// Second local time window end
+ ///
+ [DataMember(Name = "local_time_window_end_2", EmitDefaultValue = false)]
+ public int? local_time_window_end_2 { get; set; }
+
+ ///
+ /// Second time
+ ///
+ [DataMember(Name = "service_time", EmitDefaultValue = false)]
+ public int? service_time { get; set; }
+
+ ///
+ /// Address City
+ ///
+ [DataMember(Name = "address_city", EmitDefaultValue = false)]
+ public string address_city { get; set; }
+
+ ///
+ /// Address state ID
+ ///
+ [DataMember(Name = "address_state_id", EmitDefaultValue = false)]
+ public string address_state_id { get; set; }
+
+ ///
+ /// Address country ID
+ ///
+ [DataMember(Name = "address_country_id", EmitDefaultValue = false)]
+ public string address_country_id { get; set; }
+
+ ///
+ /// Address ZIP
+ ///
+ [DataMember(Name = "address_zip", EmitDefaultValue = false)]
+ public string address_zip { get; set; }
+
+ ///
+ /// Order status ID
+ ///
+ [DataMember(Name = "order_status_id", EmitDefaultValue = false)]
+ public int order_status_id { get; set; }
+
+ ///
+ /// The id of the member inside the route4me system
+ ///
+ [DataMember(Name = "member_id", EmitDefaultValue = false)]
+ public int member_id { get; set; }
+
+ ///
+ /// First name
+ ///
+ [DataMember(Name = "EXT_FIELD_first_name", EmitDefaultValue = false)]
+ public string EXT_FIELD_first_name { get; set; }
+
+ ///
+ /// Last name
+ ///
+ [DataMember(Name = "EXT_FIELD_last_name", EmitDefaultValue = false)]
+ public string EXT_FIELD_last_name { get; set; }
+
+ ///
+ /// Email
+ ///
+ [DataMember(Name = "EXT_FIELD_email", EmitDefaultValue = false)]
+ public string EXT_FIELD_email { get; set; }
+
+ ///
+ /// Phone number
+ ///
+ [DataMember(Name = "EXT_FIELD_phone", EmitDefaultValue = false)]
+ public string EXT_FIELD_phone { get; set; }
+
+ ///
+ /// Custom data
+ ///
+ [DataMember(Name = "EXT_FIELD_custom_data", EmitDefaultValue = false)]
+ public object EXT_FIELD_custom_data
+ {
+ get
+ {
+ if (m_EXT_FIELD_custom_data == null) return null;
+ string sTypeName = m_EXT_FIELD_custom_data.GetType().Name;
+ if (sTypeName == "Object[]") return new Dictionary();
+ return (Dictionary)m_EXT_FIELD_custom_data;
+ }
+ set { m_EXT_FIELD_custom_data = value; }
+ }
+ private object m_EXT_FIELD_custom_data;
+
+ ///
+ /// Local timezone string
+ ///
+ [DataMember(Name = "local_timezone_string", EmitDefaultValue = false)]
+ public string local_timezone_string { get; set; }
+
+ ///
+ /// Order icon
+ ///
+ [DataMember(Name = "order_icon", EmitDefaultValue = false)]
+ public string order_icon { get; set; }
+
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/OrdersResponse.cs b/Route4MeSDKLibrary/DataTypes/OrdersResponse.cs
new file mode 100644
index 00000000..5d06ada6
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/OrdersResponse.cs
@@ -0,0 +1,16 @@
+using Route4MeSDK.QueryTypes;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class OrdersResponse : GenericParameters
+ {
+ [DataMember(Name = "results", EmitDefaultValue = false)]
+ public Order[] results { get; set; }
+
+ [DataMember(Name = "total", EmitDefaultValue = false)]
+ public int? total { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/Route.cs b/Route4MeSDKLibrary/DataTypes/Route.cs
new file mode 100755
index 00000000..97987b9b
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/Route.cs
@@ -0,0 +1,49 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+
+
+ [DataContract]
+ public sealed class DataObjectRoute : DataObject
+ {
+ [DataMember(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteID { get; set; }
+
+ [DataMember(Name = "member_id", EmitDefaultValue = false)]
+ public string MemberId { get; set; }
+
+ [DataMember(Name = "member_email", EmitDefaultValue = false)]
+ public string MemberEmail { get; set; }
+
+ [DataMember(Name = "vehicle_alias", EmitDefaultValue = false)]
+ public string VehicleAlias { get; set; }
+
+ [DataMember(Name = "driver_alias", EmitDefaultValue = false)]
+ public string DriverAlias { get; set; }
+
+ [DataMember(Name = "route_cost", EmitDefaultValue = false)]
+ public double? RouteCost { get; set; }
+
+ [DataMember(Name = "route_revenue", EmitDefaultValue = false)]
+ public double? RouteRevenue { get; set; }
+
+ [DataMember(Name = "net_revenue_per_distance_unit", EmitDefaultValue = false)]
+ public double? NetRevenuePerDistanceUnit { get; set; }
+
+ [DataMember(Name = "created_timestamp", EmitDefaultValue = false)]
+ public int? CreatedTimestamp { get; set; }
+
+ [DataMember(Name = "mpg", EmitDefaultValue = false)]
+ public string mpg { get; set; }
+
+ [DataMember(Name = "trip_distance", EmitDefaultValue = false)]
+ public double? TripDistance { get; set; }
+
+ [DataMember(Name = "gas_price", EmitDefaultValue = false)]
+ public double? GasPrice { get; set; }
+
+ [DataMember(Name = "route_duration_sec", EmitDefaultValue = false)]
+ public int? RouteDurationSec { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/RouteParameters.cs b/Route4MeSDKLibrary/DataTypes/RouteParameters.cs
new file mode 100755
index 00000000..b8022986
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/RouteParameters.cs
@@ -0,0 +1,209 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+
+ [DataContract]
+ public sealed class RouteParameters
+ {
+
+ //let the R4M api know if this sdk request is coming from a file upload within your environment (for analytics)
+ [DataMember(Name = "is_upload", EmitDefaultValue = false)]
+ public string IsUpload { get; set; }
+
+ //the tour type of this route. rt is short for round trip, the optimization engine changes its behavior for round trip routes
+ [DataMember(Name = "rt", EmitDefaultValue = false)]
+ public bool? RT { get; set; }
+
+ //by disabling optimization, the route optimization engine will not resequence the stops in your
+ [DataMember(Name = "disable_optimization", EmitDefaultValue = false)]
+ public bool? DisableOptimization { get; set; }
+
+ //the name of this route. this route name will be accessible in the search API, and also will be displayed on the mobile device of a user
+ [DataMember(Name = "route_name", EmitDefaultValue = false)]
+ public string RouteName { get; set; }
+
+ //the route start date in UTC, unix timestamp seconds.
+ //used to show users when the route will begin, also used for reporting and analytics
+ [DataMember(Name = "route_date", EmitDefaultValue = false)]
+ public long? RouteDate { get; set; }
+
+ //offset in seconds relative to the route start date (i.e. 9AM would be 60 * 60 * 9)
+ [DataMember(Name = "route_time", EmitDefaultValue = false)]
+ public object RouteTime { get; set; }
+
+ //deprecated
+ //specify if the route can be viewed by unauthenticated users
+ [DataMember(Name = "shared_publicly", EmitDefaultValue = false)]
+ public string SharedPublicly { get; set; }
+
+
+ [DataMember(Name = "optimize", EmitDefaultValue = false)]
+ public string Optimize { get; set; }
+
+ //when the tour type is not round trip (rt = false), enable lock last so that the final destination is fixed
+ //example: driver leaves a depot, but must always arrive at home ( or a specific gas station) at the end of the route
+ [DataMember(Name = "lock_last", EmitDefaultValue = false)]
+ public bool? LockLast { get; set; }
+
+
+ [DataMember(Name = "vehicle_capacity", EmitDefaultValue = false)]
+ public string VehicleCapacity { get; set; }
+
+ [DataMember(Name = "vehicle_max_distance_mi", EmitDefaultValue = false)]
+ public string VehicleMaxDistanceMI { get; set; }
+
+ //km or mi, the route4me api will convert all measurements into these units
+ [DataMember(Name = "distance_unit", EmitDefaultValue = false)]
+ public string DistanceUnit { get; set; }
+
+ [DataMember(Name = "travel_mode", EmitDefaultValue = false)]
+ public string TravelMode { get; set; }
+
+ [DataMember(Name = "avoid", EmitDefaultValue = false)]
+ public string Avoid { get; set; }
+
+ [DataMember(Name = "vehicle_id", EmitDefaultValue = false)]
+ public string VehicleId { get; set; }
+
+ //deprecated, all new routes should be assigned to a member_id
+ [DataMember(Name = "driver_id", EmitDefaultValue = false)]
+ public string DriverId { get; set; }
+
+ //the latitude of the device making this sdk request
+ [DataMember(Name = "dev_lat", EmitDefaultValue = false)]
+ public double? DevLatitude { get; set; }
+
+ //the longitude of the device making this sdk request
+ [DataMember(Name = "dev_lng", EmitDefaultValue = false)]
+ public double? DevLongitude { get; set; }
+
+ //when using a multiple driver algorithm, this is the maximum permissible duration of a generated route
+ //the optimization system will automatically create more routes when the route_max_duration is exceeded for a route
+ //however it will create an 'unrouted' list of addresses if the maximum number of drivers is exceeded
+ [DataMember(Name = "route_max_duration", EmitDefaultValue = false)]
+ public int? RouteMaxDuration { get; set; }
+
+ //the email address to notify upon completion of an optimization request
+ [DataMember(Name = "route_email", EmitDefaultValue = false)]
+ public string RouteEmail { get; set; }
+
+ //type of route being created: ENUM(api,null)
+ [DataMember(Name = "route_type", EmitDefaultValue = false)]
+ public string RouteType { get; set; }
+
+ //deprecated
+ //all routes are stored by default at this time
+ [DataMember(Name = "store_route", EmitDefaultValue = false)]
+ public bool? StoreRoute { get; set; }
+
+ //1 = ROUTE4ME_METRIC_EUCLIDEAN (use euclidean distance when computing point to point distance)
+ //2 = ROUTE4ME_METRIC_MANHATTAN (use manhattan distance (taxicab geometry) when computing point to point distance)
+ //3 = ROUTE4ME_METRIC_GEODESIC (use geodesic distance when computing point to point distance)
+ //#4 is the default and suggested metric
+ //4 = ROUTE4ME_METRIC_MATRIX (use road network driving distance when computing point to point distance)
+ //5 = ROUTE4ME_METRIC_EXACT_2D (use exact rectilinear distance)
+ [DataMember(Name = "metric", EmitDefaultValue = false)]
+ public Metric Metric { get; set; }
+
+ //the type of algorithm to use when optimizing the route
+ [DataMember(Name = "algorithm_type", EmitDefaultValue = false)]
+ public AlgorithmType AlgorithmType { get; set; }
+
+ //in order for users in your organization to have routes assigned to them,
+ //you must provide their member id within the route4me system
+ //a list of member ids can be retrieved with view_users api method
+ [DataMember(Name = "member_id", EmitDefaultValue = false)]
+ public string MemberId { get; set; }
+
+
+ //specify the ip address of the remote user making this optimization request
+ [DataMember(Name = "ip", EmitDefaultValue = false)]
+ public string Ip { get; set; }
+
+
+ //the method to use when compute the distance between the points in a route
+ //1 = DEFAULT (R4M PROPRIETARY ROUTING)
+ //2 = DEPRECRATED
+ //3 = R4M TRAFFIC ENGINE
+ //4 = DEPRECATED
+ //5 = DEPRECATED
+ //6 = TRUCKING
+ [DataMember(Name = "dm", EmitDefaultValue = false)]
+ public int? DM { get; set; }
+
+ //directions method
+ //1 = DEFAULT (R4M PROPRIETARY INTERNAL NAVIGATION SYSTEM)
+ //2 = DEPRECATED
+ //3 = TRUCKING
+ //4 = DEPRECATED
+ [DataMember(Name = "dirm", EmitDefaultValue = false)]
+ public int? Dirm { get; set; }
+
+ [DataMember(Name = "parts", EmitDefaultValue = false)]
+ public int? Parts { get; set; }
+
+ //deprecated
+ [DataMember(Name = "device_id", EmitDefaultValue = false)]
+ public object DeviceID { get; set; }
+
+ //the type of device making this request
+ //ENUM("web", "iphone", "ipad", "android_phone", "android_tablet")
+ [DataMember(Name = "device_type", EmitDefaultValue = false)]
+ public string DeviceType { get; set; }
+
+ //for routes that have trucking directions enabled, directions generated
+ //will ensure compliance so that road directions generated do not take the vehicle
+ //where trailers are prohibited
+ [DataMember(Name = "has_trailer", EmitDefaultValue = false)]
+ public bool? HasTrailer { get; set; }
+
+ //for routes that have trucking directions enabled, directions generated
+ //will ensure compliance so that road directions generated do not take the vehicle
+ //on roads where the weight of the vehicle in tons exceeds this value
+ [DataMember(Name = "trailer_weight_t", EmitDefaultValue = false)]
+ public double? TrailerWeightT { get; set; }
+
+
+ [DataMember(Name = "limited_weight_t", EmitDefaultValue = false)]
+ public double? LimitedWeightT { get; set; }
+
+ //for routes that have trucking directions enabled, directions generated
+ //will ensure compliance so that road directions generated do not take the vehicle
+ //where the weight per axle in tons exceeds this value
+ [DataMember(Name = "weight_per_axle_t", EmitDefaultValue = false)]
+ public double? WeightPerAxleT { get; set; }
+
+ //for routes that have trucking directions enabled, directions generated
+ //will ensure compliance of this maximum height of truck when generating road network driving directions
+ [DataMember(Name = "truck_height_meters", EmitDefaultValue = false)]
+ public int? TruckHeightMeters { get; set; }
+
+ //for routes that have trucking directions enabled, directions generated
+ //will ensure compliance of this width of the truck when generating road network driving directions
+ [DataMember(Name = "truck_width_meters", EmitDefaultValue = false)]
+ public int? TruckWidthMeters { get; set; }
+
+ //for routes that have trucking directions enabled, directions generated
+ //will ensure compliance of this length of the truck when generating road network driving directions
+ [DataMember(Name = "truck_length_meters", EmitDefaultValue = false)]
+ public int? TruckLengthMeters { get; set; }
+
+
+ //the minimum number of stops permitted per created subroute
+ [DataMember(Name = "min_tour_size", EmitDefaultValue = false)]
+ public int? MinTourSize { get; set; }
+
+ //the maximum number of stops permitted per created subroute
+ [DataMember(Name = "max_tour_size", EmitDefaultValue = false)]
+ public int? MaxTourSize { get; set; }
+
+ //there are 3 types of optimization qualities that are optimizations goals
+ //1 - Generate Optimized Routes As Quickly as Possible
+ //2 - Generate Routes That Look Better On A Map
+ //3 - Generate The Shortest And Quickest Possible Routes
+
+ [DataMember(Name = "optimization_quality", EmitDefaultValue = false)]
+ public int? OptimizationQuality { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/RouteResponse.cs b/Route4MeSDKLibrary/DataTypes/RouteResponse.cs
new file mode 100644
index 00000000..acc18519
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/RouteResponse.cs
@@ -0,0 +1,291 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class RouteResponse
+ {
+ [DataMember(Name = "route_id")]
+ public string RouteID
+ {
+ get { return m_RouteID; }
+ set { m_RouteID = value; }
+ }
+ private string m_RouteID;
+
+ [DataMember(Name = "optimization_problem_id")]
+ public string OptimizationProblemId
+ {
+ get { return m_OptimizationProblemId; }
+ set { m_OptimizationProblemId = value; }
+ }
+ private string m_OptimizationProblemId;
+
+ ///
+ /// Route rating by user [0 - 5]
+ ///
+ [DataMember(Name = "user_route_rating")]
+ public System.Nullable UserRouteRating
+ {
+ get { return m_UserRouteRating; }
+ set { m_UserRouteRating = value; }
+ }
+ private System.Nullable m_UserRouteRating;
+
+ [DataMember(Name = "member_id")]
+ public System.Nullable MemberId
+ {
+ get { return m_MemberId; }
+ set { m_MemberId = value; }
+ }
+ private System.Nullable m_MemberId;
+
+ [DataMember(Name = "member_email")]
+ public string MemberEmail
+ {
+ get { return m_MemberEmail; }
+ set { m_MemberEmail = value; }
+ }
+ private string m_MemberEmail;
+
+ [DataMember(Name = "member_first_name")]
+ public string MemberFirstName
+ {
+ get { return m_MemberFirstName; }
+ set { m_MemberFirstName = value; }
+ }
+ private string m_MemberFirstName;
+
+ [DataMember(Name = "member_last_name")]
+ public string MemberLastName
+ {
+ get { return m_MemberLastName; }
+ set { m_MemberLastName = value; }
+ }
+ private string m_MemberLastName;
+
+ [DataMember(Name = "channel_name")]
+ public string ChannelName
+ {
+ get { return m_ChannelName; }
+ set { m_ChannelName = value; }
+ }
+ private string m_ChannelName;
+
+ [DataMember(Name = "vehicle_alias")]
+ public string VehicleAlias
+ {
+ get { return m_VehicleAlias; }
+ set { m_VehicleAlias = value; }
+ }
+ private string m_VehicleAlias;
+
+ [DataMember(Name = "driver_alias")]
+ public string DriverAlias
+ {
+ get { return m_DriverAlias; }
+ set { m_DriverAlias = value; }
+ }
+ private string m_DriverAlias;
+
+ [DataMember(Name = "trip_distance")]
+ public System.Nullable TripDistance
+ {
+ get { return m_TripDistance; }
+ set { m_TripDistance = value; }
+ }
+ private System.Nullable m_TripDistance;
+
+ [DataMember(Name = "is_unrouted")]
+ public bool IsUnrouted
+ {
+ get { return m_IsUnrouted; }
+ set { m_IsUnrouted = value; }
+ }
+ private bool m_IsUnrouted;
+
+ [DataMember(Name = "route_cost")]
+ public System.Nullable RouteCost
+ {
+ get { return m_RouteCost; }
+ set { m_RouteCost = value; }
+ }
+ private System.Nullable m_RouteCost;
+
+ [DataMember(Name = "route_revenue")]
+ public System.Nullable RouteRevenue
+ {
+ get { return m_RouteRevenue; }
+ set { m_RouteRevenue = value; }
+ }
+ private System.Nullable m_RouteRevenue;
+
+ [DataMember(Name = "net_revenue_per_distance_unit")]
+ public System.Nullable NetRevenuePerDistanceUnit
+ {
+ get { return m_NetRevenuePerDistanceUnit; }
+ set { m_NetRevenuePerDistanceUnit = value; }
+ }
+ private System.Nullable m_NetRevenuePerDistanceUnit;
+
+ [DataMember(Name = "created_timestamp")]
+ public System.Nullable CreatedTimestamp
+ {
+ get { return m_CreatedTimestamp; }
+ set { m_CreatedTimestamp = value; }
+ }
+ private System.Nullable m_CreatedTimestamp;
+
+ [DataMember(Name = "mpg")]
+ public System.Nullable mpg
+ {
+ get { return m_mpg; }
+ set { m_mpg = value; }
+ }
+ private System.Nullable m_mpg;
+
+ [DataMember(Name = "gas_price")]
+ public System.Nullable GasPrice
+ {
+ get { return m_GasPrice; }
+ set { m_GasPrice = value; }
+ }
+ private System.Nullable m_GasPrice;
+
+ [DataMember(Name = "route_duration_sec")]
+ public System.Nullable RouteDurationSec
+ {
+ get { return m_RouteDurationSec; }
+ set { m_RouteDurationSec = value; }
+ }
+ private System.Nullable m_RouteDurationSec;
+
+ [DataMember(Name = "planned_total_route_duration")]
+ public System.Nullable PlannedTotalRouteDuration
+ {
+ get { return m_PlannedTotalRouteDuration; }
+ set { m_PlannedTotalRouteDuration = value; }
+ }
+ private System.Nullable m_PlannedTotalRouteDuration;
+
+ [DataMember(Name = "actual_travel_distance")]
+ public System.Nullable ActualTravelDistance
+ {
+ get { return m_ActualTravelDistance; }
+ set { m_ActualTravelDistance = value; }
+ }
+ private System.Nullable m_ActualTravelDistance;
+
+ [DataMember(Name = "actual_travel_time")]
+ public System.Nullable ActualTravelTime
+ {
+ get { return m_ActualTravelTime; }
+ set { m_ActualTravelTime = value; }
+ }
+ private System.Nullable m_ActualTravelTime;
+
+ [DataMember(Name = "actual_footsteps")]
+ public System.Nullable ActualFootSteps
+ {
+ get { return m_ActualFootSteps; }
+ set { m_ActualFootSteps = value; }
+ }
+ private System.Nullable m_ActualFootSteps;
+
+ [DataMember(Name = "working_time")]
+ public System.Nullable WorkingTime
+ {
+ get { return m_WorkingTime; }
+ set { m_WorkingTime = value; }
+ }
+ private System.Nullable m_WorkingTime;
+
+ [DataMember(Name = "driving_time")]
+ public System.Nullable DrivingTime
+ {
+ get { return m_DrivingTime; }
+ set { m_DrivingTime = value; }
+ }
+ private System.Nullable m_DrivingTime;
+
+ [DataMember(Name = "idling_time")]
+ public System.Nullable IdlingTime
+ {
+ get { return m_IdlingTime; }
+ set { m_IdlingTime = value; }
+ }
+ private System.Nullable m_IdlingTime;
+
+ [DataMember(Name = "paying_miles")]
+ public System.Nullable PayingMiles
+ {
+ get { return m_PayingMiles; }
+ set { m_PayingMiles = value; }
+ }
+ private System.Nullable m_PayingMiles;
+
+ [DataMember(Name = "geofence_polygon_type")]
+ public string GeofencePolygonType
+ {
+ get { return m_GeofencePolygonType; }
+ set { m_GeofencePolygonType = value; }
+ }
+ private string m_GeofencePolygonType;
+
+ [DataMember(Name = "geofence_polygon_size")]
+ public System.Nullable GeofencePolygonSize
+ {
+ get { return m_GeofencePolygonSize; }
+ set { m_GeofencePolygonSize = value; }
+ }
+ private System.Nullable m_GeofencePolygonSize;
+
+ [DataMember(Name = "parameters")]
+ public RouteParameters Parameters
+ {
+ get { return m_Parameters; }
+ set { m_Parameters = value; }
+ }
+ private RouteParameters m_Parameters;
+
+ [DataMember(Name = "addresses")]
+ public Address[] Addresses
+ {
+ get { return m_Addresses; }
+ set { m_Addresses = value; }
+ }
+ private Address[] m_Addresses;
+
+ [DataMember(Name = "links")]
+ public Links Links
+ {
+ get { return m_Links; }
+ set { m_Links = value; }
+ }
+ private Links m_Links;
+
+ [DataMember(Name = "notes")]
+ public AddressNote[] Notes
+ {
+ get { return m_Notes; }
+ set { m_Notes = value; }
+ }
+ private AddressNote[] m_Notes;
+
+ [DataMember(Name = "path")]
+ public GeoPoint[] Path
+ {
+ get { return m_Path; }
+ set { m_Path = value; }
+ }
+ private GeoPoint[] m_Path;
+
+ [DataMember(Name = "directions")]
+ public Direction[] Directions
+ {
+ get { return m_Directions; }
+ set { m_Directions = value; }
+ }
+ private Direction[] m_Directions;
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/Schedule.cs b/Route4MeSDKLibrary/DataTypes/Schedule.cs
new file mode 100644
index 00000000..66180ad7
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/Schedule.cs
@@ -0,0 +1,239 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.ComponentModel.DataAnnotations;
+
+namespace Route4MeSDK.DataTypes
+{
+ ///
+ /// A trip schedule to a location
+ ///
+ [DataContract]
+ public sealed class Schedule
+ {
+ public Schedule(string sMode, bool blNth)
+ {
+ switch (sMode)
+ {
+ case "daily":
+ this.daily = new schedule_daily();
+ this.mode = "daily";
+ break;
+ case "weekly":
+ this.weekly = new schedule_weekly();
+ this.mode = "weekly";
+ //this.weekly.weekdays = new int[]{};
+ break;
+ case "monthly":
+ this.monthly = new schedule_monthly();
+ this.mode = "monthly";
+ if (blNth) this.monthly.nth = new schedule_monthly_nth();
+ break;
+ case "annually":
+ this.annually = new schedule_annually();
+ this.mode = "annually";
+ if (blNth) this.annually.nth = new schedule_monthly_nth();
+ //this.annually.months = new int[] { };
+ break;
+ }
+
+ }
+
+ public Schedule()
+ {
+
+ }
+
+ [DataMember(Name = "enabled")]
+ public bool enabled { get; set; }
+
+ [DataMember(Name = "mode"), CustomValidation(typeof(PropertyValidation), "ValidateScheduleMode")]
+ public string mode { get; set; }
+
+ [DataMember(Name = "daily", EmitDefaultValue = false, IsRequired = false)]
+ public schedule_daily daily { get; set; }
+
+ [DataMember(Name = "weekly", EmitDefaultValue = false, IsRequired = false)]
+ public schedule_weekly weekly { get; set; }
+
+ [DataMember(Name = "monthly", EmitDefaultValue = false, IsRequired = false)]
+ public schedule_monthly monthly { get; set; }
+
+ [DataMember(Name = "annually", EmitDefaultValue = false, IsRequired = false)]
+ public schedule_annually annually { get; set; }
+
+ public bool ValidateScheduleMode(object ScheduleMode)
+ {
+ if (ScheduleMode == null) return false;
+ if (Array.IndexOf(new string[]{"daily","weekly","monthly","annually"},ScheduleMode.ToString())>=0) return true;
+ return false;
+ }
+
+ public bool ValidateScheduleEnabled(object ScheduleEnabled)
+ {
+ bool blValid = false;
+ if (bool.TryParse(ScheduleEnabled.ToString(), out blValid)) return true; else return false;
+ }
+
+ public bool ValidateScheduleUseNth(object ScheduleUseNth)
+ {
+ bool blValid = false;
+ if (bool.TryParse(ScheduleUseNth.ToString(), out blValid)) return true; else return false;
+ }
+
+ public bool ValidateScheduleEvery(object ScheduleEvery)
+ {
+ int iEvery = -1;
+ if (int.TryParse(ScheduleEvery.ToString(), out iEvery)) return true; else return false;
+ }
+
+ public bool ValidateScheduleWeekdays(object Weekdays)
+ {
+ if (Weekdays == null) return false;
+
+ bool blValid = true;
+
+ string[] arWeekdays = Weekdays.ToString().Split(',');
+
+ foreach (string weekday in arWeekdays)
+ {
+ int iWeekday = -1;
+ if (!int.TryParse(weekday, out iWeekday)) { blValid = false; break; }
+
+ iWeekday = Convert.ToInt32(weekday);
+ if (iWeekday > 7 || iWeekday < 1) { blValid = false; break; }
+ }
+
+ return blValid;
+ }
+
+ public bool ValidateScheduleMonthDays(object ScheduleMonthDays)
+ {
+ if (ScheduleMonthDays == null) return false;
+
+ bool blValid = true;
+
+ string[] arMonthdays = ScheduleMonthDays.ToString().Split(',');
+
+ foreach (string monthday in arMonthdays)
+ {
+ int iMonthday = -1;
+ if (!int.TryParse(monthday, out iMonthday)) { blValid = false; break; }
+
+ iMonthday = Convert.ToInt32(monthday);
+ if (iMonthday > 31 || iMonthday < 1) { blValid = false; break; }
+ }
+
+ return blValid;
+ }
+
+ public bool ValidateScheduleYearMonths(object ScheduleYearMonths)
+ {
+ if (ScheduleYearMonths == null) return false;
+
+ bool blValid = true;
+
+ string[] arYearMonth = ScheduleYearMonths.ToString().Split(',');
+
+ foreach (string yearmonth in arYearMonth)
+ {
+ int iYearmonth = -1;
+ if (!int.TryParse(yearmonth, out iYearmonth)) { blValid = false; break; }
+
+ iYearmonth = Convert.ToInt32(yearmonth);
+ if (iYearmonth > 12 || iYearmonth < 1) { blValid = false; break; }
+ }
+
+ return blValid;
+ }
+
+ public bool ValidateScheduleMonthlyMode(object ScheduleMonthlyMode)
+ {
+ if (ScheduleMonthlyMode == null) return false;
+ if (Array.IndexOf(new string[] { "dates", "nth" }, ScheduleMonthlyMode.ToString()) >= 0) return true;
+ return false;
+ }
+
+ public bool ValidateScheduleNthN(object ScheduleNthN)
+ {
+ int iN = -1;
+ if (!int.TryParse(ScheduleNthN.ToString(), out iN)) return false;
+ iN = Convert.ToInt32(ScheduleNthN);
+
+ if (Array.IndexOf(new int[] { 1, 2, 3, 4, 5, -1 }, iN) < 0) return false;
+
+ return true;
+ }
+
+ public bool ValidateScheduleNthWhat(object ScheduleNthWhat)
+ {
+ int iN = -1;
+ if (!int.TryParse(ScheduleNthWhat.ToString(), out iN)) return false;
+ iN = Convert.ToInt32(ScheduleNthWhat);
+
+ if (Array.IndexOf(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, iN) < 0) return false;
+
+ return true;
+ }
+
+ }
+
+ [DataContract]
+ public class schedule_daily
+ {
+ [DataMember(Name = "every")]
+ public int every { get; set; }
+ }
+
+ [DataContract]
+ public class schedule_weekly
+ {
+ [DataMember(Name = "every")]
+ public int every { get; set; }
+
+ [DataMember(Name = "weekdays", EmitDefaultValue = false), Range(1, 7, ErrorMessage = "Weekday must be between 1 and 7")]
+ public int[] weekdays { get; set; }
+ }
+
+ [DataContract]
+ public class schedule_monthly_nth
+ {
+ [DataMember(Name = "n", EmitDefaultValue = false), CustomValidation(typeof(PropertyValidation), "ValidateMonthlyNthN")]
+ public int n { get; set; }
+
+ [DataMember(Name = "what", EmitDefaultValue = false), Range(1, 10, ErrorMessage = "Wrong value for the What Time parameter")]
+ public int what { get; set; }
+ }
+
+ [DataContract]
+ public class schedule_monthly
+ {
+ [DataMember(Name = "every")]
+ public int every { get; set; }
+
+ [DataMember(Name = "mode"), CustomValidation(typeof(PropertyValidation), "ValidateScheduleMonthlyMode")]
+ public string mode { get; set; }
+
+ [DataMember(Name = "dates", EmitDefaultValue = false), Range(1, 31, ErrorMessage = "Month day must be between 1 and 31")]
+ public int[] dates { get; set; }
+
+ [DataMember(Name = "nth", EmitDefaultValue = false)]
+ public schedule_monthly_nth nth { get; set; }
+ }
+
+ [DataContract]
+ public class schedule_annually
+ {
+ [DataMember(Name = "every")]
+ public int every { get; set; }
+
+ [DataMember(Name = "use_nth")]
+ public bool use_nth { get; set; }
+
+ [DataMember(Name = "months", EmitDefaultValue = false), Range(1, 12, ErrorMessage = "Month number must be between 1 and 12")]
+ public int[] months { get; set; }
+
+ [DataMember(Name = "nth", EmitDefaultValue = false)]
+ public schedule_monthly_nth nth { get; set; }
+ }
+}
\ No newline at end of file
diff --git a/Route4MeSDKLibrary/DataTypes/Territory.cs b/Route4MeSDKLibrary/DataTypes/Territory.cs
new file mode 100644
index 00000000..e9eb83f6
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/Territory.cs
@@ -0,0 +1,23 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ ///
+ /// Territory parameters
+ ///
+ [DataContract]
+ public sealed class Territory
+ {
+ ///
+ /// Territory type (circle, rectangle, polygon)
+ ///
+ [DataMember(Name = "type")]
+ public string Type { get; set; }
+
+ ///
+ /// Territory figure data
+ ///
+ [DataMember(Name = "data")]
+ public string[] Data { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/TerritoryZone.cs b/Route4MeSDKLibrary/DataTypes/TerritoryZone.cs
new file mode 100644
index 00000000..cd820de1
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/TerritoryZone.cs
@@ -0,0 +1,77 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ ///
+ /// Territory Zone
+ ///
+ [DataContract]
+ public sealed class TerritoryZone
+ {
+ ///
+ /// Avoidance zone id
+ ///
+ [DataMember(Name = "territory_id")]
+ public string TerritoryId
+ {
+ get { return m_TerritoryId; }
+ set { m_TerritoryId = value; }
+ }
+ private string m_TerritoryId;
+
+ ///
+ /// Territory name
+ ///
+ [DataMember(Name = "territory_name")]
+ public string TerritoryName
+ {
+ get { return m_TerritoryName; }
+ set { m_TerritoryName = value; }
+ }
+ private string m_TerritoryName;
+
+ ///
+ /// Territory color
+ ///
+ [DataMember(Name = "territory_color")]
+ public string TerritoryColor
+ {
+ get { return m_TerritoryColor; }
+ set { m_TerritoryColor = value; }
+ }
+ private string m_TerritoryColor;
+
+ ///
+ /// Territory addresses
+ ///
+ [DataMember(Name = "addresses")]
+ public int[] addresses
+ {
+ get { return m_addresses; }
+ set { m_addresses = value; }
+ }
+ private int[] m_addresses;
+
+ ///
+ /// Member Id
+ ///
+ [DataMember(Name = "member_id")]
+ public string MemberId
+ {
+ get { return m_MemberId; }
+ set { m_MemberId = value; }
+ }
+ private string m_MemberId;
+
+ ///
+ /// Territory parameters
+ ///
+ [DataMember(Name = "territory")]
+ public Territory Territory
+ {
+ get { return m_Territory; }
+ set { m_Territory = value; }
+ }
+ private Territory m_Territory;
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/TrackingHistory.cs b/Route4MeSDKLibrary/DataTypes/TrackingHistory.cs
new file mode 100755
index 00000000..1b06c778
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/TrackingHistory.cs
@@ -0,0 +1,34 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+
+ [DataContract]
+ public sealed class TrackingHistory
+ {
+ /* tracking data key names are shortened to reduce bandwidth usage (even with compression on) */
+ // speed at the time of the location transaction event
+ [DataMember(Name = "s")]
+ public double? Speed {get; set; }
+
+ // latitude at the time of the location transaction event
+ [DataMember(Name = "lt")]
+ public double? Latitude { get; set; }
+
+ // longitude at the time of the location transaction event
+ [DataMember(Name = "lg")]
+ public double? Longitude { get; set; }
+
+ // direction/heading at the time of the location transaction event
+ [DataMember(Name = "d")]
+ public string D {get; set; }
+
+ // the original timestamp in unix timestamp format at the moment location transaction event
+ [DataMember(Name = "ts")]
+ public string TimeStamp {get; set; }
+
+ // the original timestamp in a human readable timestamp format at the moment location transaction event
+ [DataMember(Name = "ts_friendly")]
+ public string TimeStampFriendly { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/User.cs b/Route4MeSDKLibrary/DataTypes/User.cs
new file mode 100644
index 00000000..b651ea4d
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/User.cs
@@ -0,0 +1,36 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class User
+ {
+ //the id of the member inside the route4me system
+ [DataMember(Name = "member_id", EmitDefaultValue = false)]
+ public int? MemberId { get; set; }
+
+ [DataMember(Name = "account_type_id", EmitDefaultValue = false)]
+ public int? AccountTypeId { get; set; }
+
+ [DataMember(Name = "member_type", EmitDefaultValue = false)]
+ public string MemberType { get; set; }
+
+ [DataMember(Name = "member_first_name")]
+ public string MemberFirstName { get; set; }
+
+ [DataMember(Name = "member_last_name")]
+ public string MemberLasttName { get; set; }
+
+ [DataMember(Name = "member_email")]
+ public string MemberEmail { get; set; }
+
+ [DataMember(Name = "phone_number")]
+ public string PhoneNumber { get; set; }
+
+ [DataMember(Name = "readonly_user", EmitDefaultValue = false)]
+ public bool? ReadonlyUser { get; set; }
+
+ [DataMember(Name = "show_superuser_addresses", EmitDefaultValue = false)]
+ public bool? ShowSuperuserAddresses { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/VehicleResponse.cs b/Route4MeSDKLibrary/DataTypes/VehicleResponse.cs
new file mode 100644
index 00000000..2413322f
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/VehicleResponse.cs
@@ -0,0 +1,194 @@
+using Route4MeSDK.QueryTypes;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.DataTypes
+{
+ [DataContract]
+ public sealed class VehicleResponse : GenericParameters
+ {
+ [DataMember(Name = "vehicle_id")]
+ public string VehicleId
+ {
+ get { return m_VehicleId; }
+ set { m_VehicleId = value; }
+ }
+ private string m_VehicleId;
+
+ [DataMember(Name = "created_time")]
+ public string CreatedTime
+ {
+ get { return m_CreatedTime; }
+ set { m_CreatedTime = value; }
+ }
+ private string m_CreatedTime;
+
+ [DataMember(Name = "member_id")]
+ public string MemberId
+ {
+ get { return m_MemberId; }
+ set { m_MemberId = value; }
+ }
+ private string m_MemberId;
+
+ [DataMember(Name = "vehicle_alias")]
+ public string VehicleAlias
+ {
+ get { return m_VehicleAlias; }
+ set { m_VehicleAlias = value; }
+ }
+ private string m_VehicleAlias;
+
+ [DataMember(Name = "vehicle_vin")]
+ public string VehicleVin
+ {
+ get { return m_VehicleVin; }
+ set { m_VehicleVin = value; }
+ }
+ private string m_VehicleVin;
+
+ [DataMember(Name = "vehicle_reg_state")]
+ public string VehicleRegState
+ {
+ get { return m_VehicleRegState; }
+ set { m_VehicleRegState = value; }
+ }
+ private string m_VehicleRegState;
+
+ [DataMember(Name = "vehicle_reg_state_id")]
+ public System.Nullable VehicleRegStateId
+ {
+ get { return m_VehicleRegStateId; }
+ set { m_VehicleRegStateId = value; }
+ }
+ private System.Nullable m_VehicleRegStateId;
+
+ [DataMember(Name = "vehicle_reg_country")]
+ public string VehicleRegCountry
+ {
+ get { return m_VehicleRegCountry; }
+ set { m_VehicleRegCountry = value; }
+ }
+ private string m_VehicleRegCountry;
+
+ [DataMember(Name = "vehicle_reg_country_id")]
+ public System.Nullable VehicleRegCountryId
+ {
+ get { return m_VehicleRegCountryId; }
+ set { m_VehicleRegCountryId = value; }
+ }
+ private System.Nullable m_VehicleRegCountryId;
+
+ [DataMember(Name = "vehicle_license_plate")]
+ public string VehicleLicensePlate
+ {
+ get { return m_VehicleLicensePlate; }
+ set { m_VehicleLicensePlate = value; }
+ }
+ private string m_VehicleLicensePlate;
+
+ [DataMember(Name = "vehicle_make")]
+ public string VehicleMake
+ {
+ get { return m_VehicleMake; }
+ set { m_VehicleMake = value; }
+ }
+ private string m_VehicleMake;
+
+ [DataMember(Name = "vehicle_model_year")]
+ public System.Nullable VehicleModelYear
+ {
+ get { return m_VehicleModelYear; }
+ set { m_VehicleModelYear = value; }
+ }
+ private System.Nullable m_VehicleModelYear;
+
+ [DataMember(Name = "vehicle_model")]
+ public string VehicleModel
+ {
+ get { return m_VehicleModel; }
+ set { m_VehicleModel = value; }
+ }
+ private string m_VehicleModel;
+
+ [DataMember(Name = "vehicle_year_acquired")]
+ public System.Nullable VehicleYearAcquired
+ {
+ get { return m_VehicleYearAcquired; }
+ set { m_VehicleYearAcquired = value; }
+ }
+ private System.Nullable m_VehicleYearAcquired;
+
+ [DataMember(Name = "vehicle_cost_new")]
+ public System.Nullable VehicleCostNew
+ {
+ get { return m_VehicleCostNew; }
+ set { m_VehicleCostNew = value; }
+ }
+ private System.Nullable m_VehicleCostNew;
+
+ [DataMember(Name = "license_start_date")]
+ public string LicenseStartDate
+ {
+ get { return m_LicenseStartDate; }
+ set { m_LicenseStartDate = value; }
+ }
+ private string m_LicenseStartDate;
+
+ [DataMember(Name = "license_end_date")]
+ public string LicenseEndDate
+ {
+ get { return m_LicenseEndDate; }
+ set { m_LicenseEndDate = value; }
+ }
+ private string m_LicenseEndDate;
+
+ [DataMember(Name = "vehicle_axle_count")]
+ public System.Nullable VehicleAxleCount
+ {
+ get { return m_VehicleAxleCount; }
+ set { m_VehicleAxleCount = value; }
+ }
+ private System.Nullable m_VehicleAxleCount;
+
+ [DataMember(Name = "mpg_city")]
+ public System.Nullable MpgCity
+ {
+ get { return m_MpgCity; }
+ set { m_MpgCity = value; }
+ }
+ private System.Nullable m_MpgCity;
+
+ [DataMember(Name = "mpg_highway")]
+ public System.Nullable MpgHighway
+ {
+ get { return m_MpgHighway; }
+ set { m_MpgHighway = value; }
+ }
+ private System.Nullable m_MpgHighway;
+
+ [DataMember(Name = "fuel_type")]
+ public string FuelType
+ {
+ get { return m_FuelType; }
+ set { m_FuelType = value; }
+ }
+ private string m_FuelType;
+
+ [DataMember(Name = "height_inches")]
+ public System.Nullable HeightInches
+ {
+ get { return m_HeightInches; }
+ set { m_HeightInches = value; }
+ }
+ private System.Nullable m_HeightInches;
+
+ [DataMember(Name = "weight_lb")]
+ public System.Nullable WeightLb
+ {
+ get { return m_WeightLb; }
+ set { m_WeightLb = value; }
+ }
+ private System.Nullable m_WeightLb;
+ }
+}
diff --git a/Route4MeSDKLibrary/DataTypes/cDatabase.cs b/Route4MeSDKLibrary/DataTypes/cDatabase.cs
new file mode 100644
index 00000000..477f83a5
--- /dev/null
+++ b/Route4MeSDKLibrary/DataTypes/cDatabase.cs
@@ -0,0 +1,1066 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Json;
+using System.Data;
+using System.Data.Common;
+using System.Configuration;
+using System.Data.OleDb;
+using System.Web.Script;
+
+namespace Route4MeSDK.DataTypes
+{
+ public enum R4M_DataType
+ {
+ Activity,
+ Addressbook,
+ AvoidanceZone,
+ Member,
+ Note,
+ Optimization,
+ Order,
+ Route,
+ Telematics,
+ Territory,
+ Vehicle
+ }
+
+ public enum DB_Type
+ {
+ MSSQL,
+ MySQL,
+ PostgreSQL,
+ SQLite,
+ MS_Access
+ }
+
+ public class cDatabase : IDisposable
+ {
+ private IDbConnection _con;
+ private IDbCommand _cmd;
+
+ private IDbTransaction _transaction;
+ private DbDataAdapter _adapter;
+ private IDataReader _dr;
+ private DbProviderFactory _factory;
+ private ConnectionStringSettings _conStngInstitute;
+
+ private bool _isDisposed;
+
+ private string sStartupFolder;
+
+
+ public cDatabase(DB_Type db_type)
+ {
+ switch (db_type)
+ {
+ case DB_Type.MySQL:
+ _conStngInstitute = ConfigurationManager.ConnectionStrings["conMySQL"];
+ break;
+ case DB_Type.MSSQL:
+ _conStngInstitute = ConfigurationManager.ConnectionStrings["conMSSQL"];
+ break;
+ case DB_Type.PostgreSQL:
+ _conStngInstitute = ConfigurationManager.ConnectionStrings["conPostgreSQL"];
+ break;
+ case DB_Type.SQLite:
+ //_conStngInstitute = ConfigurationManager.ConnectionStrings["conInstitute"];
+ break;
+ case DB_Type.MS_Access:
+ _conStngInstitute = ConfigurationManager.ConnectionStrings["conOLEDB"];
+ break;
+ }
+
+ _factory = DbProviderFactories.GetFactory(_conStngInstitute.ProviderName);
+
+ _con = _factory.CreateConnection();
+ _con.ConnectionString = _conStngInstitute.ConnectionString;
+ _cmd = _con.CreateCommand();
+
+ _adapter = _factory.CreateDataAdapter();
+
+ _isDisposed = false;
+
+ sStartupFolder = AppDomain.CurrentDomain.BaseDirectory;
+ }
+
+ public bool IsDisposed
+ {
+ get
+ {
+ lock (this)
+ {
+ return _isDisposed;
+ }
+ }
+ }
+
+ public void Dispose()
+ {
+ if (!IsDisposed)
+ {
+ lock (this)
+ {
+ CleanUp();
+ _isDisposed = true;
+ GC.SuppressFinalize(this);
+ }
+ }
+ }
+
+ protected virtual void CleanUp()
+ {
+ if (_con != null)
+ {
+ _con.Close();
+ _con.Dispose();
+ }
+
+ if (_cmd != null)
+ {
+ _cmd.Dispose();
+ }
+
+ if (_dr != null)
+ {
+ _dr.Close();
+ _dr.Dispose();
+ }
+ }
+
+ public void OpenConnection()
+ {
+ try
+ {
+ if (_con.State != ConnectionState.Open) _con.Open();
+ }
+ catch (Exception ex) { Console.WriteLine("Connection not established!.."); }
+ }
+
+ public void CloseConnection()
+ {
+ if (_con.State != ConnectionState.Closed) _con.Close();
+ }
+
+ /* Parsing of the multi-command SQL texts, ommiting commentaries and extracting of the puare SQL commands;
+ * Note:
+ * - after semicolon ';' shouldn't be written anything (blank spaces allowed).
+ * - befor '/*' shouldn't be written anything (blank spaces allowed).
+ * */
+ public int ExecuteMulticoomandSql(string sQuery)
+ {
+ try
+ {
+ sQuery = sQuery.Replace(";", ";^");
+ string[] arCommands = sQuery.Split('^');
+ int iRet = 0;
+ _transaction = _con.BeginTransaction(IsolationLevel.Unspecified);
+ _cmd.Connection = _con;
+ _cmd.CommandType = CommandType.Text;
+ _cmd.Transaction = _transaction;
+ bool blComment = false;
+ foreach (string s0 in arCommands)
+ {
+ string[] arLines = s0.Split(new[] {"\r\n", "\r", "\n"}, StringSplitOptions.None);
+ string sCurCommand = "";
+ foreach (string s1 in arLines)
+ {
+ string s2 = s1.Trim();
+ if (s2.Length < 1) continue;
+ if (s2.IndexOf("--") == 0) continue;
+ if (s2.IndexOf(@"/*") == 0)
+ {
+ if (s2.IndexOf(@"*/") == s1.Length - 2) blComment = false; else blComment = true;
+ continue;
+ }
+ if (s2.Length>=2 && s2.IndexOf(@"*/") == s1.Length - 2)
+ {
+ blComment = false; continue;
+ }
+
+ if (!blComment)
+ {
+ if (s2.IndexOf(";") != s2.Length - 1)
+ {
+ sCurCommand += s2 + System.Environment.NewLine;
+ }
+ else
+ {
+ sCurCommand += s2;
+ _cmd.CommandText = sCurCommand;
+ iRet = _cmd.ExecuteNonQuery();
+ sCurCommand = "";
+ }
+
+ }
+
+ }
+ }
+ _transaction.Commit();
+ return 1;
+ }
+ catch (Exception ex) { Console.WriteLine(":( Transaction failed... " + ex.Message); _transaction.Rollback(); return 0; }
+
+ }
+
+ // Table for correspondance between Route4Me CSV exported file fields and Route4Me API fields
+ public DataTable GetCsv2ApiDictionary(string sTableName)
+ {
+ DataTable tblDictionary = new DataTable();
+
+ try
+ {
+ tblDictionary = fillTable("SELECT * FROM csv_to_api_dictionary WHERE table_name='" + sTableName+"'");
+ return tblDictionary;
+ }
+ catch (Exception ex) { Console.WriteLine(":( csv_to_api_dictionary table reading failed!.. "+ex.Message); }
+
+ return tblDictionary;
+ }
+
+ /* Method for importing an addressbook CSV file (with structure equal to exported by Route4Me web UI CSV file) to an addressbook table on the SQL type server.
+ * sFileName --- CSV file name.
+ * sTableName --- Server addressbook table name.
+ * sIdName --- The name of id column of the server addressbook table (it's differs from address_id, you need it for editing prior updloading to the Route4Me server)
+ * isFirstRowHeader --- If true, first column of the CSV file is header.
+ * */
+ public void Csv2Table(string sFileName, string sTableName, string sIdName, int iFieldsNumber, bool isFirstRowHeader)
+ {
+ if (!File.Exists(sFileName))
+ {
+ Console.WriteLine("The file " + sFileName + " doesn't exist..."); return;
+ }
+
+ string header = isFirstRowHeader ? "Yes" : "No";
+
+ string pathOnly = System.IO.Path.GetDirectoryName(sFileName);
+ string fileName = System.IO.Path.GetFileName(sFileName);
+
+ string csvCom = @"SELECT * FROM [" + fileName + "]";
+
+ DataTable tblDictionary = GetCsv2ApiDictionary(sTableName);
+
+ DataTable tblTempTable = new DataTable();
+
+ using (OleDbConnection csvCon = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + pathOnly + ";Extended Properties=\"Text;HDR=" + header + "\""))
+ using (OleDbCommand comCsv = new OleDbCommand(csvCom, csvCon))
+ using (OleDbDataAdapter csvAdapter = new OleDbDataAdapter(comCsv))
+ {
+ tblTempTable.Locale = System.Globalization.CultureInfo.CurrentCulture;
+ csvAdapter.Fill(tblTempTable);
+ }
+
+ foreach (DataRow row in tblTempTable.Rows)
+ {
+ int id = -1;
+
+ bool blNew = true;
+
+ if (row.Table.Columns.Contains(sIdName))
+ {
+ if (int.TryParse(row[sIdName].ToString(), out id)) id = Convert.ToInt32(row[sIdName]);
+
+ if (id > 0) blNew = IsNewAddress(sTableName, sIdName, id);
+ }
+ string sList = "(";
+ string sValues = "Values (";
+
+ if (!blNew)
+ {
+ sList = "SET ";
+
+ for (int iCol = 0; iCol < iFieldsNumber; iCol++)
+ {
+ bool isValid = IsValidValue(tblTempTable.Columns[iCol], row[iCol]);
+ if (isValid)
+ {
+ string sCsvFieldName = tblTempTable.Columns[iCol].ColumnName;
+
+ if (sCsvFieldName == sIdName) continue;
+
+ DataRow[] arRows = tblDictionary.Select("r4m_csv_field_name='" + sCsvFieldName + "'");
+ if (arRows.Length == 1)
+ {
+ string sFieldApiName= arRows[0]["api_field_name"].ToString();
+ string sApiFieldType = arRows[0]["api_field_type"].ToString();
+ string sCsvFieldType = arRows[0]["csv_field_type"].ToString();
+
+ if (sFieldApiName == "day_scheduled_for_YYMMDD")
+ {
+
+ var oSchedule = ExceptFields2QueryValue(sFieldApiName, row[iCol]);
+ if (oSchedule == null)
+ {
+ sList += sFieldApiName + "=null,";
+ }
+ else sList += sFieldApiName + "='" + oSchedule + "',";
+ }
+ else
+ {
+ switch (tblTempTable.Columns[iCol].DataType.Name)
+ {
+ case "String":
+ sList += sFieldApiName + "=N'" + row[iCol].ToString() + "',";
+ break;
+ case "Int32":
+ sList += sFieldApiName + "=" + row[iCol].ToString() + ","; ;
+ break;
+ case "Double":
+ sList += sFieldApiName + "=" + row[iCol].ToString() + ",";
+ break;
+ case "DateTime":
+ DateTime dt1900 = new DateTime(1900, 1, 1, 0, 0, 0);
+ if (DateTime.TryParse(row[iCol].ToString(), out dt1900))
+ {
+ dt1900 = Convert.ToDateTime(row[iCol]);
+ if (sApiFieldType != sCsvFieldType && sApiFieldType == "int")
+ {
+ long iUnixTime = R4MeUtils.ConvertToUnixTimestamp(dt1900);
+ sList += sFieldApiName + "=" + iUnixTime + ",";
+ }
+ else
+ {
+ if (_conStngInstitute.ProviderName == "System.Data.OleDb")
+ {
+ sList += sFieldApiName + "=#" + dt1900.ToString("yyyy-MM-dd HH:mm:ss") + "#,";
+ }
+ else sList += sFieldApiName + "='" + dt1900.ToString("yyyy-MM-dd HH:mm:ss") + "',";
+ }
+ }
+ break;
+ }
+ }
+
+ }
+ else continue;
+ }
+ }
+ sList = sList.TrimEnd(',');
+
+ if (tblTempTable.Columns.Count > 33)
+ {
+ System.Text.StringBuilder sbCustom = new System.Text.StringBuilder();
+ sbCustom.Append("{");
+ for (int iCol = 33; iCol < tblTempTable.Columns.Count; iCol++)
+ {
+ System.Text.StringBuilder sbCustom1 = new System.Text.StringBuilder();
+ sbCustom1.Append("{");
+ for (int iCol1 = 33; iCol1 < tblTempTable.Columns.Count; iCol1++)
+ {
+ bool isValid = IsValidValue(tblTempTable.Columns[iCol1], row[iCol1]);
+ if (isValid)
+ {
+ if (tblTempTable.Columns[iCol1].DataType.Name == "String")
+ {
+ string sFieldName = tblTempTable.Columns[iCol1].ColumnName;
+ string sValue = row[iCol1].ToString();
+ sbCustom1.Append("\"" + sFieldName + "\": \"" + sValue + "\",");
+ }
+ }
+ }
+ string sCustom = sbCustom.ToString();
+ sCustom = sCustom.TrimEnd(',');
+ sCustom += "}";
+ if (sCustom.Length > 3)
+ {
+ sList += "address_custom_data='" + " N'" + sCustom + "'";
+ }
+ }
+ }
+
+ string sQuery2 = "UPDATE " + sTableName + " " + sList + " WHERE " + sIdName + "=" + id;
+
+ int iResult2 = ExecuteNon(sQuery2);
+
+ if (iResult2 > 0)
+ {
+ Console.WriteLine(":) The row with "+sIdName+"d=" + id + " was updated in the table "+sTableName);
+ }
+ else
+ {
+ Console.WriteLine(":( Can not updated the row in the table "+sTableName);
+ }
+ }
+ else
+ {
+ for (int iCol = 0; iCol < iFieldsNumber; iCol++)
+ {
+ bool isValid = IsValidValue(tblTempTable.Columns[iCol], row[iCol]);
+
+ if (isValid)
+ {
+ string sCvsFieldName = tblTempTable.Columns[iCol].ColumnName;
+ DataRow[] arRows = tblDictionary.Select("r4m_csv_field_name='" + sCvsFieldName + "'");
+ if (arRows.Length == 1)
+ {
+ string sFieldApiName = arRows[0]["api_field_name"].ToString();
+ string sApiFieldType = arRows[0]["api_field_type"].ToString();
+ string sCsvFieldType = arRows[0]["csv_field_type"].ToString();
+
+ //sFields += prop.Name + ",";
+ if (sFieldApiName == "day_scheduled_for_YYMMDD")
+ {
+ sList += sFieldApiName + ",";
+ var oSchedule = ExceptFields2QueryValue(sFieldApiName, row[iCol]);
+ if (oSchedule == null)
+ {
+ sValues += "null";
+ }
+ else sValues += "'" + oSchedule + "',";
+ }
+ else
+ {
+ switch (tblTempTable.Columns[iCol].DataType.Name)
+ {
+ case "String":
+ sList += sFieldApiName + ",";
+ sValues += "N'" + row[iCol].ToString() + "',";
+ break;
+ case "Int32":
+ sList += sFieldApiName + ",";
+ sValues += row[iCol].ToString() + ",";
+ break;
+ case "Double":
+ sList += sFieldApiName + ",";
+ sValues += row[iCol].ToString() + ",";
+ break;
+ case "DateTime":
+ DateTime dt1900 = new DateTime(1900, 1, 1, 0, 0, 0);
+ if (DateTime.TryParse(row[iCol].ToString(), out dt1900))
+ {
+ dt1900 = Convert.ToDateTime(row[iCol]);
+ sList += sFieldApiName + ",";
+ if (sApiFieldType != sCsvFieldType && sApiFieldType == "int")
+ {
+ long iUnixTime = R4MeUtils.ConvertToUnixTimestamp(dt1900);
+ sValues += iUnixTime + ",";
+ }
+ else
+ {
+ if (_conStngInstitute.ProviderName == "System.Data.OleDb")
+ {
+ sValues += "#" + dt1900.ToString("yyyy-MM-dd HH:mm:ss") + "#,";
+ }
+ else sValues += "'" + dt1900.ToString("yyyy-MM-dd HH:mm:ss") + "',";
+ }
+ }
+ break;
+ }
+ }
+
+ }
+ }
+ }
+
+ #region custom fields in case of the addressbook contact, added in csv export as additional columns.
+ if (tblTempTable.Columns.Count > 33)
+ {
+ System.Text.StringBuilder sbCustom = new System.Text.StringBuilder();
+ sbCustom.Append("{");
+ for (int iCol = 33; iCol < tblTempTable.Columns.Count; iCol++)
+ {
+ bool isValid = IsValidValue(tblTempTable.Columns[iCol], row[iCol]);
+ if (isValid)
+ {
+ if (tblTempTable.Columns[iCol].DataType.Name == "String")
+ {
+ string sFieldName = tblTempTable.Columns[iCol].ColumnName;
+ string sValue = row[iCol].ToString();
+ sbCustom.Append("\"" + sFieldName + "\": \"" + sValue + "\",");
+ }
+ }
+ }
+ string sCustom = sbCustom.ToString();
+ sCustom = sCustom.TrimEnd(',');
+ sCustom += "}";
+ if (sCustom.Length > 3)
+ {
+ sList += "address_custom_data,";
+ sValues += " N'" + sCustom + "'";
+ }
+
+ }
+ #endregion
+
+ sList = sList.TrimEnd(','); sList += ")";
+ sValues = sValues.TrimEnd(','); sValues += ")";
+ string sQuery1 = "INSERT INTO "+sTableName+" " + sList + " " + sValues;
+
+ int iResult = ExecuteNon(sQuery1);
+
+ if (iResult > 0)
+ {
+ Console.WriteLine(":) New row with "+sIdName+ "=" + id + " was added to the table "+sTableName);
+ }
+ else
+ {
+ Console.WriteLine(":( Can not created new row in the table "+sTableName);
+ }
+ }
+ }
+ }
+
+ /* Method for exporting addressbook data from SQL type server to the CSV file (with structure equal to the exported by Route4Me web UI CSV file)
+ * sFileName --- CSV file name.
+ * sTableName --- Server addressbook table name.
+ * WithId --- If true, CSV file will have first ID of SQL addressbook table (you need it for editing in CSV file and updating server table using Csv2Table method.
+ * */
+ public void Table2Csv(string sFileName, string sTableName, bool WithId)
+ {
+ if (!CheckDataFolder(sFileName, true)) return;
+
+ DataTable tblTemp = fillTable("SELECT * FROM "+sTableName);
+
+ List lsCsvContent = new List();
+
+ string sFileHeader = "";
+ if (WithId) sFileHeader += "\"" + tblTemp.Columns[0].ColumnName + "\",";
+
+ DataTable tblDictionary = GetCsv2ApiDictionary(sTableName);
+
+ foreach (DataRow dictRow in tblDictionary.Rows)
+ {
+ sFileHeader += "\"" + dictRow["r4m_csv_field_name"].ToString() + "\",";
+ }
+
+ #region Convert JSON string of the custom data to the csv fields (as they are represented in the exported from Route4Me csv file
+ foreach (DataRow row in tblTemp.Rows)
+ {
+ if (IsValidValue(tblTemp.Columns["address_custom_Data"], row["address_custom_Data"]))
+ {
+ var jsSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
+ Dictionary dict = (Dictionary)jsSerializer.DeserializeObject(row["address_custom_Data"].ToString());
+
+ foreach (KeyValuePair kvpair in dict)
+ {
+ DataRow[] fRows = tblDictionary.Select("r4m_csv_field_name='" + kvpair.Key + "'");
+
+ if (fRows.Length < 1)
+ {
+ DataRow newRow = tblDictionary.NewRow();
+
+ newRow["r4m_csv_field_name"] = kvpair.Key;
+ newRow["table_name"] = "addressbook_v4";
+ newRow["csv_field_nom"] = tblDictionary.Rows.Count;
+ newRow["api_field_name"] = "_cf__" + kvpair.Key;
+
+ tblDictionary.Rows.Add(newRow);
+
+ sFileHeader += "\"" + kvpair.Key + "\",";
+ }
+
+ }
+ }
+ }
+ #endregion
+
+ sFileHeader = sFileHeader.TrimEnd(',');
+
+ lsCsvContent.Add(sFileHeader);
+
+ foreach (DataRow row in tblTemp.Rows)
+ {
+ string sRow = "";
+
+ if (WithId)
+ {
+ if (IsValidValue(tblTemp.Columns[0], row[0]))
+ {
+ sRow += row[0].ToString() + ",";
+ }
+ }
+
+ foreach (DataRow dictRow in tblDictionary.Rows)
+ {
+ string sCsvFieldName = dictRow["r4m_csv_field_name"].ToString();
+
+ string sApiFieldName = dictRow["api_field_name"].ToString();
+
+ if (sApiFieldName.IndexOf("_cf__") == 0)
+ {
+ string sKeyName = sApiFieldName.Substring(5);
+
+ if (IsValidValue(tblTemp.Columns["address_custom_Data"], row["address_custom_Data"]))
+ {
+ var jsSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
+ Dictionary dict = (Dictionary)jsSerializer.DeserializeObject(row["address_custom_Data"].ToString());
+
+ bool blExists = false;
+ foreach (KeyValuePair kvpair in dict)
+ {
+ if (kvpair.Key == sKeyName)
+ {
+ string sVal = kvpair.Value.ToString();
+ sVal = sVal.Replace("\"", "\"\"");
+ sRow += "\"" + sVal + "\",";
+ blExists = true;
+ break;
+ }
+ }
+
+ if (!blExists) sRow += ",";
+ }
+ else sRow += ",";
+ }
+ else
+ {
+ DataColumn apiCol = tblTemp.Columns[sApiFieldName];
+
+ if (IsValidValue(apiCol, row[apiCol.ColumnName]))
+ {
+ switch (apiCol.DataType.ToString())
+ {
+ case "System.String":
+ string sVal = row[apiCol.ColumnName].ToString();
+ sVal = sVal.Replace("\"", "\"\"");
+ sRow += "\"" + sVal + "\",";
+ break;
+ case "System.DdateTime":
+ sRow += "\"" + Convert.ToDateTime(row[apiCol.ColumnName]).ToString("yyyy-MM-dd HH:mm:ss") + "\",";
+ break;
+ default:
+ sRow += row[apiCol.ColumnName] + ",";
+ break;
+ }
+
+ }
+ else sRow += ",";
+ }
+
+ }
+
+ sRow = sRow.TrimEnd(',');
+ lsCsvContent.Add(sRow);
+ }
+
+ File.WriteAllLines(sFileName, lsCsvContent.ToArray());
+
+ Console.WriteLine("The file "+sFileName+" was created. You can fill it with data for upoloading on the server.");
+ }
+
+ /* Create data folder if it doesn't exist.
+ * */
+ private bool CheckDataFolder(string file_name, bool blCreateIfNotExists)
+ {
+ try
+ {
+ DirectoryInfo iDir = Directory.GetParent(file_name);
+ if (File.Exists(iDir.FullName))
+ {
+ return true;
+
+ }
+ else
+ {
+ if (blCreateIfNotExists) Directory.CreateDirectory(iDir.FullName);
+ return true;
+ }
+
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine("Creation of the data folder failed... "+ex.Message);
+ return false;
+ }
+ }
+
+ /* Method FieldValue2QueryValue converts value of the type ttype to value for sqlquery operations (update, insert)
+ **/
+ private string FieldValue2QueryValue(Type ttype, object oValue)
+ {
+ string sQueryValue = "";
+
+ switch (ttype.Name)
+ {
+ case "String":
+ sQueryValue = "N'" + oValue.ToString() + "'";
+ break;
+ case "Int32":
+ sQueryValue = oValue.ToString();
+ break;
+ case "Double":
+ sQueryValue = oValue.ToString();
+ break;
+ case "DateTime":
+ DateTime dt1900 = new DateTime(1900, 1, 1, 0, 0, 0);
+ if (DateTime.TryParse(oValue.ToString(), out dt1900))
+ {
+ dt1900 = Convert.ToDateTime(oValue);
+ if (_conStngInstitute.ProviderName == "System.Data.OleDb")
+ {
+ sQueryValue = "#" + dt1900.ToString("yyyy-MM-dd HH:mm:ss") + "#";
+ }
+ else sQueryValue = "'" + dt1900.ToString("yyyy-MM-dd HH:mm:ss") + "'";
+ }
+ break;
+ }
+
+ return sQueryValue;
+ }
+
+ private string ExceptFields2QueryValue(string PropertyName, object oValue)
+ {
+ string sQueryValue = "";
+ if (oValue == null) return "null";
+
+ switch (PropertyName)
+ {
+ case "day_scheduled_for_YYMMDD":
+ DateTime dt1900 = new DateTime(1900, 1, 1, 0, 0, 0);
+ if (DateTime.TryParse(oValue.ToString(), out dt1900))
+ {
+ dt1900 = Convert.ToDateTime(oValue);
+ return dt1900.ToShortDateString();
+ } else return null;
+ break;
+ case "EXT_FIELD_custom_data":
+ System.Text.StringBuilder sbOrderCustom = new System.Text.StringBuilder();
+ sbOrderCustom.Append("{");
+ foreach (KeyValuePair kvpair in (Dictionary)oValue)
+ {
+ if (kvpair.Value == null)
+ {
+ sbOrderCustom.Append("\"" + kvpair.Key + "\": null,");
+ }
+ else sbOrderCustom.Append("\"" + kvpair.Key + "\": \"" + kvpair.Value.ToString() + "\",");
+ }
+ sQueryValue = sbOrderCustom.ToString().TrimEnd(',');
+ sQueryValue += "}";
+ break;
+ case "address_custom_data":
+ System.Text.StringBuilder sbCustom = new System.Text.StringBuilder();
+ sbCustom.Append("{");
+ foreach (KeyValuePair kvpair in (Dictionary)oValue)
+ {
+ if (kvpair.Value == null)
+ {
+ sbCustom.Append("\"" + kvpair.Key + "\": null,");
+ }
+ else sbCustom.Append("\"" + kvpair.Key + "\": \"" + kvpair.Value.ToString() + "\",");
+ }
+ sQueryValue = sbCustom.ToString().TrimEnd(',');
+ sQueryValue += "}";
+ break;
+ case "schedule":
+ System.Text.StringBuilder sb = new System.Text.StringBuilder();
+ DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(IList));
+
+ using (MemoryStream ms = new MemoryStream())
+ {
+ serializer.WriteObject(ms, oValue);
+ sQueryValue = System.Text.Encoding.Default.GetString(ms.ToArray());
+ }
+ break;
+ case "schedule_blacklist":
+ System.Text.StringBuilder sbBlackList = new System.Text.StringBuilder();
+ foreach (string dt1 in (string[])oValue)
+ {
+ sbBlackList.Append("\""+dt1+"\",");
+ }
+ sQueryValue = sbBlackList.ToString();
+ sQueryValue = sQueryValue.TrimEnd(',');
+ break;
+
+ }
+
+ return sQueryValue;
+ }
+
+ /* Upload JSON response file, generated by the process of getting addressbook contacts by Route4Me API, to the SQL type server.
+ * */
+ public void Json2Table(string sFileName, string sTableName, string sIdName, R4M_DataType r4m_dtype)
+ {
+ if (!File.Exists(sFileName))
+ {
+ Console.WriteLine("The file " + sFileName + " doesn't exist..."); return;
+ }
+
+ string pathOnly = System.IO.Path.GetDirectoryName(sFileName);
+ string fileName = System.IO.Path.GetFileName(sFileName);
+
+ string jsonContent = File.ReadAllText(sFileName);
+
+ DataTable tblTempTable = new DataTable();
+
+ var jsSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
+
+ switch (r4m_dtype)
+ {
+ case R4M_DataType.Addressbook:
+ //var jsSerializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(AddressBookContactsResponse));
+ AddressBookContactsResponse Data = jsSerializer.Deserialize(jsonContent);
+ if (Data.total == 0) break;
+
+ foreach (AddressBookContact contact in Data.results)
+ {
+ string sQuery = "";
+ if (IsNewAddressID("addressbook_v4", contact.address_id ))
+ {
+ sQuery = "INSERT INTO addressbook_v4 ";
+ string sFields = "";
+ string sValues = "";
+ foreach (System.Reflection.PropertyInfo prop in typeof(AddressBookContact).GetProperties())
+ {
+ if (prop.Name=="address_id") continue;
+ if (prop.Name == "ConvertBooleansToInteger") continue;
+ if (prop.MemberType != System.Reflection.MemberTypes.Property) continue;
+ var vValue = contact.GetType().GetProperty(prop.Name).GetValue(contact, null);
+ if (vValue == null) continue;
+
+ Console.WriteLine("Properyt type=" + prop.PropertyType.Name);
+
+ sFields += prop.Name + ",";
+ if (prop.Name == "address_custom_data" || prop.Name == "schedule" || prop.Name == "schedule_blacklist")
+ {
+ sValues += "'" + ExceptFields2QueryValue(prop.Name, vValue) + "',";
+ }
+ else
+ {
+ sValues += FieldValue2QueryValue(vValue.GetType(), vValue) + ",";
+ }
+
+ }
+ sFields = sFields.TrimEnd(',');
+ sValues=sValues.TrimEnd(',');
+
+ sFields = "("+sFields+")";
+ sValues = "(" + sValues + ")";
+
+ sQuery += sFields + " VALUES " +sValues;
+ }
+ else
+ {
+ int address_id = (int)contact.address_id;
+ sQuery = "UPDATE addressbook_v4 SET ";
+ string sSet = "";
+ foreach (System.Reflection.PropertyInfo prop in typeof(AddressBookContact).GetProperties())
+ {
+ if (prop.Name == "address_id") continue;
+ if (prop.Name == "ConvertBooleansToInteger") continue;
+ if (prop.MemberType != System.Reflection.MemberTypes.Property) continue;
+ var vValue = contact.GetType().GetProperty(prop.Name).GetValue(contact,null);
+ if (vValue == null) continue;
+
+ Console.WriteLine("Properyt type=" + prop.PropertyType.Name);
+ if (prop.Name == "address_custom_data" || prop.Name == "schedule" || prop.Name == "schedule_blacklist")
+ {
+ sSet += prop.Name + "='" + ExceptFields2QueryValue(prop.Name, vValue) + "',";
+ }
+ else sSet += prop.Name + "=" + FieldValue2QueryValue(vValue.GetType(), vValue) + ",";
+ }
+ sSet = sSet.TrimEnd(',');
+ sQuery += sSet + " WHERE address_id=" + address_id;
+ }
+ int iSuccess = ExecuteNon(sQuery);
+
+ }
+ break;
+ case R4M_DataType.Order:
+ OrdersResponse ordersData = jsSerializer.Deserialize(jsonContent);
+ if (ordersData.total == 0) break;
+
+ foreach (Order order in ordersData.results)
+ {
+ string sQuery = "";
+ if (IsNewOrderID("orders", order.order_id))
+ {
+ sQuery = "INSERT INTO orders ";
+ string sFields = "";
+ string sValues = "";
+
+ foreach (System.Reflection.PropertyInfo prop in typeof(Order).GetProperties())
+ {
+ //if (prop.Name == "order_id") continue;
+ if (prop.Name == "ConvertBooleansToInteger") continue;
+ if (prop.MemberType != System.Reflection.MemberTypes.Property) continue;
+ var vValue = order.GetType().GetProperty(prop.Name).GetValue(order, null);
+ if (vValue == null) continue;
+
+ Console.WriteLine("Properyt type=" + prop.PropertyType.Name);
+
+ sFields += prop.Name + ",";
+ if (prop.Name == "EXT_FIELD_custom_data")
+ {
+ sValues += "'" + ExceptFields2QueryValue(prop.Name, vValue) + "',";
+ }
+ else
+ {
+ sValues += FieldValue2QueryValue(vValue.GetType(), vValue) + ",";
+ }
+
+ }
+ sFields = sFields.TrimEnd(',');
+ sValues = sValues.TrimEnd(',');
+
+ sFields = "(" + sFields + ")";
+ sValues = "(" + sValues + ")";
+
+ sQuery += sFields + " VALUES " + sValues;
+
+ }
+ else
+ {
+ int order_id = (int)order.order_id;
+ sQuery = "UPDATE orders SET ";
+ string sSet = "";
+
+ foreach (System.Reflection.PropertyInfo prop in typeof(Order).GetProperties())
+ {
+ if (prop.Name == "order_id") continue;
+ if (prop.Name == "ConvertBooleansToInteger") continue;
+ if (prop.MemberType != System.Reflection.MemberTypes.Property) continue;
+ var vValue = order.GetType().GetProperty(prop.Name).GetValue(order, null);
+ if (vValue == null) continue;
+
+ Console.WriteLine("Properyt type=" + prop.PropertyType.Name);
+ if (prop.Name == "EXT_FIELD_custom_data")
+ {
+ sSet += prop.Name + "='" + ExceptFields2QueryValue(prop.Name, vValue) + "',";
+ }
+ else sSet += prop.Name + "=" + FieldValue2QueryValue(vValue.GetType(), vValue) + ",";
+ }
+ sSet = sSet.TrimEnd(',');
+ sQuery += sSet + " WHERE order_id=" + order_id;
+ }
+ int iOrderSuccess = ExecuteNon(sQuery);
+ }
+
+ break;
+ case R4M_DataType.Route:
+
+ break;
+ }
+ }
+
+ public bool IsNewAddress(string sTableName, string sIdName, int AddressId)
+ {
+ bool blNew = true;
+ string sCom = @"SELECT COUNT(*) as rba FROM "+sTableName+ " WHERE "+sIdName+"="+AddressId;
+ object result = ExecuteScalar(sCom);
+ int iRows = -1;
+ if (int.TryParse(result.ToString(), out iRows)) iRows = Convert.ToInt32(result);
+ if (iRows > 0) blNew = false;
+ return blNew;
+ }
+
+ public bool IsNewAddressID(string sTableName, object oAddressId)
+ {
+ bool blNew = true;
+ int AddressId = -1;
+ if (int.TryParse(oAddressId.ToString(), out AddressId)) AddressId = Convert.ToInt32(oAddressId); else return true;
+
+ string sCom = @"SELECT COUNT(*) as rba FROM " + sTableName + " WHERE address_id=" + AddressId;
+ object result = ExecuteScalar(sCom);
+ int iRows = -1;
+ if (int.TryParse(result.ToString(), out iRows)) iRows = Convert.ToInt32(result);
+ if (iRows > 0) blNew = false;
+ return blNew;
+ }
+
+ public bool IsNewOrderID(string sTableName, object oOrderId)
+ {
+ bool blNew = true;
+ int OrderId = -1;
+ if (int.TryParse(oOrderId.ToString(), out OrderId)) OrderId = Convert.ToInt32(oOrderId); else return true;
+
+ string sCom = @"SELECT COUNT(*) as rba FROM " + sTableName + " WHERE order_id=" + OrderId;
+ object result = ExecuteScalar(sCom);
+ int iRows = -1;
+ if (int.TryParse(result.ToString(), out iRows)) iRows = Convert.ToInt32(result);
+ if (iRows > 0) blNew = false;
+ return blNew;
+ }
+
+ public object ExecuteScalar(string sQuery)
+ {
+ object result = null;
+ try
+ {
+ int iResult = -1;
+ OpenConnection();
+ _cmd.CommandText = sQuery;
+ result = _cmd.ExecuteScalar();
+
+ if (int.TryParse(result.ToString(), out iResult)) iResult = Convert.ToInt32(result);
+ return iResult;
+ }
+ catch (Exception ex) { Console.WriteLine(ex.Message); return 0; }
+ finally
+ {
+ CloseConnection();
+ }
+
+ }
+
+ public int ExecuteNon(string sQuery)
+ {
+ try
+ {
+ int iResult = -1;
+ _cmd.CommandText = sQuery;
+ OpenConnection();
+ iResult = _cmd.ExecuteNonQuery();
+
+ return iResult;
+ }
+ catch (Exception ex) { Console.WriteLine(ex.Message); return 0; }
+ finally
+ {
+ CloseConnection();
+ }
+
+ }
+
+ public bool IsValidValue(DataColumn col, object value)
+ {
+ bool isValid = false;
+
+ string sType = col.DataType.Name;
+
+ switch (sType)
+ {
+ case "Int32":
+ int i_val = -1;
+ if (int.TryParse(value.ToString(), out i_val)) isValid = true;
+ break;
+ case "String":
+ if (value.ToString().Length>0) isValid = true;
+ break;
+ case "Double":
+ double d_val = 0;
+ if (double.TryParse(value.ToString(), out d_val)) isValid = true;
+ break;
+ case "DateTime":
+ DateTime dt1908 = new DateTime(1899,1,1,0,0,0);
+ if (DateTime.TryParse(value.ToString(), out dt1908)) isValid = true;
+ break;
+ }
+
+ return isValid;
+ }
+
+ public DataTable fillTable(string sSQLSelect)
+ {
+ DataTable dtbElements = new DataTable();
+
+ try
+ {
+ OpenConnection();
+
+ _cmd.CommandText = sSQLSelect;
+ _adapter.SelectCommand = (DbCommand)_cmd;
+
+ _adapter.Fill(dtbElements);
+
+ return dtbElements;
+ }
+ catch (Exception ex) { Console.WriteLine(""); return dtbElements; }
+ finally
+ {
+ CloseConnection();
+ }
+
+ }
+ }
+}
diff --git a/Route4MeSDKLibrary/Properties/AssemblyInfo.cs b/Route4MeSDKLibrary/Properties/AssemblyInfo.cs
new file mode 100755
index 00000000..c6e90fde
--- /dev/null
+++ b/Route4MeSDKLibrary/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Route4MeSDKLibrary")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Route4MeSDKLibrary")]
+[assembly: AssemblyCopyright("Copyright © 2014")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("e3fa443f-066c-4a22-8c95-f8552c918a9e")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/Route4MeSDKLibrary/PropertyValidation.cs b/Route4MeSDKLibrary/PropertyValidation.cs
new file mode 100644
index 00000000..8b98e1c4
--- /dev/null
+++ b/Route4MeSDKLibrary/PropertyValidation.cs
@@ -0,0 +1,72 @@
+using System;
+using System.ComponentModel;
+using System.Reflection;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.ComponentModel.DataAnnotations;
+
+namespace Route4MeSDK
+{
+ ///
+ /// Validation of the class properties
+ ///
+ public static class PropertyValidation
+ {
+ public static ValidationResult ValidateMonthlyNthN(int N)
+ {
+ bool isValid=false;
+
+ int[] nList = {1,2,3,4,5,-1};
+ // Perform validation logic here and set isValid to true or false.
+
+ if (Array.IndexOf(nList,N)>=0)
+ {
+ isValid = true;
+ return ValidationResult.Success;
+ }
+ else
+ {
+ return new ValidationResult(
+ "The selected option is not available for this type of the schedule.");
+ }
+ }
+
+ public static ValidationResult ValidateScheduleMode(string sMode)
+ {
+ bool isValid = false;
+
+ string[] sList = { "daily", "weekly", "monthly", "annually" };
+ // Perform validation logic here and set isValid to true or false.
+
+ if (Array.IndexOf(sList, sMode) >= 0)
+ {
+ isValid = true;
+ return ValidationResult.Success;
+ }
+ else
+ {
+ return new ValidationResult(
+ "The selected option is not available for this type of the schedule.");
+ }
+ }
+
+ public static ValidationResult ValidateScheduleMonthlyMode(string sMode)
+ {
+ bool isValid = false;
+
+ string[] sList = { "dates", "nth" };
+ // Perform validation logic here and set isValid to true or false.
+
+ if (Array.IndexOf(sList, sMode) >= 0)
+ {
+ isValid = true;
+ return ValidationResult.Success;
+ }
+ else
+ {
+ return new ValidationResult(
+ "The selected option is not available for this type of the schedule.");
+ }
+ }
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/ActivityParameters.cs b/Route4MeSDKLibrary/QueryTypes/ActivityParameters.cs
new file mode 100644
index 00000000..c6f97968
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/ActivityParameters.cs
@@ -0,0 +1,36 @@
+
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class ActivityParameters : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "device_id", EmitDefaultValue = false)]
+ public string DeviceID { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "member_id", EmitDefaultValue = false)]
+ public int? MemberId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "limit", EmitDefaultValue = false)]
+ public uint? Limit { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "offset", EmitDefaultValue = false)]
+ public uint? Offset { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "team", EmitDefaultValue = false)]
+ public string Team { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "start", EmitDefaultValue = false)]
+ public uint? Start { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "end", EmitDefaultValue = false)]
+ public uint? End { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "activity_type", EmitDefaultValue = false)]
+ public string ActivityType { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "activity_message", EmitDefaultValue = false)]
+ public string ActivityMessage { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/AddressBookParameters.cs b/Route4MeSDKLibrary/QueryTypes/AddressBookParameters.cs
new file mode 100644
index 00000000..0a013756
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/AddressBookParameters.cs
@@ -0,0 +1,26 @@
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class AddressBookParameters : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "address_id", EmitDefaultValue = false)]
+ public string AddressId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "limit", EmitDefaultValue = false)]
+ public uint? Limit { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "offset", EmitDefaultValue = false)]
+ public uint? Offset { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "start", EmitDefaultValue = false)]
+ public uint? Start { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "query", EmitDefaultValue = false)]
+ public string Query { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "fields", EmitDefaultValue = false)]
+ public string Fields { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "display", EmitDefaultValue = false)]
+ public string Display { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/AddressParameters.cs b/Route4MeSDKLibrary/QueryTypes/AddressParameters.cs
new file mode 100644
index 00000000..ecda010f
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/AddressParameters.cs
@@ -0,0 +1,25 @@
+
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class AddressParameters : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "route_destination_id", EmitDefaultValue = false)]
+ public int RouteDestinationId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "address_id", EmitDefaultValue = false)]
+ public int AddressId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "notes")]
+ public bool Notes { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "is_departed")]
+ public bool IsDeparted { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "is_visited")]
+ public bool IsVisited { get; set; }
+
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/AvoidanceZoneParameters.cs b/Route4MeSDKLibrary/QueryTypes/AvoidanceZoneParameters.cs
new file mode 100644
index 00000000..efbc9c1d
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/AvoidanceZoneParameters.cs
@@ -0,0 +1,49 @@
+using Route4MeSDK.DataTypes;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.QueryTypes
+{
+ ///
+ /// Avoidance zone parameters
+ ///
+ [DataContract]
+ public sealed class AvoidanceZoneParameters : GenericParameters
+ {
+ ///
+ /// Device Id
+ ///
+ [IgnoreDataMember] // Don't serialize as JSON
+ [HttpQueryMemberAttribute(Name = "device_id", EmitDefaultValue = false)]
+ public string DeviceID { get; set; }
+
+ ///
+ /// Territory Id
+ ///
+ [HttpQueryMemberAttribute(Name = "territory_id", EmitDefaultValue = false)]
+ public string TerritoryId { get; set; }
+
+ ///
+ /// Territory name
+ ///
+ [DataMember(Name = "territory_name")]
+ public string TerritoryName { get; set; }
+
+ ///
+ /// Territory color
+ ///
+ [DataMember(Name = "territory_color")]
+ public string TerritoryColor { get; set; }
+
+ ///
+ /// Member Id
+ ///
+ [DataMember(Name = "member_id")]
+ public string MemberId { get; set; }
+
+ ///
+ /// Territory parameters
+ ///
+ [DataMember(Name = "territory")]
+ public Territory Territory { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/AvoidanceZoneQuerry.cs b/Route4MeSDKLibrary/QueryTypes/AvoidanceZoneQuerry.cs
new file mode 100644
index 00000000..4a8637cf
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/AvoidanceZoneQuerry.cs
@@ -0,0 +1,23 @@
+using Route4MeSDK.DataTypes;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.QueryTypes
+{
+ ///
+ /// Avoidance zone query
+ ///
+ public sealed class AvoidanceZoneQuery : GenericParameters
+ {
+ ///
+ /// Device Id
+ ///
+ [HttpQueryMemberAttribute(Name = "device_id", EmitDefaultValue = false)]
+ public string DeviceID { get; set; }
+
+ ///
+ /// Territory Id
+ ///
+ [HttpQueryMemberAttribute(Name = "territory_id", EmitDefaultValue = false)]
+ public string TerritoryId { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/GPSParameters.cs b/Route4MeSDKLibrary/QueryTypes/GPSParameters.cs
new file mode 100755
index 00000000..682b95fe
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/GPSParameters.cs
@@ -0,0 +1,67 @@
+
+namespace Route4MeSDK.QueryTypes
+{
+ ///
+ /// Helper class, for setting GPS data
+ /// Used to create the suitable query string
+ /// See example in Route4MeExamples.SetGPSPosition()
+ ///
+ public sealed class GPSParameters : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "format")]
+ public string Format {get; set; }
+
+ [HttpQueryMemberAttribute(Name = "member_id")]
+ public int MemberId {get; set; }
+
+ [HttpQueryMemberAttribute(Name = "route_id")]
+ public string RouteId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "tx_id")]
+ public string TxId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "vehicle_id")]
+ public int VehicleId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "course")]
+ public int Course { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "speed")]
+ public double Speed { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "lat")]
+ public double Latitude { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "lng")]
+ public double Longitude { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "last_position")]
+ public bool last_position { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "time_period")]
+ public string time_period { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "start_date")]
+ public int start_date { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "end_date")]
+ public int end_date { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "altitude", EmitDefaultValue = false)]
+ public double Altitude { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "device_type")]
+ public string DeviceType { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "device_guid")]
+ public string DeviceGuid { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "device_timestamp", EmitDefaultValue = false)]
+ public string DeviceTimestamp { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "app_version", EmitDefaultValue = false)]
+ public string AppVersion { get; set; }
+
+
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/GenericParameters.cs b/Route4MeSDKLibrary/QueryTypes/GenericParameters.cs
new file mode 100755
index 00000000..ab03ebba
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/GenericParameters.cs
@@ -0,0 +1,101 @@
+using Route4MeSDK.DataTypes;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Web;
+
+namespace Route4MeSDK.QueryTypes
+{
+ ///
+ /// Helper class, for easy REST query parameters string generation
+ /// 1. Use GenericParameters.Serialize() to generate the query string
+ /// 2. Use GenericParameters.ParametersCollection for adding query parameters
+ /// 3. Inherit this class, to create usable parameters holders
+ /// Add an attribute [HttpQueryMemberAttribute] on each property for serializing it automatically
+ /// 4. Modify ConvertBooleansToInteger.GenericParameters to serialize bool and bool? as "0" and "1"
+ /// Important: You have to add here all derived classes, that are serealized as json as a KnownType
+ ///
+ [DataContract]
+ [KnownType(typeof(OptimizationParameters))]
+ [KnownType(typeof(AddressBookContact))]
+ [KnownType(typeof(ActivityParameters))]
+ [KnownType(typeof(AddressBookParameters))]
+ [KnownType(typeof(AddressParameters))]
+ [KnownType(typeof(GPSParameters))]
+ [KnownType(typeof(NoteParameters))]
+ [KnownType(typeof(RouteParameters))]
+ [KnownType(typeof(RouteParametersQuery))]
+ [KnownType(typeof(AvoidanceZoneParameters))]
+ [KnownType(typeof(AvoidanceZoneQuery))]
+ [KnownType(typeof(GeocodingParameters))]
+ [KnownType(typeof(MemberParameters))]
+ public class GenericParameters
+ {
+ #region Fields
+
+ [IgnoreDataMember]
+ public NameValueCollection ParametersCollection = new NameValueCollection();
+
+ [IgnoreDataMember]
+ public bool ConvertBooleansToInteger {get; protected set;}
+
+ #endregion
+
+ #region Methods
+
+ public GenericParameters()
+ {
+ this.PrepareForSerialization();
+ }
+
+ public void PrepareForSerialization()
+ {
+ ConvertBooleansToInteger = true;
+ if (ParametersCollection == null)
+ ParametersCollection = new NameValueCollection();
+ }
+
+ public string Serialize(string apiKey = null)
+ {
+ var paramsCollection = HttpUtility.ParseQueryString(string.Empty);
+
+ paramsCollection.Add(ParametersCollection);
+
+ var properties = GetType().GetProperties();
+
+ foreach (var property in properties)
+ {
+ var attribute = property.GetCustomAttribute(typeof(HttpQueryMemberAttribute)) as HttpQueryMemberAttribute;
+
+ if (attribute != null)
+ {
+ var valueObj = property.GetValue(this);
+ var value = valueObj != null ? valueObj.ToString() : "null";
+
+ if (ConvertBooleansToInteger &&
+ valueObj != null &&
+ (property.PropertyType == typeof(bool) || property.PropertyType == typeof(bool?)))
+ {
+ value = ((bool)valueObj) ? "1" : "0";
+ }
+
+ var name = attribute.Name ?? property.Name;
+ var emit = valueObj != attribute.DefaultValue ||
+ attribute.EmitDefaultValue;
+
+ if (emit)
+ {
+ paramsCollection.Add(name, value);
+ }
+ }
+ }
+
+ string apiKeyStr = string.IsNullOrEmpty(apiKey) ? "?" : string.Format("?api_key={0}", apiKey);
+ string result = paramsCollection.Count > 0 ? string.Format("{0}&{1}", apiKeyStr, paramsCollection.ToString()) : apiKeyStr;
+
+ return result;
+ }
+
+ #endregion
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/GeocodingParameters.cs b/Route4MeSDKLibrary/QueryTypes/GeocodingParameters.cs
new file mode 100644
index 00000000..10ed6633
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/GeocodingParameters.cs
@@ -0,0 +1,61 @@
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class GeocodingParameters : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "addresses", EmitDefaultValue = false)]
+ public string Addresses
+ {
+ get { return m_Addresses; }
+ set { m_Addresses = value; }
+ }
+ private string m_Addresses;
+
+ [HttpQueryMemberAttribute(Name = "format", EmitDefaultValue = false)]
+ public string Format
+ {
+ get { return m_Format; }
+ set { m_Format = value; }
+ }
+ private string m_Format;
+
+ [HttpQueryMemberAttribute(Name = "pk", EmitDefaultValue = false)]
+ public int Pk
+ {
+ get { return m_pk; }
+ set { m_pk = value; }
+ }
+ private int m_pk;
+
+ [HttpQueryMemberAttribute(Name = "offset", EmitDefaultValue = false)]
+ public int Offset
+ {
+ get { return m_Offset; }
+ set { m_Offset = value; }
+ }
+ private int m_Offset;
+
+ [HttpQueryMemberAttribute(Name = "limit", EmitDefaultValue = false)]
+ public int Limit
+ {
+ get { return m_Limit; }
+ set { m_Limit = value; }
+ }
+ private int m_Limit;
+
+ [HttpQueryMemberAttribute(Name = "zipcode", EmitDefaultValue = false)]
+ public string Zipcode
+ {
+ get { return m_Zipcode; }
+ set { m_Zipcode = value; }
+ }
+ private string m_Zipcode;
+
+ [HttpQueryMemberAttribute(Name = "housenumber", EmitDefaultValue = false)]
+ public string Housenumber
+ {
+ get { return m_Housenumber; }
+ set { m_Housenumber = value; }
+ }
+ private string m_Housenumber;
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/HttpQueryMemberAttribute.cs b/Route4MeSDKLibrary/QueryTypes/HttpQueryMemberAttribute.cs
new file mode 100755
index 00000000..3683b433
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/HttpQueryMemberAttribute.cs
@@ -0,0 +1,37 @@
+using System;
+
+namespace Route4MeSDK.QueryTypes
+{
+
+ public sealed class HttpQueryMemberAttribute : Attribute
+ {
+ #region Properties
+
+ ///
+ /// The serialized argument name, if specifed overrides the property name
+ ///
+ public string Name { get; set; }
+
+ ///
+ /// Specifies whether to emit the property value, if its value is a default value
+ ///
+ public bool EmitDefaultValue { get; set; }
+
+ ///
+ /// Specifies the default value, that is used when emiting the property value
+ /// If not specified null is used as a default value
+ ///
+ public object DefaultValue { get; set; }
+
+ #endregion
+
+ #region Methods
+
+ public HttpQueryMemberAttribute()
+ {
+ EmitDefaultValue = true;
+ }
+
+ #endregion
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/HybridOptimizationParameters.cs b/Route4MeSDKLibrary/QueryTypes/HybridOptimizationParameters.cs
new file mode 100644
index 00000000..bef2195b
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/HybridOptimizationParameters.cs
@@ -0,0 +1,19 @@
+using Route4MeSDK.DataTypes;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.QueryTypes
+{
+
+ [DataContract]
+ public sealed class HybridOptimizationParameters : GenericParameters
+ {
+ [IgnoreDataMember] // Don't serialize as JSON
+ [HttpQueryMemberAttribute(Name = "target_date_string", EmitDefaultValue = false)]
+ public string target_date_string { get; set; }
+
+ [IgnoreDataMember] // Don't serialize as JSON
+ [HttpQueryMemberAttribute(Name = "timezone_offset_minutes", EmitDefaultValue = false)]
+ public int timezone_offset_minutes { get; set; }
+
+ }
+}
\ No newline at end of file
diff --git a/Route4MeSDKLibrary/QueryTypes/MemberConfigurationParameters.cs b/Route4MeSDKLibrary/QueryTypes/MemberConfigurationParameters.cs
new file mode 100644
index 00000000..2dade714
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/MemberConfigurationParameters.cs
@@ -0,0 +1,23 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class MemberConfigurationParameters : GenericParameters
+ {
+ [DataMember(Name = "config_key", EmitDefaultValue = false)]
+ public string config_key
+ {
+ get { return m_config_key; }
+ set { m_config_key = value; }
+ }
+ private string m_config_key;
+
+ [DataMember(Name = "config_value", EmitDefaultValue = false)]
+ public string config_value
+ {
+ get { return m_config_value; }
+ set { m_config_value = value; }
+ }
+ private string m_config_value;
+ }
+}
\ No newline at end of file
diff --git a/Route4MeSDKLibrary/QueryTypes/MemberParameters.cs b/Route4MeSDKLibrary/QueryTypes/MemberParameters.cs
new file mode 100644
index 00000000..6e39b8f6
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/MemberParameters.cs
@@ -0,0 +1,129 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class MemberParameters : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "session_guid", EmitDefaultValue = false)]
+ public string SessionGuid
+ {
+ get { return m_SessionGuid; }
+ set { m_SessionGuid = value; }
+ }
+ private string m_SessionGuid;
+
+ [HttpQueryMemberAttribute(Name = "format", EmitDefaultValue = false)]
+ public string hFormat
+ {
+ get { return m_hFormat; }
+ set { m_hFormat = value; }
+ }
+ private string m_hFormat;
+
+ [HttpQueryMemberAttribute(Name = "member_id", EmitDefaultValue = false)]
+ public System.Nullable MemberId
+ {
+ get { return m_MemberId; }
+ set { m_MemberId = value; }
+ }
+ private System.Nullable m_MemberId;
+
+ [HttpQueryMemberAttribute(Name = "plan", EmitDefaultValue = false)]
+ public string Plan
+ {
+ get { return m_Plan; }
+ set { m_Plan = value; }
+ }
+ private string m_Plan;
+
+ [HttpQueryMemberAttribute(Name = "member_type", EmitDefaultValue = false)]
+ public System.Nullable MemberType
+ {
+ get { return m_MemberType; }
+ set { m_MemberType = value; }
+ }
+ private System.Nullable m_MemberType;
+
+ [DataMember(Name = "strEmail", EmitDefaultValue = false)]
+ public string StrEmail
+ {
+ get { return m_StrEmail; }
+ set { m_StrEmail = value; }
+ }
+ private string m_StrEmail;
+
+ [DataMember(Name = "strPassword", EmitDefaultValue = false)]
+ public string StrPassword
+ {
+ get { return m_StrPassword; }
+ set { m_StrPassword = value; }
+ }
+ private string m_StrPassword;
+
+ [DataMember(Name = "format", EmitDefaultValue = false)]
+ public string Format
+ {
+ get { return m_Format; }
+ set { m_Format = value; }
+ }
+ private string m_Format;
+
+ [DataMember(Name = "strIndustry", EmitDefaultValue = false)]
+ public string StrIndustry
+ {
+ get { return m_StrIndustry; }
+ set { m_StrIndustry = value; }
+ }
+ private string m_StrIndustry;
+
+ [DataMember(Name = "strFirstName", EmitDefaultValue = false)]
+ public string StrFirstName
+ {
+ get { return m_StrFirstName; }
+ set { m_StrFirstName = value; }
+ }
+ private string m_StrFirstName;
+
+ [DataMember(Name = "strLastName", EmitDefaultValue = false)]
+ public string StrLastName
+ {
+ get { return m_StrLastName; }
+ set { m_StrLastName = value; }
+ }
+ private string m_StrLastName;
+
+ [DataMember(Name = "chkTerms", EmitDefaultValue = false)]
+ public System.Nullable ChkTerms
+ {
+ get { return m_ChkTerms; }
+ set { m_ChkTerms = value; }
+ }
+ private System.Nullable m_ChkTerms;
+
+ [DataMember(Name = "device_type", EmitDefaultValue = false)]
+ public string DeviceType
+ {
+ get { return m_DeviceType; }
+ set { m_DeviceType = value; }
+ }
+ private string m_DeviceType;
+
+ [DataMember(Name = "strPassword_1", EmitDefaultValue = false)]
+ public string StrPassword_1
+ {
+ get { return m_StrPassword1; }
+ set { m_StrPassword1 = value; }
+ }
+ private string m_StrPassword1;
+
+ [DataMember(Name = "strPassword_2", EmitDefaultValue = false)]
+ public string StrPassword_2
+ {
+ get { return m_StrPassword2; }
+ set { m_StrPassword2 = value; }
+ }
+ private string m_StrPassword2;
+
+
+ }
+}
\ No newline at end of file
diff --git a/Route4MeSDKLibrary/QueryTypes/MemberParametersV4.cs b/Route4MeSDKLibrary/QueryTypes/MemberParametersV4.cs
new file mode 100644
index 00000000..134ae72d
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/MemberParametersV4.cs
@@ -0,0 +1,137 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class MemberParametersV4 : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "member_id", EmitDefaultValue = false)]
+ public System.Nullable member_id
+ {
+ get { return m_member_id; }
+ set { m_member_id = value; }
+ }
+ private System.Nullable m_member_id;
+
+ [DataMember(Name = "HIDE_ROUTED_ADDRESSES", EmitDefaultValue = false)]
+ public bool HIDE_ROUTED_ADDRESSES
+ {
+ get { return m_HIDE_ROUTED_ADDRESSES; }
+ set { m_HIDE_ROUTED_ADDRESSES = value; }
+ }
+ private bool m_HIDE_ROUTED_ADDRESSES;
+
+
+ [DataMember(Name = "HIDE_VISITED_ADDRESSES", EmitDefaultValue = false)]
+ public bool HIDE_VISITED_ADDRESSES
+ {
+ get { return m_HIDE_VISITED_ADDRESSES; }
+ set { m_HIDE_VISITED_ADDRESSES = value; }
+ }
+ private bool m_HIDE_VISITED_ADDRESSES;
+
+ [DataMember(Name = "READONLY_USER", EmitDefaultValue = false)]
+ public bool READONLY_USER
+ {
+ get { return m_READONLY_USER; }
+ set { m_READONLY_USER = value; }
+ }
+ private bool m_READONLY_USER;
+
+
+ [DataMember(Name = "HIDE_NONFUTURE_ROUTES", EmitDefaultValue = false)]
+ public bool HIDE_NONFUTURE_ROUTES
+ {
+ get { return m_HIDE_NONFUTURE_ROUTES; }
+ set { m_HIDE_NONFUTURE_ROUTES = value; }
+ }
+ private bool m_HIDE_NONFUTURE_ROUTES;
+
+ [DataMember(Name = "SHOW_ALL_VEHICLES", EmitDefaultValue = false)]
+ public bool SHOW_ALL_VEHICLES
+ {
+ get { return m_SHOW_ALL_VEHICLES; }
+ set { m_SHOW_ALL_VEHICLES = value; }
+ }
+ private bool m_SHOW_ALL_VEHICLES;
+
+ [DataMember(Name = "SHOW_ALL_DRIVERS", EmitDefaultValue = false)]
+ public bool SHOW_ALL_DRIVERS
+ {
+ get { return m_SHOW_ALL_DRIVERS; }
+ set { m_SHOW_ALL_DRIVERS = value; }
+ }
+ private bool m_SHOW_ALL_DRIVERS;
+
+ [DataMember(Name = "member_phone", EmitDefaultValue = false)]
+ public string member_phone
+ {
+ get { return m_member_phone; }
+ set { m_member_phone = value; }
+ }
+ private string m_member_phone;
+
+ [DataMember(Name = "member_zipcode", EmitDefaultValue = false)]
+ public string member_zipcode
+ {
+ get { return m_member_zipcode; }
+ set { m_member_zipcode = value; }
+ }
+ private string m_member_zipcode;
+
+ [HttpQueryMemberAttribute(Name = "route_count", EmitDefaultValue = false)]
+ public System.Nullable route_count
+ {
+ get { return m_route_count; }
+ set { m_route_count = value; }
+ }
+ private System.Nullable m_route_count;
+
+ [DataMember(Name = "member_email", EmitDefaultValue = false)]
+ public string member_email
+ {
+ get { return m_member_email; }
+ set { m_member_email = value; }
+ }
+ private string m_member_email;
+
+ [DataMember(Name = "member_type", EmitDefaultValue = false)]
+ public string member_type
+ {
+ get { return m_member_type; }
+ set { m_member_type = value; }
+ }
+ private string m_member_type;
+
+ [DataMember(Name = "date_of_birth", EmitDefaultValue = false)]
+ public string date_of_birth
+ {
+ get { return m_date_of_birth; }
+ set { m_date_of_birth = value; }
+ }
+ private string m_date_of_birth;
+
+ [DataMember(Name = "member_first_name", EmitDefaultValue = false)]
+ public string member_first_name
+ {
+ get { return m_member_first_name; }
+ set { m_member_first_name = value; }
+ }
+ private string m_member_first_name;
+
+ [DataMember(Name = "member_password", EmitDefaultValue = false)]
+ public string member_password
+ {
+ get { return m_member_password; }
+ set { m_member_password = value; }
+ }
+ private string m_member_password;
+
+ [DataMember(Name = "member_last_name", EmitDefaultValue = false)]
+ public string member_last_name
+ {
+ get { return m_member_last_name; }
+ set { m_member_last_name = value; }
+ }
+ private string m_member_last_name;
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/NoteParameters.cs b/Route4MeSDKLibrary/QueryTypes/NoteParameters.cs
new file mode 100644
index 00000000..d3c0f3b0
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/NoteParameters.cs
@@ -0,0 +1,28 @@
+
+namespace Route4MeSDK.QueryTypes
+{
+
+ public sealed class NoteParameters : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "address_id", EmitDefaultValue = false)]
+ public int AddressId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "dev_lat")]
+ public double Latitude { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "dev_lng")]
+ public double Longitude { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "device_type")]
+ public string DeviceType { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "strUpdateType")]
+ public string ActivityType { get; set; }
+
+ //[HttpQueryMemberAttribute(Name = "strNoteContents", EmitDefaultValue = false)]
+ //public string StrNoteContents { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/OptimizationParameters.cs b/Route4MeSDKLibrary/QueryTypes/OptimizationParameters.cs
new file mode 100644
index 00000000..82c4bcec
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/OptimizationParameters.cs
@@ -0,0 +1,40 @@
+using Route4MeSDK.DataTypes;
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.QueryTypes
+{
+
+ [DataContract]
+ public sealed class OptimizationParameters : GenericParameters
+ {
+ [IgnoreDataMember] // Don't serialize as JSON
+ [HttpQueryMemberAttribute(Name = "optimization_problem_id", EmitDefaultValue = false)]
+ public string OptimizationProblemID { get; set; }
+
+ [IgnoreDataMember] // Don't serialize as JSON
+ [HttpQueryMemberAttribute(Name = "reoptimize", EmitDefaultValue = false)]
+ public bool? ReOptimize { get; set; }
+
+ ///
+ /// If true will be redirected
+ ///
+ [IgnoreDataMember()]
+ [HttpQueryMemberAttribute(Name = "redirect", EmitDefaultValue = false)]
+ public System.Nullable Redirect
+ {
+ get { return m_Redirect; }
+ set { m_Redirect = value; }
+ }
+ private System.Nullable m_Redirect;
+
+ [IgnoreDataMember] // Don't serialize as JSON
+ [HttpQueryMemberAttribute(Name = "show_directions", EmitDefaultValue = false)]
+ public bool? ShowDirections { get; set; }
+
+ [DataMember(Name = "parameters", EmitDefaultValue = false)]
+ public RouteParameters Parameters { get; set; }
+
+ [DataMember(Name = "addresses", EmitDefaultValue = false)]
+ public Address[] Addresses { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/OrderParameters.cs b/Route4MeSDKLibrary/QueryTypes/OrderParameters.cs
new file mode 100644
index 00000000..e4e4e372
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/OrderParameters.cs
@@ -0,0 +1,70 @@
+
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class OrderParameters : GenericParameters
+ {
+
+ ///
+ /// Limit per page, if you use 0 you will get all records
+ ///
+ [HttpQueryMemberAttribute(Name = "limit", EmitDefaultValue = false)]
+ public uint? Limit { get; set; }
+
+ ///
+ /// Offset
+ ///
+ [HttpQueryMemberAttribute(Name = "offset", EmitDefaultValue = false)]
+ public uint? Offset { get; set; }
+
+ ///
+ /// if query is array search engine will search by fields, if query is string will search by all text fields. Array / string.
+ ///
+ [HttpQueryMemberAttribute(Name = "query", EmitDefaultValue = false)]
+ public string Query { get; set; }
+
+ ///
+ /// Use it for get specific fields. String / coma separated
+ ///
+ [HttpQueryMemberAttribute(Name = "fields", EmitDefaultValue = false)]
+ public string Fields { get; set; }
+
+ ///
+ /// filter routed/unrouted. enum(all,routed,unrouted)
+ ///
+ [HttpQueryMemberAttribute(Name = "display", EmitDefaultValue = false)]
+ public string Display { get; set; }
+
+ ///
+ /// Order ID.
+ ///
+ [HttpQueryMemberAttribute(Name = "order_id", EmitDefaultValue = false)]
+ public string OrderId
+ {
+ get { return m_OrderId; }
+ set { m_OrderId = value; }
+ }
+ private string m_OrderId;
+
+ ///
+ /// Date an order was inserted
+ ///
+ [HttpQueryMemberAttribute(Name = "day_added_YYMMDD", EmitDefaultValue = false)]
+ public string DayAddedYYMMDD
+ {
+ get { return m_DayAddedYYMMDD; }
+ set { m_DayAddedYYMMDD = value; }
+ }
+ private string m_DayAddedYYMMDD;
+
+ ///
+ /// Date an order was scheduled for
+ ///
+ [HttpQueryMemberAttribute(Name = "scheduled_for_YYMMDD", EmitDefaultValue = false)]
+ public string ScheduledForYYMMDD
+ {
+ get { return m_ScheduledForYYMMDD; }
+ set { m_ScheduledForYYMMDD = value; }
+ }
+ private string m_ScheduledForYYMMDD;
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/RouteParametersQuery.cs b/Route4MeSDKLibrary/QueryTypes/RouteParametersQuery.cs
new file mode 100755
index 00000000..c62e4882
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/RouteParametersQuery.cs
@@ -0,0 +1,144 @@
+
+using Route4MeSDK.DataTypes;
+using System.Runtime.Serialization;
+namespace Route4MeSDK.QueryTypes
+{
+ ///
+ /// Route parameters accepted by endpoints
+ ///
+ [DataContract]
+ public sealed class RouteParametersQuery : GenericParameters
+ {
+ ///
+ /// Route Identifier
+ ///
+ [IgnoreDataMember] // Don't serialize as JSON
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId { get; set; }
+
+ ///
+ /// Pass True to return directions and the route path
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "directions", EmitDefaultValue = false)]
+ public bool? Directions { get; set; }
+
+ ///
+ /// "None" - no path output. "Points" - points path output
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "route_path_output", EmitDefaultValue = false)]
+ public string RoutePathOutput { get; set; }
+
+ ///
+ /// Output route tracking data in response
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "device_tracking_history", EmitDefaultValue = false)]
+ public bool? DeviceTrackingHistory { get; set; }
+
+ ///
+ /// The number of existing routes that should be returned per response when looking at a list of all the routes.
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "limit", EmitDefaultValue = false)]
+ public uint? Limit { get; set; }
+
+ ///
+ /// The page number for route listing pagination. Increment the offset by the limit number to move to the next page.
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "offset", EmitDefaultValue = false)]
+ public uint? Offset { get; set; }
+
+ ///
+ /// Output addresses and directions in the original optimization request sequence. This is to allow us to compare routes before & after optimization.
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "original", EmitDefaultValue = false)]
+ public bool? Original { get; set; }
+
+ ///
+ /// Output route and stop-specific notes. The notes will have timestamps, note types, and geospatial information if available
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "notes", EmitDefaultValue = false)]
+ public bool? Notes { get; set; }
+
+ ///
+ /// Search query
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "query", EmitDefaultValue = false)]
+ public string Query { get; set; }
+
+ ///
+ /// Updating a route supports the reoptimize=1 parameter, which reoptimizes only that route. Also supports the parameters from GET.
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "reoptimize", EmitDefaultValue = false)]
+ public bool? ReOptimize { get; set; }
+
+
+ [IgnoreDataMember()]
+ [HttpQueryMemberAttribute(Name = "disable_optimization", EmitDefaultValue = false)]
+ public System.Nullable DisableOptimization
+ {
+ get { return m_DisableOptimization; }
+ set { m_DisableOptimization = value; }
+ }
+ private System.Nullable m_DisableOptimization;
+
+ [IgnoreDataMember()]
+ [HttpQueryMemberAttribute(Name = "optimize", EmitDefaultValue = false)]
+ public string Optimize
+ {
+ get { return m_Optimize; }
+ set { m_Optimize = value; }
+ }
+ private string m_Optimize;
+
+ ///
+ /// By sending recompute_directions=1 we request that the route directions be recomputed (note that this does happen automatically if certain properties of the route are updated, such as stop sequence_no changes or round-tripness)
+ ///
+ [IgnoreDataMember]
+ [HttpQueryMemberAttribute(Name = "recompute_directions", EmitDefaultValue = false)]
+ public bool? RecomputeDirections { get; set; }
+
+ [IgnoreDataMember()]
+ [HttpQueryMemberAttribute(Name = "response_format", EmitDefaultValue = false)]
+ public string ResponseFormat
+ {
+ get { return m_ResponseFormat; }
+ set { m_ResponseFormat = value; }
+ }
+ private string m_ResponseFormat;
+
+ [IgnoreDataMember()]
+ [HttpQueryMemberAttribute(Name = "route_destination_id", EmitDefaultValue = false)]
+ public System.Nullable RouteDestinationId
+ {
+ get { return m_RouteDestinationId; }
+ set { m_RouteDestinationId = value; }
+ }
+ private System.Nullable m_RouteDestinationId;
+
+ ///
+ /// If true will be redirected
+ ///
+ [IgnoreDataMember()]
+ [HttpQueryMemberAttribute(Name = "redirect", EmitDefaultValue = false)]
+ public System.Nullable Redirect {
+ get { return m_Redirect; }
+ set { m_Redirect = value; }
+ }
+ private System.Nullable m_Redirect;
+
+ ///
+ /// Route Parameters to update.
+ /// (After a PUT there is no guarantee that the route_destination_id values are preserved! It may create copies resulting in new destination IDs, especially when dealing with multiple depots.)
+ ///
+ [DataMember(Name = "parameters", EmitDefaultValue = false)]
+ public RouteParameters Parameters { get; set; }
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/TerritoryQuery.cs b/Route4MeSDKLibrary/QueryTypes/TerritoryQuery.cs
new file mode 100644
index 00000000..2e57c67e
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/TerritoryQuery.cs
@@ -0,0 +1,40 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class TerritoryQuery : GenericParameters
+ {
+ ///
+ /// Device Id
+ ///
+ [HttpQueryMemberAttribute(Name = "device_id", EmitDefaultValue = false)]
+ public string DeviceID
+ {
+ get { return m_DeviceID; }
+ set { m_DeviceID = value; }
+ }
+ private string m_DeviceID;
+
+ ///
+ /// Territory Id
+ ///
+ [HttpQueryMemberAttribute(Name = "territory_id", EmitDefaultValue = false)]
+ public string TerritoryId
+ {
+ get { return m_TerritoryId; }
+ set { m_TerritoryId = value; }
+ }
+ private string m_TerritoryId;
+
+ ///
+ /// Territory Id
+ ///
+ [HttpQueryMemberAttribute(Name = "addresses", EmitDefaultValue = false)]
+ public System.Nullable addresses
+ {
+ get { return m_addresses; }
+ set { m_addresses = value; }
+ }
+ private System.Nullable m_addresses;
+ }
+}
diff --git a/Route4MeSDKLibrary/QueryTypes/VehicleParameters.cs b/Route4MeSDKLibrary/QueryTypes/VehicleParameters.cs
new file mode 100644
index 00000000..e72a5ffa
--- /dev/null
+++ b/Route4MeSDKLibrary/QueryTypes/VehicleParameters.cs
@@ -0,0 +1,41 @@
+using System.Runtime.Serialization;
+
+namespace Route4MeSDK.QueryTypes
+{
+ public sealed class VehicleParameters : GenericParameters
+ {
+ ///
+ /// Limit per page, if you use 0 you will get all records
+ ///
+ [HttpQueryMemberAttribute(Name = "limit", EmitDefaultValue = false)]
+ public System.Nullable Limit
+ {
+ get { return m_Limit; }
+ set { m_Limit = value; }
+ }
+ private System.Nullable m_Limit;
+
+ ///
+ /// Offset
+ ///
+ [HttpQueryMemberAttribute(Name = "offset", EmitDefaultValue = false)]
+ public System.Nullable Offset
+ {
+ get { return m_Offset; }
+ set { m_Offset = value; }
+ }
+ private System.Nullable m_Offset;
+
+ ///
+ /// Vehicle ID
+ ///
+ [DataMember(Name = "vehicle_id", EmitDefaultValue = false)]
+ public string VehicleId
+ {
+ get { return m_VehicleId; }
+ set { m_VehicleId = value; }
+ }
+ private string m_VehicleId;
+ }
+}
+
diff --git a/Route4MeSDKLibrary/Route4MeManager.cs b/Route4MeSDKLibrary/Route4MeManager.cs
new file mode 100755
index 00000000..a270d5af
--- /dev/null
+++ b/Route4MeSDKLibrary/Route4MeManager.cs
@@ -0,0 +1,2439 @@
+using Route4MeSDK.DataTypes;
+using Route4MeSDK.QueryTypes;
+using Route4MeSDKLibrary.DataTypes;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+
+namespace Route4MeSDK
+{
+ ///
+ /// This class encapsulates the Route4Me REST API
+ /// 1. Create an instance of Route4MeManager with the api_key
+ /// 1. Shortcut methods: Use shortcuts methods (for example Route4MeManager.GetOptimization()) to access the most popular functionality.
+ /// See examples Route4MeExamples.GetOptimization(), Route4MeExamples.SingleDriverRoundTrip()
+ /// 2. Generic methods: Use generic methods (for example Route4MeManager.GetJsonObjectFromAPI() or Route4MeManager.GetStringResponseFromAPI())
+ /// to access any availaible functionality.
+ /// See examples Route4MeExamples.GenericExample(), Route4MeExamples.SingleDriverRoundTripGeneric()
+ ///
+ public sealed class Route4MeManager
+ {
+ #region Fields
+
+ private readonly string m_ApiKey;
+ private readonly TimeSpan m_DefaultTimeOut = new TimeSpan(TimeSpan.TicksPerMinute * 30); // Default timeout - 30 minutes
+ //private bool m_isTestMode = false;
+
+ #endregion
+
+ #region Methods
+
+ #region Constructors
+
+ public Route4MeManager(string apiKey)
+ {
+ m_ApiKey = apiKey;
+ }
+
+ #endregion
+
+ #region Route4Me Shortcut Methods
+
+ #region Optimizations
+
+ public DataObject RunOptimization(OptimizationParameters optimizationParameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(optimizationParameters,
+ R4MEInfrastructureSettings.ApiHost,
+ HttpMethodType.Post,
+ false,
+ out errorString);
+
+ return result;
+ }
+
+ public DataObject GetOptimization(OptimizationParameters optimizationParameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(optimizationParameters,
+ R4MEInfrastructureSettings.ApiHost,
+ HttpMethodType.Get,
+ out errorString);
+
+ return result;
+ }
+
+ ///
+ ///
+ [DataContract]
+ private sealed class DataObjectOptimizations
+ {
+ [DataMember(Name = "optimizations")]
+ public DataObject[] Optimizations { get; set; }
+ }
+
+ public DataObject[] GetOptimizations(RouteParametersQuery queryParameters, out string errorString)
+ {
+ DataObjectOptimizations dataObjectOptimizations = GetJsonObjectFromAPI(queryParameters,
+ R4MEInfrastructureSettings.ApiHost,
+ HttpMethodType.Get,
+ out errorString);
+ DataObject[] result = null;
+ if (dataObjectOptimizations != null)
+ {
+ result = dataObjectOptimizations.Optimizations;
+ }
+ return result;
+ }
+
+ public DataObject UpdateOptimization(OptimizationParameters optimizationParameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(optimizationParameters,
+ R4MEInfrastructureSettings.ApiHost,
+ HttpMethodType.Put,
+ false,
+ out errorString);
+
+ return result;
+ }
+
+ [DataContract]
+ private sealed class RemoveOptimizationResponse
+ {
+ [DataMember(Name = "status")]
+ public bool Status { get; set; }
+ [DataMember(Name = "removed")]
+ public bool Removed { get; set; }
+ }
+
+ ///
+ /// Remove an existing optimization belonging to an user.
+ ///
+ /// Optimization Problem ID
+ /// out: Error as string
+ /// Result status true/false
+ public bool RemoveOptimization(string optimizationProblemID, out string errorString)
+ {
+ GenericParameters genericParameters = new GenericParameters();
+ genericParameters.ParametersCollection.Add("optimization_problem_id", optimizationProblemID);
+ RemoveOptimizationResponse response = GetJsonObjectFromAPI(genericParameters,
+ R4MEInfrastructureSettings.ApiHost,
+ HttpMethodType.Delete,
+ out errorString);
+ if (response != null && response.Status && response.Removed)
+ {
+ return true;
+ }
+ else
+ {
+ if (errorString == "")
+ errorString = "Error removing optimization";
+ return false;
+ }
+ }
+
+ [DataContract]
+ private sealed class RemoveDestinationFromOptimizationResponse
+ {
+ [DataMember(Name = "deleted")]
+ public Boolean Deleted { get; set; }
+
+ [DataMember(Name = "route_destination_id")]
+ public int RouteDestinationId { get; set; }
+ }
+
+ public bool RemoveDestinationFromOptimization(string optimizationId, int destinationId, out string errorString)
+ {
+ GenericParameters genericParameters = new GenericParameters();
+ genericParameters.ParametersCollection.Add("optimization_problem_id", optimizationId);
+ genericParameters.ParametersCollection.Add("route_destination_id", destinationId.ToString());
+ RemoveDestinationFromOptimizationResponse response = GetJsonObjectFromAPI(genericParameters,
+ R4MEInfrastructureSettings.GetAddress,
+ HttpMethodType.Delete,
+ out errorString);
+ if (response != null && response.Deleted)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ #endregion
+
+ #region Hybrid Optimization
+ public DataObject GetOHybridptimization(HybridOptimizationParameters hybridOptimizationParameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(hybridOptimizationParameters,
+ R4MEInfrastructureSettings.HybridOptimization,
+ HttpMethodType.Get,
+ out errorString);
+
+ return result;
+ }
+ #endregion
+
+ #region Routes
+
+ public DataObjectRoute GetRoute(RouteParametersQuery routeParameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(routeParameters,
+ R4MEInfrastructureSettings.RouteHost,
+ HttpMethodType.Get,
+ out errorString);
+
+ return result;
+ }
+
+ public DataObjectRoute[] GetRoutes(RouteParametersQuery routeParameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(routeParameters,
+ R4MEInfrastructureSettings.RouteHost,
+ HttpMethodType.Get,
+ out errorString);
+
+ return result;
+ }
+
+ public string GetRouteId(string optimizationProblemId, out string errorString)
+ {
+ GenericParameters genericParameters = new GenericParameters();
+ genericParameters.ParametersCollection.Add("optimization_problem_id", optimizationProblemId);
+ genericParameters.ParametersCollection.Add("wait_for_final_state", "1");
+ DataObject response = GetJsonObjectFromAPI(genericParameters,
+ R4MEInfrastructureSettings.ApiHost,
+ HttpMethodType.Get,
+ out errorString);
+ if (response != null && response.Routes != null && response.Routes.Length > 0)
+ {
+ string routeId = response.Routes[0].RouteID;
+ return routeId;
+ }
+ return null;
+ }
+
+ public DataObjectRoute UpdateRoute(RouteParametersQuery routeParameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(routeParameters,
+ R4MEInfrastructureSettings.RouteHost,
+ HttpMethodType.Put,
+ out errorString);
+
+ return result;
+ }
+
+ [DataContract]
+ private sealed class DuplicateRouteResponse
+ {
+ [DataMember(Name = "optimization_problem_id")]
+ public string OptimizationProblemId { get; set; }
+
+ [DataMember(Name = "success")]
+ public Boolean Success { get; set; }
+ }
+
+ public string DuplicateRoute(RouteParametersQuery queryParameters, out string errorString)
+ {
+ //if (queryParameters.ParametersCollection["to"] == null)
+ // queryParameters.ParametersCollection.Add("to", "none");
+ // Redirect to page or return json for none
+ queryParameters.ParametersCollection["to"] = "none";
+ DuplicateRouteResponse response = GetJsonObjectFromAPI(queryParameters,
+ R4MEInfrastructureSettings.DuplicateRoute,
+ HttpMethodType.Get,
+ out errorString);
+ string routeId = null;
+ if (response != null && response.Success)
+ {
+ string optimizationProblemId = response.OptimizationProblemId;
+ if (optimizationProblemId != null)
+ {
+ routeId = this.GetRouteId(optimizationProblemId, out errorString);
+ }
+ }
+ return routeId;
+ }
+
+ [DataContract]
+ private sealed class DeleteRouteResponse
+ {
+ [DataMember(Name = "deleted")]
+ public Boolean Deleted { get; set; }
+
+ [DataMember(Name = "errors")]
+ public List Errors { get; set; }
+
+ [DataMember(Name = "route_id")]
+ public string routeId { get; set; }
+
+ [DataMember(Name = "route_ids")]
+ public string[] routeIds { get; set; }
+ }
+
+ public string[] DeleteRoutes(string[] routeIds, out string errorString)
+ {
+ string str_route_ids = "";
+ foreach (string routeId in routeIds)
+ {
+ if (str_route_ids.Length > 0)
+ str_route_ids += ",";
+ str_route_ids += routeId;
+ }
+ GenericParameters genericParameters = new GenericParameters();
+ genericParameters.ParametersCollection.Add("route_id", str_route_ids);
+ DeleteRouteResponse response = GetJsonObjectFromAPI(genericParameters,
+ R4MEInfrastructureSettings.RouteHost,
+ HttpMethodType.Delete,
+ out errorString);
+ string[] deletedRouteIds = null;
+ if (response != null)
+ {
+ deletedRouteIds = response.routeIds;
+ }
+ return deletedRouteIds;
+ }
+
+ public void MergeRoutes(string[] routeIds, out string errorString)
+ {
+ string str_route_ids = "";
+ foreach (string routeId in routeIds)
+ {
+ if (str_route_ids.Length > 0)
+ str_route_ids += ",";
+ str_route_ids += routeId;
+ }
+ GenericParameters genericParameters = new GenericParameters();
+ genericParameters.ParametersCollection.Add("route_ids", str_route_ids);
+ DataObject result = GetJsonObjectFromAPI(genericParameters,
+ R4MEInfrastructureSettings.MergeRoutes,
+ HttpMethodType.Post,
+ out errorString);
+ }
+
+ [DataContract()]
+ private sealed class ResequenceReoptimizeRouteResponse
+ {
+ [DataMember(Name = "status")]
+ public Boolean Status
+ {
+ get { return m_Status; }
+ set { m_Status = value; }
+ }
+ private Boolean m_Status;
+ }
+
+ public bool ResequenceReoptimizeRoute(Dictionary roParames, out string errorString)
+ {
+ RouteParametersQuery request = new RouteParametersQuery
+ {
+ RouteId = roParames["route_id"],
+ DisableOptimization = roParames["disable_optimization"]=="1" ? true : false,
+ Optimize = roParames["optimize"]
+ };
+
+ ResequenceReoptimizeRouteResponse response = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.RouteReoptimize, HttpMethodType.Get, out errorString);
+
+ if (response != null && response.Status)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ public bool RouteSharing(RouteParametersQuery roParames, string Email, out string errorString)
+ {
+ List> keyValues = new List>();
+
+ keyValues.Add(new KeyValuePair("recipient_email", Email));
+ HttpContent httpContent = new FormUrlEncodedContent(keyValues);
+
+ ResequenceReoptimizeRouteResponse response = GetJsonObjectFromAPI(roParames, R4MEInfrastructureSettings.RouteSharing, HttpMethodType.Post, httpContent, out errorString);
+
+ if (response != null && response.Status)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ [DataContract()]
+ private sealed class UpdateRouteCustomDataRequest : GenericParameters
+ {
+
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId
+ {
+ get { return m_RouteId; }
+ set { m_RouteId = value; }
+ }
+
+ private string m_RouteId;
+ [HttpQueryMemberAttribute(Name = "route_destination_id", EmitDefaultValue = false)]
+ public System.Nullable RouteDestinationId
+ {
+ get { return m_RouteDestinationId; }
+ set { m_RouteDestinationId = value; }
+ }
+
+ private System.Nullable m_RouteDestinationId;
+
+ [DataMember(Name = "custom_fields", EmitDefaultValue = false)]
+ public Dictionary CustomFields
+ {
+ get { return m_CustomFields; }
+ set { m_CustomFields = value; }
+ }
+ private Dictionary m_CustomFields;
+ }
+
+ public Address UpdateRouteCustomData(RouteParametersQuery routeParameters, Dictionary customData, out string errorString)
+ {
+ UpdateRouteCustomDataRequest request = new UpdateRouteCustomDataRequest
+ {
+ RouteId = routeParameters.RouteId,
+ RouteDestinationId = routeParameters.RouteDestinationId,
+ CustomFields = customData
+ };
+
+ var result = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.GetAddress, HttpMethodType.Put, out errorString);
+
+ return result;
+ }
+
+ [DataContract()]
+ private sealed class UpdateRouteDestinationRequest : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId
+ {
+ get { return m_RouteId; }
+ set { m_RouteId = value; }
+ }
+
+ private string m_RouteId;
+ [HttpQueryMemberAttribute(Name = "route_destination_id", EmitDefaultValue = false)]
+ public System.Nullable RouteDestinationId
+ {
+ get { return m_RouteDestinationId; }
+ set { m_RouteDestinationId = value; }
+ }
+ private System.Nullable m_RouteDestinationId;
+
+ [DataMember(Name = "alias", EmitDefaultValue = false)]
+ public string Alias { get; set; }
+
+ [DataMember(Name = "first_name", EmitDefaultValue = false)]
+ public string FirstName { get; set; }
+
+ [DataMember(Name = "last_name", EmitDefaultValue = false)]
+ public string LastName { get; set; }
+
+ [DataMember(Name = "address", EmitDefaultValue = false)]
+ public string AddressString { get; set; }
+
+ [DataMember(Name = "is_depot", EmitDefaultValue = false)]
+ public bool? IsDepot { get; set; }
+
+ //the latitude of this address
+ [DataMember(Name = "lat", EmitDefaultValue = false)]
+ public double Latitude { get; set; }
+
+ //the longitude of this address
+ [DataMember(Name = "lng", EmitDefaultValue = false)]
+ public double Longitude { get; set; }
+
+ [DataMember(Name = "sequence_no", EmitDefaultValue = false)]
+ public int? SequenceNo { get; set; }
+
+ //status flag to mark an address as visited (aka check in)
+ [DataMember(Name = "is_visited", EmitDefaultValue = false)]
+ public bool? IsVisited { get; set; }
+
+ //status flag to mark an address as departed (aka check out)
+ [DataMember(Name = "is_departed", EmitDefaultValue = false)]
+ public bool? IsDeparted { get; set; }
+
+ //the last known visited timestamp of this address
+ [DataMember(Name = "timestamp_last_visited", EmitDefaultValue = false)]
+ public uint? TimestampLastVisited { get; set; }
+
+ //the last known departed timestamp of this address
+ [DataMember(Name = "timestamp_last_departed", EmitDefaultValue = false)]
+ public uint? TimestampLastDeparted { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ [DataMember(Name = "customer_po", EmitDefaultValue = false)]
+ public object CustomerPo { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ [DataMember(Name = "invoice_no", EmitDefaultValue = false)]
+ public object InvoiceNo { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ [DataMember(Name = "reference_no", EmitDefaultValue = false)]
+ public object ReferenceNo { get; set; }
+
+ //pass-through data about this route destination
+ //the data will be visible on the manifest, website, and mobile apps
+ [DataMember(Name = "order_no", EmitDefaultValue = false)]
+ public object OrderNo { get; set; }
+
+ [DataMember(Name = "order_id", EmitDefaultValue = false)]
+ public int? OrderId { get; set; }
+
+ [DataMember(Name = "weight", EmitDefaultValue = false)]
+ public object Weight { get; set; }
+
+ [DataMember(Name = "cost", EmitDefaultValue = false)]
+ public object Cost { get; set; }
+
+ [DataMember(Name = "revenue", EmitDefaultValue = false)]
+ public object Revenue { get; set; }
+
+ //the cubic volume that this destination/order/line-item consumes/contains
+ //this is how much space it will take up on a vehicle
+ [DataMember(Name = "cube", EmitDefaultValue = false)]
+ public object Cube { get; set; }
+
+ //the number of pieces/palllets that this destination/order/line-item consumes/contains on a vehicle
+ [DataMember(Name = "pieces", EmitDefaultValue = false)]
+ public object Pieces { get; set; }
+
+ [DataMember(Name = "email", EmitDefaultValue = false)]
+ public string Email { get; set; }
+
+ [DataMember(Name = "phone", EmitDefaultValue = false)]
+ public string Phone { get; set; }
+
+ [DataMember(Name = "time_window_start", EmitDefaultValue = false)]
+ public int? TimeWindowStart { get; set; }
+
+ [DataMember(Name = "time_window_end", EmitDefaultValue = false)]
+ public int? TimeWindowEnd { get; set; }
+
+ //the expected amount of time that will be spent at this address by the driver/user
+ [DataMember(Name = "time", EmitDefaultValue = false)]
+ public int? Time { get; set; }
+
+ [DataMember(Name = "notes", EmitDefaultValue = false)]
+ public AddressNote[] Notes { get; set; }
+
+ //if present, the priority will sequence addresses in all the optimal routes so that
+ //higher priority addresses are general at the beginning of the route sequence
+ //1 is the highest priority, 100000 is the lowest
+ [DataMember(Name = "priority", EmitDefaultValue = false)]
+ public int? Priority { get; set; }
+
+ //generate optimal routes and driving directions to this curbside lat
+ [DataMember(Name = "curbside_lat", EmitDefaultValue = false)]
+ public double? CurbsideLatitude { get; set; }
+
+ //generate optimal routes and driving directions to the curbside lang
+ [DataMember(Name = "curbside_lng", EmitDefaultValue = false)]
+ public double? CurbsideLongitude { get; set; }
+
+ [DataMember(Name = "time_window_start_2", EmitDefaultValue = false)]
+ public int? TimeWindowStart2 { get; set; }
+
+ [DataMember(Name = "time_window_end_2", EmitDefaultValue = false)]
+ public int? TimeWindowEnd2 { get; set; }
+
+ [DataMember(Name = "custom_fields", EmitDefaultValue = false)]
+ public Dictionary CustomFields
+ {
+ get { return m_CustomFields; }
+ set { m_CustomFields = value; }
+ }
+ private Dictionary m_CustomFields;
+ }
+
+ public Address UpdateRouteDestination(Address addressParameters, out string errorString)
+ {
+ UpdateRouteDestinationRequest request = new UpdateRouteDestinationRequest
+ {
+ RouteId = addressParameters.RouteId,
+ RouteDestinationId = addressParameters.RouteDestinationId,
+ };
+
+ if (addressParameters.Alias != null) request.Alias = addressParameters.Alias;
+ if (addressParameters.FirstName != null) request.FirstName = addressParameters.FirstName;
+ if (addressParameters.LastName != null) request.LastName = addressParameters.LastName;
+ if (addressParameters.AddressString != null) request.AddressString = addressParameters.AddressString;
+ if (addressParameters.IsDepot != null) request.IsDepot = addressParameters.IsDepot;
+ if (addressParameters.Latitude != null) request.Latitude = addressParameters.Latitude;
+ if (addressParameters.Longitude != null) request.Longitude = addressParameters.Longitude;
+
+ if (addressParameters.SequenceNo != null) request.SequenceNo = addressParameters.SequenceNo;
+ if (addressParameters.IsVisited != null) request.IsVisited = addressParameters.IsVisited;
+ if (addressParameters.IsDeparted != null) request.IsDeparted = addressParameters.IsDeparted;
+ if (addressParameters.TimestampLastVisited != null) request.TimestampLastVisited = addressParameters.TimestampLastVisited;
+ if (addressParameters.TimestampLastDeparted != null) request.TimestampLastDeparted = addressParameters.TimestampLastDeparted;
+ if (addressParameters.CustomerPo != null) request.CustomerPo = addressParameters.CustomerPo;
+ if (addressParameters.InvoiceNo != null) request.InvoiceNo = addressParameters.InvoiceNo;
+ if (addressParameters.ReferenceNo != null) request.ReferenceNo = addressParameters.ReferenceNo;
+ if (addressParameters.OrderNo != null) request.OrderNo = addressParameters.OrderNo;
+ if (addressParameters.OrderId != null) request.OrderId = addressParameters.OrderId;
+ if (addressParameters.Weight != null) request.Weight = addressParameters.Weight;
+ if (addressParameters.Cost != null) request.Cost = addressParameters.Cost;
+ if (addressParameters.Revenue != null) request.Revenue = addressParameters.Revenue;
+ if (addressParameters.Cube != null) request.Cube = addressParameters.Cube;
+ if (addressParameters.Pieces != null) request.Pieces = addressParameters.Pieces;
+ if (addressParameters.Phone != null) request.Phone = addressParameters.Phone.ToString();
+
+ if (addressParameters.TimeWindowStart != null) request.TimeWindowStart = addressParameters.TimeWindowStart;
+ if (addressParameters.TimeWindowEnd != null) request.TimeWindowEnd = addressParameters.TimeWindowEnd;
+ if (addressParameters.Notes != null) request.Notes = addressParameters.Notes;
+ if (addressParameters.Priority != null) request.Priority = addressParameters.Priority;
+ if (addressParameters.CurbsideLatitude != null) request.CurbsideLatitude = addressParameters.CurbsideLatitude;
+ if (addressParameters.CurbsideLongitude != null) request.CurbsideLongitude = addressParameters.CurbsideLongitude;
+ if (addressParameters.TimeWindowStart2 != null) request.TimeWindowStart2 = addressParameters.TimeWindowStart2;
+ if (addressParameters.TimeWindowEnd2 != null) request.TimeWindowEnd2 = addressParameters.TimeWindowEnd2;
+ if (addressParameters.CustomFields != null) request.CustomFields = addressParameters.CustomFields;
+
+ var result = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.GetAddress, HttpMethodType.Put, out errorString);
+
+ return result;
+ }
+
+ #endregion
+
+ #region Tracking
+
+ public DataObject GetLastLocation(GenericParameters parameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(parameters,
+ R4MEInfrastructureSettings.RouteHost,
+ HttpMethodType.Get,
+ false,
+ out errorString);
+
+ return result;
+ }
+
+ public string SetGPS(GPSParameters gpsParameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(gpsParameters,
+ R4MEInfrastructureSettings.SetGpsHost,
+ HttpMethodType.Get,
+ true,
+ out errorString);
+
+ return result;
+ }
+
+ [DataContract()]
+ private sealed class FindAssetRequest : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "tracking", EmitDefaultValue = false)]
+ public string Tracking
+ {
+ get { return m_Tracking; }
+ set { m_Tracking = value; }
+ }
+
+ private string m_Tracking;
+ }
+
+ public FindAssetResponse FindAsset(string tracking, out string errorString)
+ {
+ FindAssetRequest request = new FindAssetRequest { Tracking = tracking };
+
+ FindAssetResponse result = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.AssetTracking, HttpMethodType.Get, false, out errorString);
+
+ return result;
+ }
+
+ #endregion
+
+ #region Users
+
+ public User[] GetUsers(GenericParameters parameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(parameters,
+ R4MEInfrastructureSettings.GetUsersHost,
+ HttpMethodType.Get,
+ out errorString);
+
+ return result;
+ }
+
+ public MemberResponseV4 CreateUser(MemberParametersV4 memParams, out string errorString)
+ {
+ MemberResponseV4 response = GetJsonObjectFromAPI(memParams, R4MEInfrastructureSettings.GetUsersHost, HttpMethodType.Post, out errorString);
+ return response;
+ }
+
+ [DataContract()]
+ public sealed class UserDeleteResponse
+ {
+ [DataMember(Name = "status")]
+ public bool Status
+ {
+ get { return m_Status; }
+ set { m_Status = value; }
+ }
+ private bool m_Status;
+ }
+
+ public bool UserDelete(MemberParametersV4 memParams, out string errorString)
+ {
+ UserDeleteResponse response = GetJsonObjectFromAPI(memParams, R4MEInfrastructureSettings.GetUsersHost, HttpMethodType.Delete, out errorString);
+
+ if (response == null) return false;
+
+ if (response.Status) return true; else return false;
+ }
+
+ public MemberResponseV4 GetUserById(MemberParametersV4 memParams, out string errorString)
+ {
+ MemberResponseV4 response = GetJsonObjectFromAPI(memParams, R4MEInfrastructureSettings.GetUsersHost, HttpMethodType.Get, out errorString);
+ return response;
+ }
+
+ public MemberResponseV4 UserUpdate(MemberParametersV4 memParams, out string errorString)
+ {
+ MemberResponseV4 response = GetJsonObjectFromAPI(memParams, R4MEInfrastructureSettings.GetUsersHost, HttpMethodType.Put, out errorString);
+ return response;
+ }
+
+ public MemberResponse UserAuthentication(MemberParameters memParams, out string errorString)
+ {
+ MemberParameters roParams = new MemberParameters();
+
+ var keyValues = new List>();
+ keyValues.Add(new KeyValuePair("strEmail", memParams.StrEmail));
+ keyValues.Add(new KeyValuePair("strPassword", memParams.StrPassword));
+ keyValues.Add(new KeyValuePair("format", memParams.Format));
+
+ HttpContent httpContent = new FormUrlEncodedContent(keyValues);
+
+ MemberResponse response = GetJsonObjectFromAPI(roParams, R4MEInfrastructureSettings.UserAuthentication, HttpMethodType.Post, httpContent, out errorString);
+
+ return response;
+ }
+
+ public MemberResponse UserRegistration(MemberParameters memParams, out string errorString)
+ {
+ MemberParameters roParams = new MemberParameters();
+ roParams.Plan = memParams.Plan;
+ roParams.MemberType = memParams.MemberType;
+
+ var keyValues = new List>();
+ keyValues.Add(new KeyValuePair("strIndustry", memParams.StrIndustry));
+ keyValues.Add(new KeyValuePair("strFirstName", memParams.StrFirstName));
+ keyValues.Add(new KeyValuePair("strLastName", memParams.StrLastName));
+ keyValues.Add(new KeyValuePair("strEmail", memParams.StrEmail));
+ keyValues.Add(new KeyValuePair("format", memParams.Format));
+ keyValues.Add(new KeyValuePair("chkTerms", memParams.ChkTerms==1 ? "1" : "0"));
+ keyValues.Add(new KeyValuePair("device_type", memParams.DeviceType));
+ keyValues.Add(new KeyValuePair("strPassword_1", memParams.StrPassword_1));
+ keyValues.Add(new KeyValuePair("strPassword_2", memParams.StrPassword_2));
+
+ HttpContent httpContent = new FormUrlEncodedContent(keyValues);
+
+ MemberResponse response = GetJsonObjectFromAPI(roParams, R4MEInfrastructureSettings.UserRegistration, HttpMethodType.Post, httpContent, out errorString);
+
+ return response;
+ }
+
+ [DataContract()]
+ private sealed class ValidateSessionRequest : GenericParameters
+ {
+
+ [HttpQueryMemberAttribute(Name = "session_guid", EmitDefaultValue = false)]
+ public string SessionGuid
+ {
+ get { return m_SessionGuid; }
+ set { m_SessionGuid = value; }
+ }
+
+ private string m_SessionGuid;
+ [HttpQueryMemberAttribute(Name = "member_id", EmitDefaultValue = false)]
+ public System.Nullable MemberId
+ {
+ get { return m_MemberId; }
+ set { m_MemberId = value; }
+ }
+
+ private System.Nullable m_MemberId;
+ [HttpQueryMemberAttribute(Name = "format", EmitDefaultValue = false)]
+ public string Format
+ {
+ get { return m_Format; }
+ set { m_Format = value; }
+ }
+
+ private string m_Format;
+ }
+
+ public MemberResponse ValidateSession(MemberParameters memParams, out string errorString)
+ {
+ ValidateSessionRequest request = new ValidateSessionRequest
+ {
+ SessionGuid = memParams.SessionGuid,
+ MemberId = memParams.MemberId,
+ Format = memParams.Format
+ };
+
+ MemberResponse result = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.ValidateSession, HttpMethodType.Get, false, out errorString);
+
+ return result;
+ }
+
+ public MemberConfigurationResponse CreateNewConfigurationKey(MemberConfigurationParameters confParams, out string errorString)
+ {
+ MemberConfigurationResponse response = GetJsonObjectFromAPI(confParams, R4MEInfrastructureSettings.UserConfiguration, HttpMethodType.Post, out errorString);
+
+ return response;
+ }
+
+ public MemberConfigurationResponse RemoveConfigurationKey(MemberConfigurationParameters confParams, out string errorString)
+ {
+ MemberConfigurationResponse response = GetJsonObjectFromAPI(confParams, R4MEInfrastructureSettings.UserConfiguration, HttpMethodType.Delete, out errorString);
+
+ return response;
+ }
+
+ [DataContract()]
+ private sealed class GetConfigurationDataRequest : GenericParameters
+ {
+
+ [HttpQueryMemberAttribute(Name = "config_key", EmitDefaultValue = false)]
+ public string config_key
+ {
+ get { return m_config_key; }
+ set { m_config_key = value; }
+ }
+
+ private string m_config_key;
+ }
+
+ public MemberConfigurationDataRersponse GetConfigurationData(MemberConfigurationParameters confParams, out string errorString)
+ {
+ GetConfigurationDataRequest mParams = default(GetConfigurationDataRequest);
+ mParams = new GetConfigurationDataRequest();
+ if ((confParams != null))
+ {
+ mParams.config_key = confParams.config_key;
+ }
+
+ MemberConfigurationDataRersponse response = GetJsonObjectFromAPI(mParams, R4MEInfrastructureSettings.UserConfiguration, HttpMethodType.Get, out errorString);
+
+ return response;
+ }
+
+ public MemberConfigurationResponse UpdateConfigurationKey(MemberConfigurationParameters confParams, out string errorString)
+ {
+ MemberConfigurationResponse response = GetJsonObjectFromAPI(confParams, R4MEInfrastructureSettings.UserConfiguration, HttpMethodType.Put, out errorString);
+
+ return response;
+ }
+
+ #endregion
+
+ #region Address Notes
+
+ public AddressNote[] GetAddressNotes(NoteParameters noteParameters, out string errorString)
+ {
+ AddressParameters addressParameters = new AddressParameters()
+ {
+ RouteId = noteParameters.RouteId,
+ RouteDestinationId = noteParameters.AddressId,
+ Notes = true
+ };
+ Address address = this.GetAddress(addressParameters, out errorString);
+ if (address != null)
+ {
+ return address.Notes;
+ }
+ else
+ {
+ return null;
+ }
+ }
+
+ [DataContract]
+ private sealed class AddAddressNoteResponse
+ {
+ [DataMember(Name = "status")]
+ public bool Status { get; set; }
+
+ [DataMember(Name = "note")]
+ public AddressNote Note { get; set; }
+ }
+
+ public AddressNote AddAddressNote(NoteParameters noteParameters, string noteContents, string attachmentFilePath, out string errorString)
+ {
+ var strUpdateType = "unclassified";
+ if (noteParameters.ActivityType != null && noteParameters.ActivityType.Length > 0)
+ {
+ strUpdateType = noteParameters.ActivityType;
+ }
+ HttpContent httpContent = null;
+ FileStream attachmentFileStream = null;
+ StreamContent attachmentStreamContent = null;
+ if (attachmentFilePath != null)
+ {
+ attachmentFileStream = File.OpenRead(attachmentFilePath);
+ attachmentStreamContent = new StreamContent(attachmentFileStream);
+ MultipartFormDataContent multipartFormDataContent = new MultipartFormDataContent();
+ multipartFormDataContent.Add(attachmentStreamContent, "strFilename", Path.GetFileName(attachmentFilePath));
+ multipartFormDataContent.Add(new StringContent(strUpdateType), "strUpdateType");
+ multipartFormDataContent.Add(new StringContent(noteContents), "strNoteContents");
+ httpContent = multipartFormDataContent;
+ }
+ else
+ {
+ var keyValues = new List>();
+ keyValues.Add(new KeyValuePair("strUpdateType", strUpdateType));
+ keyValues.Add(new KeyValuePair("strNoteContents", noteContents));
+ httpContent = new FormUrlEncodedContent(keyValues);
+ }
+ AddAddressNoteResponse response = GetJsonObjectFromAPI(noteParameters,
+ R4MEInfrastructureSettings.AddRouteNotesHost,
+ HttpMethodType.Post,
+ httpContent,
+ out errorString);
+ if (attachmentStreamContent != null)
+ {
+ attachmentStreamContent.Dispose();
+ }
+ if (attachmentFileStream != null)
+ {
+ attachmentFileStream.Dispose();
+ }
+ if (response != null)
+ {
+ if (response.Note != null)
+ {
+ return response.Note;
+ }
+ else
+ {
+ if (response.Status == false)
+ {
+ errorString = "Note not added";
+ }
+ return null;
+ }
+ }
+ else
+ {
+ return null;
+ }
+ }
+
+ public AddressNote AddAddressNote(NoteParameters noteParameters, string noteContents, out string errorString)
+ {
+ return this.AddAddressNote(noteParameters, noteContents, null, out errorString);
+ }
+
+ #endregion
+
+ #region Activities
+
+ [DataContract]
+ private sealed class GetActivitiesResponse
+ {
+ [DataMember(Name = "results")]
+ public Activity[] Results { get; set; }
+
+ [DataMember(Name = "total")]
+ public uint Total { get; set; }
+ }
+
+ ///
+ /// Get Activity Feed
+ ///
+ /// Input parameters
+ /// Error string
+ /// List of Activity objects
+ public Activity[] GetActivityFeed(ActivityParameters activityParameters, out string errorString)
+ {
+ GetActivitiesResponse response = GetJsonObjectFromAPI(activityParameters,
+ R4MEInfrastructureSettings.ActivityFeedHost,
+ HttpMethodType.Get,
+ out errorString);
+ Activity[] result = null;
+ if (response != null)
+ {
+ result = response.Results;
+ }
+ return result;
+ }
+
+ [DataContract]
+ private sealed class LogCustomActivityResponse
+ {
+ [DataMember(Name = "status")]
+ public bool Status { get; set; }
+ }
+
+ ///
+ /// Create User Activity. Send custom message to Activity Stream.
+ ///
+ /// Input Activity object to add
+ /// Error string
+ /// True/False
+ public bool LogCustomActivity(Activity activity, out string errorString)
+ {
+ activity.PrepareForSerialization();
+ LogCustomActivityResponse response = GetJsonObjectFromAPI(activity,
+ R4MEInfrastructureSettings.ActivityFeedHost,
+ HttpMethodType.Post,
+ out errorString);
+ if (response != null && response.Status)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ #endregion
+
+ #region Destinations
+
+ public Address GetAddress(AddressParameters addressParameters, out string errorString)
+ {
+ var result = GetJsonObjectFromAPI(addressParameters,
+ R4MEInfrastructureSettings.GetAddress,
+ HttpMethodType.Get,
+ out errorString);
+
+ return result;
+ }
+
+ [DataContract]
+ private sealed class AddRouteDestinationRequest : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId { get; set; }
+
+ [DataMember(Name = "addresses", EmitDefaultValue = false)]
+ public Address[] Addresses { get; set; }
+
+ ///
+ /// If true, an address will be inserted at optimal position of a route
+ ///
+ [DataMember(Name = "optimal_position", EmitDefaultValue = true)]
+ public bool OptimalPosition { get; set; }
+ }
+
+ ///
+ /// Add address(es) into a route.
+ ///
+ /// Route ID
+ /// Valid array of Address objects.
+ /// If true, an address will be inserted at optimal position of a route
+ /// out: Error as string
+ /// IDs of added addresses
+ public int[] AddRouteDestinations(string routeId, Address[] addresses, bool optimalPosition, out string errorString)
+ {
+ AddRouteDestinationRequest request = new AddRouteDestinationRequest()
+ {
+ RouteId = routeId,
+ Addresses = addresses,
+ OptimalPosition = optimalPosition
+ };
+ DataObject response = GetJsonObjectFromAPI(request,
+ R4MEInfrastructureSettings.RouteHost,
+ HttpMethodType.Put,
+ out errorString);
+ int[] destinationIds = null;
+ if (response != null && response.Addresses != null)
+ {
+ List arrDestinationIds = new List();
+ foreach (Address addressNew in addresses)
+ {
+ int destinationId = 0;
+ foreach (Address addressResp in response.Addresses)
+ {
+ if (addressResp.AddressString == addressNew.AddressString
+ && addressResp.Latitude == addressNew.Latitude
+ && addressResp.Longitude == addressNew.Longitude
+ && addressResp.RouteDestinationId != null)
+ {
+ destinationId = (int)addressResp.RouteDestinationId;
+ }
+ }
+ arrDestinationIds.Add(destinationId);
+ }
+ destinationIds = arrDestinationIds.ToArray();
+ }
+ return destinationIds;
+ }
+
+ ///
+ /// Add address(es) into a route.
+ ///
+ /// Route ID
+ /// Valid array of Address objects.
+ /// out: Error as string
+ /// IDs of added addresses
+ public int[] AddRouteDestinations(string routeId, Address[] addresses, out string errorString)
+ {
+ return this.AddRouteDestinations(routeId, addresses, true, out errorString);
+ }
+
+
+ [DataContract]
+ private sealed class RemoveRouteDestinationRequest : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId { get; set; }
+
+ [HttpQueryMemberAttribute(Name = "route_destination_id", EmitDefaultValue = false)]
+ public int RouteDestinationId { get; set; }
+ }
+
+ [DataContract]
+ private sealed class RemoveRouteDestinationResponse
+ {
+ [DataMember(Name = "deleted")]
+ public Boolean Deleted { get; set; }
+
+ [DataMember(Name = "route_destination_id")]
+ public int RouteDestinationId { get; set; }
+ }
+
+ public bool RemoveRouteDestination(string routeId, int destinationId, out string errorString)
+ {
+ RemoveRouteDestinationRequest request = new RemoveRouteDestinationRequest()
+ {
+ RouteId = routeId,
+ RouteDestinationId = destinationId
+ };
+ RemoveRouteDestinationResponse response = GetJsonObjectFromAPI(request,
+ R4MEInfrastructureSettings.GetAddress,
+ HttpMethodType.Delete,
+ out errorString);
+ if (response != null && response.Deleted)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+
+ [DataContract]
+ private sealed class MoveDestinationToRouteResponse
+ {
+ [DataMember(Name = "success")]
+ public Boolean Success { get; set; }
+
+ [DataMember(Name = "error")]
+ public string error { get; set; }
+ }
+
+ public bool MoveDestinationToRoute(string toRouteId, int routeDestinationId, int afterDestinationId, out string errorString)
+ {
+ var keyValues = new List>();
+ keyValues.Add(new KeyValuePair("to_route_id", toRouteId));
+ keyValues.Add(new KeyValuePair("route_destination_id", Convert.ToString(routeDestinationId)));
+ keyValues.Add(new KeyValuePair("after_destination_id", Convert.ToString(afterDestinationId)));
+ HttpContent httpContent = new FormUrlEncodedContent(keyValues);
+
+ MoveDestinationToRouteResponse response = GetJsonObjectFromAPI(new GenericParameters(),
+ R4MEInfrastructureSettings.MoveRouteDestination,
+ HttpMethodType.Post,
+ httpContent,
+ out errorString);
+ if (response != null)
+ {
+ if (!response.Success && response.error != null)
+ {
+ errorString = response.error;
+ }
+ return response.Success;
+ }
+ return false;
+ }
+
+ [DataContract]
+ private sealed class MarkAddressDepartedRequest : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId
+ {
+ get { return m_RouteId; }
+ set { m_RouteId = value; }
+ }
+ private string m_RouteId;
+
+ [HttpQueryMemberAttribute(Name = "address_id", EmitDefaultValue = false)]
+ public System.Nullable AddressId
+ {
+ get { return m_AddressId; }
+ set { m_AddressId = value; }
+ }
+ private System.Nullable m_AddressId;
+
+ [IgnoreDataMember()]
+ [HttpQueryMemberAttribute(Name = "is_departed", EmitDefaultValue = false)]
+ public bool IsDeparted
+ {
+ get { return m_IsDeparted; }
+ set { m_IsDeparted = value; }
+ }
+ private bool m_IsDeparted;
+
+ [IgnoreDataMember()]
+ [HttpQueryMemberAttribute(Name = "is_visited", EmitDefaultValue = false)]
+ public bool IsVisited
+ {
+ get { return m_IsVisited; }
+ set { m_IsVisited = value; }
+ }
+ private bool m_IsVisited;
+
+ [HttpQueryMemberAttribute(Name = "member_id", EmitDefaultValue = false)]
+ public System.Nullable MemberId
+ {
+ get { return m_MemberId; }
+ set { m_MemberId = value; }
+ }
+ private System.Nullable m_MemberId;
+ }
+
+ public int MarkAddressVisited(AddressParameters aParams, out string errorString)
+ {
+ MarkAddressDepartedRequest request = new MarkAddressDepartedRequest
+ {
+ RouteId = aParams.RouteId,
+ AddressId = aParams.AddressId,
+ IsVisited = aParams.IsVisited,
+ MemberId = 1
+ };
+
+ string response = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.MarkAddressVisited, HttpMethodType.Get, out errorString);
+ int iResponse = 0;
+ if (int.TryParse(response.ToString(), out iResponse)) iResponse = Convert.ToInt32(response);
+ return iResponse;
+ }
+
+ [DataContract]
+ private sealed class MarkAddressDepartedResponse
+ {
+ [DataMember(Name = "status")]
+ public Boolean Status { get; set; }
+
+ [DataMember(Name = "error")]
+ public string error { get; set; }
+ }
+
+ public int MarkAddressDeparted(AddressParameters aParams, out string errorString)
+ {
+ MarkAddressDepartedRequest request = new MarkAddressDepartedRequest
+ {
+ RouteId = aParams.RouteId,
+ AddressId = aParams.AddressId,
+ IsDeparted = aParams.IsDeparted,
+ MemberId = 1
+ };
+
+ MarkAddressDepartedResponse response = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.MarkAddressDeparted, HttpMethodType.Get, out errorString);
+
+ if (response != null)
+ {
+ if (response.Status) return 1; else return 0;
+ } else return 0;
+ }
+
+ [DataContract()]
+ private sealed class MarkAddressAsMarkedAsDepartedRequest : GenericParameters
+ {
+
+ [HttpQueryMemberAttribute(Name = "route_id", EmitDefaultValue = false)]
+ public string RouteId
+ {
+ get { return m_RouteId; }
+ set { m_RouteId = value; }
+ }
+
+ private string m_RouteId;
+ [HttpQueryMemberAttribute(Name = "route_destination_id", EmitDefaultValue = false)]
+ public System.Nullable RouteDestinationId
+ {
+ get { return m_RouteDestinationId; }
+ set { m_RouteDestinationId = value; }
+ }
+
+ private System.Nullable m_RouteDestinationId;
+ [IgnoreDataMember()]
+ [DataMember(Name = "is_departed")]
+ public bool IsDeparted
+ {
+ get { return m_IsDeparted; }
+ set { m_IsDeparted = value; }
+ }
+
+ private bool m_IsDeparted;
+ [IgnoreDataMember()]
+ [DataMember(Name = "is_visited")]
+ public bool IsVisited
+ {
+ get { return m_IsVisited; }
+ set { m_IsVisited = value; }
+ }
+ private bool m_IsVisited;
+ }
+
+ public Address MarkAddressAsMarkedAsVisited(AddressParameters aParams, out string errorString)
+ {
+ MarkAddressAsMarkedAsDepartedRequest request = new MarkAddressAsMarkedAsDepartedRequest
+ {
+ RouteId = aParams.RouteId,
+ RouteDestinationId = aParams.RouteDestinationId,
+ IsVisited = aParams.IsVisited
+ };
+
+ Address response = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.GetAddress, HttpMethodType.Put, out errorString);
+
+ return response;
+ }
+
+ public Address MarkAddressAsMarkedAsDeparted(AddressParameters aParams, out string errorString)
+ {
+ MarkAddressAsMarkedAsDepartedRequest request = new MarkAddressAsMarkedAsDepartedRequest
+ {
+ RouteId = aParams.RouteId,
+ RouteDestinationId = aParams.RouteDestinationId,
+ IsDeparted = aParams.IsDeparted
+ };
+
+ Address response = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.GetAddress, HttpMethodType.Put, out errorString);
+
+ return response;
+ }
+
+ #endregion
+
+ #region Address Book
+
+ [DataContract]
+ private sealed class GetAddressBookContactsResponse
+ {
+ [DataMember(Name = "results")]
+ public AddressBookContact[] Results { get; set; }
+
+ [DataMember(Name = "total")]
+ public uint Total { get; set; }
+ }
+
+ public AddressBookContact[] GetAddressBookContacts(AddressBookParameters addressBookParameters, out uint total, out string errorString)
+ {
+ total = 0;
+ var response = GetJsonObjectFromAPI(addressBookParameters,
+ R4MEInfrastructureSettings.AddressBook,
+ HttpMethodType.Get,
+ out errorString);
+ AddressBookContact[] result = null;
+ if (response != null)
+ {
+ result = response.Results;
+ total = response.Total;
+ }
+ return result;
+ }
+
+ public AddressBookContact[] GetAddressBookLocation(AddressBookParameters addressBookParameters, out uint total, out string errorString)
+ {
+ total = 0;
+
+ var response = GetJsonObjectFromAPI(addressBookParameters, R4MEInfrastructureSettings.AddressBook, HttpMethodType.Get, out errorString);
+ AddressBookContact[] result = null;
+ if (response != null)
+ {
+ result = response.Results;
+ total = response.Total;
+ }
+ return result;
+ }
+
+ [DataContract()]
+ private sealed class SearchAddressBookLocationRequest : GenericParameters
+ {
+ [HttpQueryMemberAttribute(Name = "query", EmitDefaultValue = false)]
+ public string Query
+ {
+ get { return m_Query; }
+ set { m_Query = value; }
+ }
+
+ private string m_Query;
+ [HttpQueryMemberAttribute(Name = "fields", EmitDefaultValue = false)]
+ public string Fields
+ {
+ get { return m_Fields; }
+ set { m_Fields = value; }
+ }
+
+ private string m_Fields;
+ [HttpQueryMemberAttribute(Name = "offset", EmitDefaultValue = false)]
+ public System.Nullable Offset
+ {
+ get { return m_Offset; }
+ set { m_Offset = value; }
+ }
+
+ private System.Nullable m_Offset;
+ [HttpQueryMemberAttribute(Name = "limit", EmitDefaultValue = false)]
+ public System.Nullable Limit
+ {
+ get { return m_Limit; }
+ set { m_Limit = value; }
+ }
+
+ private System.Nullable m_Limit;
+ }
+
+ [DataContract()]
+ private sealed class SearchAddressBookLocationResponse
+ {
+ [DataMember(Name = "results")]
+ public List Results
+ {
+ get { return m_Results; }
+ set { m_Results = value; }
+ }
+
+ private List m_Results;
+ [DataMember(Name = "total")]
+ public uint Total
+ {
+ get { return m_Total; }
+ set { m_Total = value; }
+ }
+
+ private uint m_Total;
+ [DataMember(Name = "fields")]
+ public string[] Fields
+ {
+ get { return m_Fields; }
+ set { m_Fields = value; }
+ }
+ private string[] m_Fields;
+ }
+
+ public List SearchAddressBookLocation(AddressBookParameters addressBookParameters, out uint total, out string errorString)
+ {
+ total = 0;
+
+ SearchAddressBookLocationRequest request = new SearchAddressBookLocationRequest
+ {
+ Query = addressBookParameters.Query,
+ Fields = addressBookParameters.Fields,
+ Offset = addressBookParameters.Offset >= 0 ? (int)addressBookParameters.Offset : 0,
+ Limit = addressBookParameters.Limit >= 0 ? (int)addressBookParameters.Limit : 0
+ };
+
+ var response = GetJsonObjectFromAPI(request, R4MEInfrastructureSettings.AddressBook, HttpMethodType.Get, out errorString);
+ List result = null;
+ if (response != null)
+ {
+ result = response.Results;
+ total = response.Total;
+ }
+ return result;
+ }
+
+ public AddressBookContact AddAddressBookContact(AddressBookContact contact, out string errorString)
+ {
+ contact.PrepareForSerialization();
+ AddressBookContact result = GetJsonObjectFromAPI(contact,
+ R4MEInfrastructureSettings.AddressBook,
+ HttpMethodType.Post,
+ out errorString);
+ return result;
+ }
+
+
+ public AddressBookContact UpdateAddressBookContact(AddressBookContact contact, out string errorString)
+ {
+ contact.PrepareForSerialization();
+ AddressBookContact result = GetJsonObjectFromAPI(contact,
+ R4MEInfrastructureSettings.AddressBook,
+ HttpMethodType.Put,
+ out errorString);
+ return result;
+ }
+
+
+ [DataContract]
+ private sealed class RemoveAddressBookContactsRequest : GenericParameters
+ {
+ [DataMember(Name = "address_ids", EmitDefaultValue = false)]
+ public string[] AddressIds { get; set; }
+ }
+
+ [DataContract]
+ private sealed class RemoveAddressBookContactsResponse
+ {
+ [DataMember(Name = "status")]
+ public bool Status { get; set; }
+ }
+
+ public bool RemoveAddressBookContacts(string[] addressIds, out string errorString)
+ {
+ RemoveAddressBookContactsRequest request = new RemoveAddressBookContactsRequest()
+ {
+ AddressIds = addressIds
+ };
+ RemoveAddressBookContactsResponse response = GetJsonObjectFromAPI(request,
+ R4MEInfrastructureSettings.AddressBook,
+ HttpMethodType.Delete,
+ out errorString);
+ if (response != null && response.Status)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ #endregion
+
+ #region Avoidance Zones
+
+ ///
+ /// Create avoidance zone
+ ///
+ /// Parameters for request
+ /// out: Error as string
+ /// Avoidance zone Object
+ public AvoidanceZone AddAvoidanceZone(AvoidanceZoneParameters avoidanceZoneParameters, out string errorString)
+ {
+ AvoidanceZone avoidanceZone = GetJsonObjectFromAPI(avoidanceZoneParameters,
+ R4MEInfrastructureSettings.Avoidance,
+ HttpMethodType.Post,
+ out errorString);
+ return avoidanceZone;
+ }
+
+ ///
+ /// Get avoidance zones
+ ///
+ /// Parameters for request
+ /// out: Error as string
+ /// Avoidance zone Object list
+ public AvoidanceZone[] GetAvoidanceZones(AvoidanceZoneQuery avoidanceZoneQuery, out string errorString)
+ {
+ AvoidanceZone[] avoidanceZones = GetJsonObjectFromAPI(avoidanceZoneQuery,
+ R4MEInfrastructureSettings.Avoidance,
+ HttpMethodType.Get,
+ out errorString);
+ return avoidanceZones;
+ }
+
+ ///
+ /// Get avoidance zone by parameters (territory id, device id)
+ ///
+ /// Parameters for request
+ /// out: Error as string
+ /// Avoidance zone Object
+ public AvoidanceZone GetAvoidanceZone(AvoidanceZoneQuery avoidanceZoneQuery, out string errorString)
+ {
+ AvoidanceZone avoidanceZone = GetJsonObjectFromAPI(avoidanceZoneQuery,
+ R4MEInfrastructureSettings.Avoidance,
+ HttpMethodType.Get,
+ out errorString);
+ return avoidanceZone;
+ }
+
+ ///
+ /// Update avoidance zone (by territory id, device id)
+ ///
+ /// Parameters for request
+ /// out: Error as string
+ /// Avoidance zone Object
+ public AvoidanceZone UpdateAvoidanceZone(AvoidanceZoneParameters avoidanceZoneParameters, out string errorString)
+ {
+ AvoidanceZone avoidanceZone = GetJsonObjectFromAPI(avoidanceZoneParameters,
+ R4MEInfrastructureSettings.Avoidance,
+ HttpMethodType.Put,
+ out errorString);
+ return avoidanceZone;
+ }
+
+ ///
+ /// Delete avoidance zone (by territory id, device id)
+ ///
+ /// Parameters for request
+ /// out: Error as string
+ /// Result status true/false
+ public bool DeleteAvoidanceZone(AvoidanceZoneQuery avoidanceZoneQuery, out string errorString)
+ {
+ GetJsonObjectFromAPI(avoidanceZoneQuery,
+ R4MEInfrastructureSettings.Avoidance,
+ HttpMethodType.Delete,
+ out errorString);
+ return errorString != "";
+ }
+
+ #endregion
+
+ #region Orders
+
+ [DataContract]
+ private sealed class GetOrdersResponse
+ {
+ [DataMember(Name = "results")]
+ public Order[] Results { get; set; }
+
+ [DataMember(Name = "total")]
+ public uint Total { get; set; }
+ }
+
+ ///
+ /// Get Orders
+ ///
+ /// Parameters for request
+ /// out: Total number of orders
+ /// out: Error as string
+ /// Order object list
+ public Order[] GetOrders(OrderParameters ordersQuery, out uint total, out string errorString)
+ {
+ total = 0;
+ GetOrdersResponse response = GetJsonObjectFromAPI(ordersQuery,
+ R4MEInfrastructureSettings.Order,
+ HttpMethodType.Get,
+ out errorString);
+ Order[] result = null;
+ if (response != null)
+ {
+ result = response.Results;
+ total = response.Total;
+ }
+ return result;
+ }
+
+ public Order[] GetOrderByID(OrderParameters orderQuery, out string errorString)
+ {
+ GetOrdersResponse response = GetJsonObjectFromAPI(orderQuery, R4MEInfrastructureSettings.Order, HttpMethodType.Get, out errorString);
+
+ return response.Results;
+ }
+
+ public Order[] SearchOrders(OrderParameters orderQuery, out string errorString)
+ {
+ GetOrdersResponse response = GetJsonObjectFromAPI(orderQuery, R4MEInfrastructureSettings.Order, HttpMethodType.Get, out errorString);
+
+ Order[] result = null;
+ if (response != null)
+ {
+ result = response.Results;
+ }
+ return result;
+ }
+
+ ///
+ /// Create Order
+ ///
+ /// Parameters for request
+ /// out: Error as string
+ /// Order object
+ public Order AddOrder(Order order, out string errorString)
+ {
+ order.PrepareForSerialization();
+ Order resultOrder = GetJsonObjectFromAPI(order,
+ R4MEInfrastructureSettings.Order,
+ HttpMethodType.Post,
+ out errorString);
+ return resultOrder;
+ }
+
+ ///
+ /// Update Order
+ ///
+ /// Parameters for request
+ /// out: Error as string
+ /// Order Object
+ public Order UpdateOrder(Order order, out string errorString)
+ {
+ order.PrepareForSerialization();
+ Order resultOrder = GetJsonObjectFromAPI(order,
+ R4MEInfrastructureSettings.Order,
+ HttpMethodType.Put,
+ out errorString);
+ return resultOrder;
+ }
+
+ [DataContract]
+ private sealed class RemoveOrdersRequest : GenericParameters
+ {
+ [DataMember(Name = "order_ids", EmitDefaultValue = false)]
+ public string[] OrderIds { get; set; }
+ }
+
+ [DataContract]
+ private sealed class RemoveOrdersResponse
+ {
+ [DataMember(Name = "status")]
+ public bool Status { get; set; }
+ }
+
+ ///